1115 lines
48 KiB
C#
1115 lines
48 KiB
C#
using Games.AI_Logic;
|
||
using Games.GlobeDefine;
|
||
using Games.ImpactModle;
|
||
using Games.SkillModle;
|
||
using GCGame.Table;
|
||
using Module.Log;
|
||
using System.Collections.Generic;
|
||
using UnityEngine;
|
||
using UnityEngine.AI;
|
||
|
||
namespace Games.LogicObj
|
||
{
|
||
/// <summary>
|
||
/// 主角普攻和技能预判断模块
|
||
/// </summary>
|
||
public partial class Obj_MainPlayer
|
||
{
|
||
// 自动寻路并且使用技能时，释放距离减少的长度
|
||
public const float skillCastOverwalk = skillCastReduce + 0.2f;
|
||
|
||
// 客户端释放技能判定减少数值，注：普攻AoE类型技能无法用服务器补偿距离，因此统一客户端减损距离
|
||
public const float skillCastReduce = 0.5f;
|
||
|
||
public readonly List<OwnSkillData> simpleAttackSkills = new List<OwnSkillData>();
|
||
|
||
// 缓存跑商时禁用的技能表
|
||
private int[] _skillsBannedByEscort;
|
||
|
||
public int NextAttackIndex { get; private set; }
|
||
|
||
//按顺序存储所有普攻 策划需求普攻技能ID顺序不固定
|
||
private void SetSimpleAttackId()
|
||
{
|
||
if (simpleAttackSkills.Count < 1)
|
||
{
|
||
var simpleSkills = new List<OwnSkillData>();
|
||
for (var i = 0; i < OwnSkillInfo.Length; i++)
|
||
{
|
||
var skillInfo = OwnSkillInfo[i];
|
||
var skillBase = skillInfo.SkillBaseTable;
|
||
if (skillBase != null &&
|
||
skillBase.SkillClass.ContainFlag((int)SKILLCLASS.SIMPLEATTACK | (int)SKILLCLASS.ACTIVE))
|
||
{
|
||
var skillEx =
|
||
CommonUtility.TryGetTable(skillInfo.SkillId, a => TableManager.GetSkillExByID(a, 0));
|
||
if (skillEx != null)
|
||
simpleSkills.Add(skillInfo);
|
||
}
|
||
}
|
||
|
||
simpleAttackSkills.Clear();
|
||
if (simpleSkills.Count == 1)
|
||
{
|
||
simpleAttackSkills.Add(simpleSkills[0]);
|
||
}
|
||
else if (simpleSkills.Count > 0)
|
||
{
|
||
// 对SimpleSkills进行链表排序，从最后一段开始反向选择
|
||
var previousSkill = simpleSkills.Find(a => a.SkillExTable.NextSkillId <= 0);
|
||
if (previousSkill == null)
|
||
LogModule.ErrorLog(string.Format("职业{0}普攻配置是无限循环!", Profession));
|
||
else
|
||
while (previousSkill != null)
|
||
{
|
||
simpleAttackSkills.Add(previousSkill);
|
||
previousSkill = simpleSkills.Find(a =>
|
||
a.ComboExTable.NextSkillId == previousSkill.ComboExTable.SkillExID);
|
||
}
|
||
|
||
simpleAttackSkills.Reverse();
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 试图使用一个普攻技能
|
||
/// </summary>
|
||
public SkillCastableCheckResult TryStartSimpleAttack(bool breakAutoCombat = true)
|
||
{
|
||
var nextAttack = GetNextSimpleAttack();
|
||
if (nextAttack == null)
|
||
return SkillCastableCheckResult.FailOther;
|
||
return TryStartTargetSkill(nextAttack, breakAutoCombat: breakAutoCombat);
|
||
}
|
||
|
||
public override bool UseSkill(Tab_SkillEx skillEx, Tab_SkillBase skillBase, int firstSkillId, int targetId,
|
||
Vector3 facePoint, bool skipWindup = false)
|
||
{
|
||
// 优先更新技能冷却时间，以服务器为准
|
||
UpdateSkillCooldown(firstSkillId);
|
||
var result = base.UseSkill(skillEx, skillBase, firstSkillId, targetId, facePoint, skipWindup);
|
||
|
||
// 无需预测连段的技能，就在释放成功后立刻解除锁定
|
||
//if (skillBase.IsPredict < 1)
|
||
//RemovePredictSkill(skillEx.SkillExID);
|
||
return result;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 使用失败的技能，是否可以立刻被再次使用
|
||
/// </summary>
|
||
public bool CanFailedSkillBeUsed(SKILLUSEFAILTYPE failType)
|
||
{
|
||
return failType == SKILLUSEFAILTYPE.CE_IN_DEATH ||
|
||
failType == SKILLUSEFAILTYPE.CE_BACKSWINGCD1_NOT_COOL ||
|
||
failType == SKILLUSEFAILTYPE.CE_BACKSWINGCD2_NOT_COOL ||
|
||
failType == SKILLUSEFAILTYPE.CE_CUR_SKILL_CANNOT_BREAK ||
|
||
failType == SKILLUSEFAILTYPE.CE_MOUNT_FREEZE ||
|
||
failType == SKILLUSEFAILTYPE.CE_TARGET_IN_HIDING ||
|
||
failType == SKILLUSEFAILTYPE.CE_TARGET_ERROR;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 使用一个技能失败的接口
|
||
/// </summary>
|
||
public void FailSkill(int skillExId, int firstSkillId, SKILLUSEFAILTYPE failType)
|
||
{
|
||
var skillEx = TableManager.GetSkillExByID(firstSkillId, 0);
|
||
if (skillEx != null)
|
||
{
|
||
var canBeUsed = CanFailedSkillBeUsed(failType);
|
||
// 如果是普攻失败，回退普攻连段
|
||
if (!canBeUsed)
|
||
{
|
||
for (var i = 0; i < simpleAttackSkills.Count; i++)
|
||
if (simpleAttackSkills[i].IsValid() &&
|
||
simpleAttackSkills[i].SkillBaseTable.Id == skillEx.BaseId)
|
||
NextAttackIndex = 0;
|
||
}
|
||
if (skillExId == firstSkillId)
|
||
{
|
||
// 多段技能中，仅仅第一段技能会回退连段
|
||
// 注：三段以上技能出错后会混乱，但是当前逻辑可以保证两段技能无误
|
||
var ownSkill = OwnSkillInfo.Find(a => a.IsValid() && a.SkillBaseTable.Id == skillEx.BaseId);
|
||
if (ownSkill != null)
|
||
{
|
||
if (!canBeUsed)
|
||
ownSkill.CleanComboState();
|
||
if (!ownSkill.SkillBaseTable.SkillClass.ContainFlag((int)SKILLCLASS.SIMPLEATTACK))
|
||
{
|
||
// 记录使用技能出错的情况
|
||
var aiPlayerCombat = GetComponent<AI_PlayerCombat>();
|
||
if (aiPlayerCombat != null)
|
||
aiPlayerCombat.AddSkillFailRecord(skillEx.BaseId, canBeUsed);
|
||
}
|
||
}
|
||
RemovePredictByBaseId(skillEx.BaseId);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 试图使用一个目标指向技能
|
||
/// </summary>
|
||
/// <param name="ownSkill">技能数据</param>
|
||
/// <param name="attackPoint">技能目标位置</param>
|
||
/// <param name="breakAutoCombat">是否打断自动战斗</param>
|
||
/// <param name="target">攻击目标</param>
|
||
/// <returns>技能是否使用成功</returns>
|
||
public SkillCastableCheckResult TryStartTargetSkill(OwnSkillData ownSkill,
|
||
Vector2 attackPoint = default(Vector2),
|
||
Obj_Character target = null,
|
||
bool breakAutoCombat = true)
|
||
{
|
||
var castable = SkillCastableCheckResult.FailCasterDeath;
|
||
if (!IsDie())
|
||
{
|
||
castable = SkillCastableCheckResult.FailNoData;
|
||
// 已经预判当前技能，等待上一个包收到回复；非自动连续技普攻会自动升段，防止降段后一段时间无法使用普攻
|
||
if (IsPredictSkill && PredictSkillBase.Id == ownSkill.ComboBaseTable.Id &&
|
||
(!PredictSkillBase.SkillClass.ContainFlag((int)SKILLCLASS.SIMPLEATTACK) ||
|
||
PredictSkillBase.SkillClass.ContainFlag((int)SKILLCLASS.AUTOREPEAT)))
|
||
{
|
||
castable = SkillCastableCheckResult.FailCurrent;
|
||
}
|
||
// 如果角色正试图使用该技能，则忽略这次输入
|
||
else if (ownSkill.ComboExTable != PendingSkillEx)
|
||
{
|
||
// 无论技能是否释放，使用技能都是玩家主动操作，都应该解除自动战斗
|
||
if (breakAutoCombat)
|
||
BreakAutoCombatState();
|
||
// 检查特殊技能流程是否允许技能的使用
|
||
castable = SkillCastableCheckResult.Success;
|
||
if (castable == SkillCastableCheckResult.Success)
|
||
castable = CheckSkillCastable(ownSkill.SkillBaseTable, ownSkill.SkillExTable, ownSkill.IsCooldownFinish());
|
||
if (castable == SkillCastableCheckResult.Success)
|
||
{
|
||
// 非向目标释放技能，试图获得最适合目标
|
||
if (IsDisableState(DISABLESTATE.Disable_Select))
|
||
target = null;
|
||
else if (target == null && !ownSkill.ComboExTableFinal.IsTargetGround())
|
||
target = GetSkillTarget(ownSkill.ComboBaseTable, ownSkill.ComboExTableFinal);
|
||
if (target == null)
|
||
{
|
||
if (ownSkill.ComboBaseTable.IsReleaseWithoutTarget < 1)
|
||
{
|
||
// 技能不允许无目标释放，并且当前无目标时
|
||
GUIData.AddNotifyData(StrDictionary.GetClientDictionaryString("#{1246}"));
|
||
castable = SkillCastableCheckResult.FailNoTarget;
|
||
}
|
||
}
|
||
else if (target == enemyTarget
|
||
&& !ValidSkillPkCondition(ownSkill.ComboExTableFinal, ownSkill.ComboBaseTable, target))
|
||
{
|
||
castable = SkillCastableCheckResult.FailPkProtection;
|
||
}
|
||
|
||
if (castable == SkillCastableCheckResult.Success)
|
||
ProcessSkill(ownSkill, target, attackPoint);
|
||
}
|
||
}
|
||
}
|
||
|
||
return castable;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 检查一个技能是否可以被释放；该检查无视角色是否可以释放技能；
|
||
/// </summary>
|
||
public SkillCastableCheckResult CheckSkillCanBeCasted(Tab_SkillBase skillBase, Tab_SkillEx skillEx, bool isCDFinish)
|
||
{
|
||
if (skillBase == null || skillEx == null)
|
||
return SkillCastableCheckResult.FailNoData;
|
||
|
||
var result = SkillCastableCheckResult.Success;
|
||
// 任务类型判定条件
|
||
if (IsInPaoShang())
|
||
{
|
||
// 构造数据表缓存
|
||
if (_skillsBannedByEscort == null)
|
||
{
|
||
// Escort表是零散数据，应该是只有一列;
|
||
var escortData = TableManager.GetEscortByID(1, 0);
|
||
_skillsBannedByEscort = new int[escortData.getSkillLimitBaseIDCount()];
|
||
for (var i = 0; i < _skillsBannedByEscort.Length; i++)
|
||
_skillsBannedByEscort[i] = escortData.GetSkillLimitBaseIDbyIndex(i);
|
||
}
|
||
|
||
if (_skillsBannedByEscort.Contain(skillBase.Id))
|
||
result = SkillCastableCheckResult.FailMission;
|
||
}
|
||
|
||
if (result == SkillCastableCheckResult.Success)
|
||
{
|
||
var sceneTable = CommonUtility.TryGetTable(GameManager.gameManager.RunningScene,
|
||
a => TableManager.GetSceneClassByID(a, 0));
|
||
if (sceneTable != null && sceneTable.IsBanUseSkill > 0)
|
||
result = SkillCastableCheckResult.FailScene;
|
||
}
|
||
|
||
if (result == SkillCastableCheckResult.Success)
|
||
if (skillBase.SkillClass.ContainFlag((int)SKILLCLASS.AUTOREPEAT))
|
||
if (IsPredictSkill && IsSkillSequence(skillEx, PredictSkill) ||
|
||
IsUsingSkill && IsSkillSequence(skillEx, SkillCore.CurrentSkill))
|
||
result = SkillCastableCheckResult.FailAutoRepeat;
|
||
if (result == SkillCastableCheckResult.Success)
|
||
if (skillBase.SkillClass.ContainFlag((int)SKILLCLASS.SIMPLEATTACK))
|
||
{
|
||
if (!SkillAllowSimpleAttack)
|
||
result = SkillCastableCheckResult.FailOtherSkill;
|
||
}
|
||
// 技能判定条件
|
||
else
|
||
{
|
||
if (!SkillAllowSkill)
|
||
result = SkillCastableCheckResult.FailOtherSkill;
|
||
}
|
||
|
||
if (result == SkillCastableCheckResult.Success)
|
||
{
|
||
// 检测技能冷却时间
|
||
if (!isCDFinish)
|
||
result = SkillCastableCheckResult.FailCooldown;
|
||
}
|
||
|
||
// 检测消耗类型
|
||
if (result == SkillCastableCheckResult.Success)
|
||
result = CheckSkillCost(skillEx, 0);
|
||
if (result == SkillCastableCheckResult.Success)
|
||
result = CheckSkillCost(skillEx, 1);
|
||
// 检测单体技能情况
|
||
if (result == SkillCastableCheckResult.Success
|
||
&& skillBase.IsReleaseWithoutTarget < 1)
|
||
if (IsDisableState(DISABLESTATE.Disable_Select))
|
||
result = SkillCastableCheckResult.FailSelect;
|
||
return result;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 检查角色是否处于能够释放技能的状态；该检查无视技能本身是否可以释放；
|
||
/// </summary>
|
||
public SkillCastableCheckResult CheckCanCastSkill()
|
||
{
|
||
var result = SkillCastableCheckResult.Success;
|
||
if (MovementState > MoveState.MainPlayMove)
|
||
result = SkillCastableCheckResult.FailMovement;
|
||
else if (IsDisableState(DISABLESTATE.Disable_UseSkill))
|
||
result = SkillCastableCheckResult.FailDisable;
|
||
else if (SkillCore == null)
|
||
result = SkillCastableCheckResult.FailNoCore;
|
||
return result;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 检查角色是否可以释放某个技能；相当于CheckCanCastSkill + CheckSkillCanBeCasted；
|
||
/// </summary>
|
||
public SkillCastableCheckResult CheckSkillCastable(Tab_SkillBase skillBase, Tab_SkillEx skillEx, bool isCDFinish,
|
||
bool showWarning = true)
|
||
{
|
||
var result = CheckCanCastSkill();
|
||
if (result == SkillCastableCheckResult.Success)
|
||
result = CheckSkillCanBeCasted(skillBase, skillEx, isCDFinish);
|
||
if (showWarning)
|
||
switch (result)
|
||
{
|
||
case SkillCastableCheckResult.FailScene:
|
||
GUIData.AddNotifyData(StrDictionary.GetClientDictionaryString("#{2997}"));
|
||
break;
|
||
case SkillCastableCheckResult.FailMission:
|
||
GUIData.AddNotifyData(StrDictionary.GetClientDictionaryString("#{34001}"));
|
||
break;
|
||
case SkillCastableCheckResult.FailNoTarget:
|
||
GUIData.AddNotifyData(StrDictionary.GetClientDictionaryString("#{1246}"));
|
||
break;
|
||
case SkillCastableCheckResult.FailCostHp:
|
||
case SkillCastableCheckResult.FailCostHpRate:
|
||
SendNoticMsg(false, "#{1247}");
|
||
break;
|
||
case SkillCastableCheckResult.FailCostMp:
|
||
case SkillCastableCheckResult.FailCostMpRate:
|
||
SendNoticMsg(false, "#{1248}");
|
||
break;
|
||
case SkillCastableCheckResult.FailCostXp:
|
||
case SkillCastableCheckResult.FailCostXpRate:
|
||
SendNoticMsg(false, "#{1244}");
|
||
break;
|
||
case SkillCastableCheckResult.FailDisable:
|
||
GUIData.AddNotifyData(StrDictionary.GetClientDictionaryString("#{1249}"));
|
||
break;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新技能CD数值
|
||
/// </summary>
|
||
public void UpdateSkillCooldown(int skillId)
|
||
{
|
||
var skillEx = TableManager.GetSkillExByID(skillId, 0);
|
||
if (skillEx != null)
|
||
{
|
||
var ownSkill = OwnSkillInfo.Find(a => a.IsValid() && a.SkillBaseTable.Id == skillEx.BaseId);
|
||
if (ownSkill != null)
|
||
{
|
||
if (ownSkill.ComboBaseTable.UseType.ContainFlag((int)SKILLUSETYPE.YINCHANG))
|
||
{
|
||
}
|
||
// 连段技能除最后一段外，不增加CD
|
||
else if (ownSkill.FullCombo)
|
||
{
|
||
ownSkill.ResetCooldown();
|
||
//var nextSkill = OwnSkillInfo.Find(a => a.IsValid() && a.ComboBaseTable.Id == skillEx.BaseId);
|
||
//if (nextSkill != null)
|
||
// nextSkill.ResetCooldown();
|
||
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 前技能连段技能中，是否拥有后技能
|
||
/// </summary>
|
||
private bool IsSkillSequence(Tab_SkillEx a, Tab_SkillEx b)
|
||
{
|
||
var result = false;
|
||
if (a.BaseId == b.BaseId)
|
||
result = true;
|
||
else
|
||
while (a.NextSkillId > 0)
|
||
{
|
||
var skillEx = TableManager.GetSkillExByID(a.NextSkillId, 0);
|
||
if (skillEx == null)
|
||
break;
|
||
else if (skillEx.BaseId == b.BaseId)
|
||
{
|
||
result = true;
|
||
break;
|
||
}
|
||
else
|
||
a = skillEx;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
private SkillCastableCheckResult CheckSkillCost(Tab_SkillEx skillEx, int typeIndex)
|
||
{
|
||
var costType = (SKILLDELANDGAINTYPE)skillEx.GetDelTypebyIndex(typeIndex);
|
||
var costValue = skillEx.GetDelNumbyIndex(typeIndex);
|
||
return CheckForUseSkillNeed(costType, costValue);
|
||
}
|
||
|
||
private Obj_Character GetSkillTarget(Tab_SkillBase skillBase, Tab_SkillEx skillEx, int overrideTargetType = -1)
|
||
{
|
||
var targetType = overrideTargetType < 0 ? skillBase.PriorityTarget : overrideTargetType;
|
||
var result = ValidClientTarget(targetType);
|
||
if (result == null
|
||
|| result.IsDisableState(DISABLESTATE.Disable_BeSelect))
|
||
{
|
||
result = SearchSkillTarget(skillBase, skillEx, targetType);
|
||
}
|
||
//// 如果是方向攻击技能，需要额外检查是否有更符合方向选择的目标
|
||
//else if (IsDirectionalAttack(skillBase) && !IsDirectionalAttackTarget(skillBase, result))
|
||
//{
|
||
// var candidate = SearchSkillTarget(skillBase, skillEx, targetType);
|
||
// if (candidate != null && IsDirectionalAttackTarget(skillBase, candidate))
|
||
// result = candidate;
|
||
//}
|
||
return result;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 检测一个技能是否是方向索敌技能
|
||
/// </summary>
|
||
private static bool IsDirectionalAttack(Tab_SkillBase skillBase)
|
||
{
|
||
return skillBase.SearchEnemyAngle > 0f;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 检测目标是否满足方向条件
|
||
/// </summary>
|
||
private bool IsDirectionalAttackTarget(Tab_SkillBase skillBase, Obj_Character target)
|
||
{
|
||
var result = true;
|
||
if (IsDirectionalAttack(skillBase))
|
||
{
|
||
var targetDirection = target.Position - Position;
|
||
targetDirection.y = 0f;
|
||
if (targetDirection != Vector3.zero)
|
||
result = Vector3.Angle(GetCurrentInputDirectional(), targetDirection) < skillBase.SearchEnemyAngle;
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
private Vector3 GetCurrentInputDirectional()
|
||
{
|
||
// 获得控制器输入方向
|
||
var direction = ProcessInput.Instance == null
|
||
? Vector3.zero
|
||
: ProcessInput.Instance.GetCurrentInputDirectionInWorld();
|
||
// 控制器无输入方向时，使用默认角色方向
|
||
if (direction == Vector3.zero)
|
||
direction = m_ObjTransform.forward;
|
||
return direction;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 开始使用技能
|
||
/// </summary>
|
||
public bool ProcessSkill(OwnSkillData ownSkill, Obj_Character target, Vector2 attackPoint = default(Vector2))
|
||
{
|
||
CleanPendingSkill();
|
||
// 配置目标为当前选定目标；
|
||
if (target != null)
|
||
SetSelectTarget(target);
|
||
// 是否可以立刻释放技能
|
||
var success = true;
|
||
if (target != null)
|
||
{
|
||
success = ValidSkillRangeForNonDash(ownSkill.ComboExTableFinal, ownSkill.ComboBaseTable, target);
|
||
if (success)
|
||
{
|
||
// 冲锋类技能检查阻挡，检查失败时，会直接执行空放
|
||
var moveImpact = ownSkill.ComboExTableFinal.GetMoveSkillImpact();
|
||
if (moveImpact != null)
|
||
{
|
||
if (!CanDashToTarget(moveImpact, target))
|
||
{
|
||
attackPoint = target.Position.RemoveY() - Position.RemoveY();
|
||
target = null;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (success)
|
||
StartSkillAction(ownSkill, target, attackPoint);
|
||
else
|
||
CreatePendingSkill(ownSkill, target);
|
||
|
||
return success;
|
||
}
|
||
|
||
private bool StartSkillAction(OwnSkillData ownSkill, Obj_Character target,
|
||
Vector2 attackPoint = default(Vector2))
|
||
{
|
||
var skipTime = false;
|
||
var skillEx = ownSkill.ComboExTableFinal;
|
||
var skillBase = ownSkill.ComboBaseTable;
|
||
// 普攻特殊处理连段和跳过前摇条件
|
||
if (skillBase.SkillClass.ContainFlag((int)SKILLCLASS.SIMPLEATTACK))
|
||
{
|
||
// 提高普攻连段数目
|
||
NextAttackIndex++;
|
||
if (NextAttackIndex > simpleAttackSkills.Count - 1)
|
||
NextAttackIndex = 0;
|
||
skipTime = Time.time < SkillCore.CurrentSkillTime +
|
||
skillEx.ConnectCradleTime.ToClientTime();
|
||
}
|
||
|
||
// 特殊技能自行处理特殊运作规则
|
||
SetPredictSkill(ownSkill, skipTime);
|
||
// 不允许移动的技能，提前停止角色移动
|
||
if (skillBase.IsMove < 1)
|
||
{
|
||
StopMove();
|
||
// Hack：2018.08.17前 - 使用技能后，直接跳过停止帧，阻止Stop协议发出
|
||
// 然后在发送技能使用之前发送Stop协议
|
||
ResetNavAgentState();
|
||
// 2018.08.17按服务器需求，修改为使用技能跳过Stop包
|
||
//SendStopToServer();
|
||
}
|
||
// 特殊：可以移动切移动打断的技能，锁定操作一段时间
|
||
else if (skillBase.IsMoveBreak >= 1)
|
||
{
|
||
LockJoyStick();
|
||
}
|
||
|
||
SendUseSkillPacket(ownSkill, target, attackPoint);
|
||
// 必须发送协议后再提升，否则会发送下一段的SkillId
|
||
ownSkill.AddCombo();
|
||
return true;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 构造一个保证可以检定通过的TargetType
|
||
/// </summary>
|
||
/// <summary>
|
||
/// 检查目标是否处于Pk保护状态
|
||
/// </summary>
|
||
public bool ValidSkillPkCondition(Tab_SkillEx skillEx, Tab_SkillBase skillBase, Obj_Character target,
|
||
bool showWarning = true)
|
||
{
|
||
return !skillBase.PriorityTarget.ContainFlag(CharacterDefine.SkillBaseTargetType.enemy) ||
|
||
ValidPkProtection(target, showWarning);
|
||
}
|
||
|
||
public bool ValidPkProtection(Obj_Character target, bool showWarning = true)
|
||
{
|
||
var result = true;
|
||
if (target.ObjType == GameDefine_Globe.OBJ_TYPE.OBJ_OTHER_PLAYER)
|
||
{
|
||
var sceneData = TableManager.GetSceneClassByID(GameManager.gameManager.RunningScene, 0);
|
||
if (sceneData != null)
|
||
{
|
||
var pvpRule = TableManager.GetPVPRuleByID(sceneData.PVPRule, 0);
|
||
if (pvpRule != null)
|
||
if (target.BaseAttr.Level < pvpRule.ProtectLevel)
|
||
{
|
||
result = false;
|
||
if (showWarning)
|
||
SendNoticMsg(false, "#{1112}");
|
||
}
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 检查目标是否处于技能射程之内
|
||
/// </summary>
|
||
public bool ValidSkillRangeOnTarget(Tab_SkillEx skillEx, Tab_SkillBase skillBase, Obj_Character target,
|
||
bool isSearch = false, float rangeReduce = -1f)
|
||
{
|
||
bool result;
|
||
// 搜索范围不考虑寻路模型限制
|
||
if (isSearch)
|
||
{
|
||
if (rangeReduce < 0f)
|
||
rangeReduce = 0f;
|
||
var distance = DistanceToAnotherEdge(target);
|
||
result = distance < skillEx.SearchRadius - rangeReduce;
|
||
}
|
||
else
|
||
{
|
||
result = ValidSkillRangeForNonDash(skillEx, skillBase, target, rangeReduce);
|
||
if (result)
|
||
{
|
||
var moveImpact = skillEx.GetMoveSkillImpact();
|
||
if (moveImpact != null)
|
||
result = CanDashToTarget(moveImpact, target);
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 检查非冲锋类技能是否可以攻击目标，不作冲锋阻挡判定
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
public bool ValidSkillRangeForNonDash(Tab_SkillEx skillEx, Tab_SkillBase skillBase, Obj_Character target, float rangeReduce = -1f)
|
||
{
|
||
var distance = DistanceToAnotherEdge(target);
|
||
if (rangeReduce < 0f)
|
||
rangeReduce = skillCastReduce;
|
||
// 攻击距离不允许低于1f
|
||
return distance < Mathf.Max(1f, skillEx.Radius - rangeReduce);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 检查地形是否允许冲锋类型技能到达目标
|
||
/// </summary>
|
||
public bool CanDashToTarget(Tab_Impact moveImpact, Obj_Character target)
|
||
{
|
||
var result = true;
|
||
NavMeshHit hit;
|
||
if (NavMesh.Raycast(Position, target.Position, out hit, NavMesh.AllAreas))
|
||
{
|
||
// 冲锋逻辑额外增加一个冲锋攻击距离
|
||
var attackRange = moveImpact.LogicID == GlobeVar.chargeSkillLogicId
|
||
? moveImpact.GetBaseParamValuebyIndex(2) * 0.01f
|
||
: 0f;
|
||
// 如果碰撞位置处于目标半径内，视为允许攻击
|
||
result = target.BaseAttr != null && target.BaseAttr.RoleData != null
|
||
&& (hit.position - target.Position).RemoveY().sqrMagnitude <
|
||
(target.BaseAttr.RoleData.ModelRadius + attackRange).ToSquare();
|
||
}
|
||
return result;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 按照SkillBase里面的TargetType定义处理角色关系
|
||
/// </summary>
|
||
public static bool ValidTargetTypeBySkillBase(Obj_Character character, int targetType)
|
||
{
|
||
// 非激活角色不能作为目标
|
||
// 主角不是宠物，不可能有主人
|
||
var result = character.gameObject.activeSelf &&
|
||
!targetType.ContainFlag(CharacterDefine.SkillBaseTargetType.master);
|
||
// 对齐角色死亡标签
|
||
if (result)
|
||
result = targetType.ContainFlag(CharacterDefine.SkillBaseTargetType.die) == character.IsDie();
|
||
if (result)
|
||
if (character.ObjType == GameDefine_Globe.OBJ_TYPE.OBJ_MAIN_PLAYER)
|
||
{
|
||
result = targetType.ContainFlag(CharacterDefine.SkillBaseTargetType.self);
|
||
}
|
||
else
|
||
{
|
||
// 队友标签
|
||
result = targetType.ContainFlag(CharacterDefine.SkillBaseTargetType.team) &&
|
||
GameManager.gameManager.PlayerDataPool.IsTeamMem(character.GUID);
|
||
// 如果不是队友，才进行阵营判定
|
||
if (!result)
|
||
result = targetType.ContainFlag(CharacterDefine.SkillBaseTargetType.friend) &&
|
||
Reputation.IsFriend(character) ||
|
||
targetType.ContainFlag(CharacterDefine.SkillBaseTargetType.enemy) &&
|
||
Reputation.CanAttack(character);
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
public static TargetSelectOrder GetTargetSelectOrder(Tab_SkillEx skillEx)
|
||
{
|
||
TargetSelectOrder result;
|
||
var selector = skillEx.GetSkillSelector();
|
||
if (selector == null)
|
||
result = TargetSelectOrder.Distance;
|
||
else
|
||
{
|
||
switch (selector.GetRangParambyIndex(2))
|
||
{
|
||
case 0:
|
||
result = TargetSelectOrder.Distance;
|
||
break;
|
||
case 1:
|
||
result = TargetSelectOrder.Angle;
|
||
break;
|
||
case 2:
|
||
result = TargetSelectOrder.HealthRatio;
|
||
break;
|
||
case 3:
|
||
result = TargetSelectOrder.Health;
|
||
break;
|
||
default:
|
||
result = TargetSelectOrder.Distance;
|
||
break;
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
public float GetWeightByOrder(Obj_Character character, TargetSelectOrder selectOrder)
|
||
{
|
||
float result;
|
||
switch (selectOrder)
|
||
{
|
||
case TargetSelectOrder.Distance:
|
||
result = DistanceToAnotherEdge(character);
|
||
break;
|
||
case TargetSelectOrder.Angle:
|
||
result = Vector2.Angle(m_ObjTransform.forward.RemoveY(), (character.Position - Position).RemoveY());
|
||
break;
|
||
case TargetSelectOrder.HealthRatio:
|
||
{
|
||
var baseAttr = character.BaseAttr;
|
||
if (baseAttr == null || baseAttr.CurMaxHP <= 0)
|
||
result = float.MaxValue;
|
||
else
|
||
result = (float)baseAttr.HP / baseAttr.CurMaxHP;
|
||
}
|
||
break;
|
||
case TargetSelectOrder.Health:
|
||
{
|
||
var baseAttr = character.BaseAttr;
|
||
result = baseAttr == null ? float.MaxValue : baseAttr.HP;
|
||
}
|
||
break;
|
||
default:
|
||
result = 0f;
|
||
break;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
public Obj_Character SearchSkillTarget(Tab_SkillBase skillBase, Tab_SkillEx skillEx,
|
||
int overrideTargetType = -1)
|
||
{
|
||
Obj_Character result = null;
|
||
var targetType = overrideTargetType < 0 ? skillBase.PriorityTarget : overrideTargetType;
|
||
var candidates = new List<Obj_Character>();
|
||
if (ValidTargetTypeBySkillBase(this, targetType))
|
||
candidates.Add(this);
|
||
var targets = Singleton<ObjManager>.GetInstance().ObjPools;
|
||
foreach (var keyValue in targets)
|
||
{
|
||
var obj = keyValue.Value as Obj_Character;
|
||
if (obj != null && obj != this &&
|
||
obj.ServerID != ServerID && !obj.isInvisible &&
|
||
!obj.IsDisableState(DISABLESTATE.Disable_BeSelect) &&
|
||
ValidTargetTypeBySkillBase(obj, targetType) &&
|
||
ValidSkillRangeOnTarget(skillEx, skillBase, obj, true))
|
||
candidates.Add(obj);
|
||
}
|
||
var targetOrder = GetTargetSelectOrder(skillEx);
|
||
// 上一个目标权重值
|
||
var lastWeight = float.PositiveInfinity;
|
||
// 上一个目标是否处于直接距离
|
||
var lastInRange = false;
|
||
for (var i = 0; i < candidates.Count; i++)
|
||
{
|
||
var obj = candidates[i];
|
||
var inRange = ValidSkillRangeOnTarget(skillEx, skillBase, candidates[i]);
|
||
// 优先选择可以原地释放的目标
|
||
if (!lastInRange || inRange)
|
||
{
|
||
var weight = GetWeightByOrder(obj, targetOrder);
|
||
if (weight < lastWeight)
|
||
{
|
||
result = obj;
|
||
lastWeight = weight;
|
||
lastInRange = inRange;
|
||
}
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获得普攻技能的Ex
|
||
/// </summary>
|
||
public OwnSkillData GetFirstSimpleAttack()
|
||
{
|
||
OwnSkillData result = null;
|
||
SetSimpleAttackId();
|
||
if (simpleAttackSkills.Count > 0)
|
||
result = simpleAttackSkills[0];
|
||
return result;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获得下一次普攻的技能Ex
|
||
/// </summary>
|
||
public OwnSkillData GetNextSimpleAttack()
|
||
{
|
||
// 注：应该只需要在这个位置初始化普攻Id
|
||
// 无论任何逻辑，都不应该在不知道下一刀普攻技能的情况下调用普攻
|
||
SetSimpleAttackId();
|
||
OwnSkillData result = null;
|
||
if (simpleAttackSkills.Count > 0)
|
||
{
|
||
// 如果是自动连续技，则直接选中第一个普攻
|
||
if (simpleAttackSkills[0].SkillBaseTable.SkillClass.ContainFlag((int)SKILLCLASS.AUTOREPEAT))
|
||
NextAttackIndex = 0;
|
||
// 循环一圈回到第一段
|
||
else if (NextAttackIndex >= simpleAttackSkills.Count)
|
||
NextAttackIndex = 0;
|
||
// 如果是连段攻击，则检查是否满足连段条件
|
||
if (NextAttackIndex > 0)
|
||
if (IsPredictSkill
|
||
&& PredictSkillBase.SkillClass.ContainFlag((int)SKILLCLASS.SIMPLEATTACK)
|
||
&& PredictSkill.NextSkillId == simpleAttackSkills[NextAttackIndex].SkillId)
|
||
{
|
||
// 普攻可连段时间超过
|
||
// 超过平砍连接时间
|
||
if (Time.time > PredictSkillTime +
|
||
PredictSkill.ConnectNextSkillTime.ToClientTime())
|
||
NextAttackIndex = 0;
|
||
}
|
||
// 上次技能不是普攻，重置
|
||
else
|
||
{
|
||
NextAttackIndex = 0;
|
||
}
|
||
|
||
result = simpleAttackSkills[NextAttackIndex];
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
public override void EndSkillByBaseId(int baseId = -1)
|
||
{
|
||
base.EndSkillByBaseId(baseId);
|
||
// 非需要保持预测的技能，就直接关闭
|
||
if (PredictSkillBase != null && PredictSkillBase.IsPredict < 1)
|
||
RemovePredictByBaseId(PredictSkillBase.Id);
|
||
}
|
||
|
||
private void SendUseSkillPacket(OwnSkillData ownSkill, Obj_Character target, Vector2 attackPoint)
|
||
{
|
||
//发送技能使用包
|
||
// 之前逻辑是在发送技能使用数据包时，计算对应的数据，先保留这个结构
|
||
var useSkill = (CG_SKILL_USE)PacketDistributed.CreatePacket(MessageID.PACKET_CG_SKILL_USE);
|
||
useSkill.SetSkillId(ownSkill.ComboExTable.SkillExID);
|
||
//if (ownSkill.IsComboSkill())
|
||
// useSkill.SetFirststagekillid(ownSkill.SkillId);
|
||
var skillEx = ownSkill.ComboExTableFinal;
|
||
var skillBase = ownSkill.ComboBaseTable;
|
||
int dirRadian;
|
||
Vector2 worldAttackPoint;
|
||
// 在有目标的情况下，攻击位置以目标位置为准
|
||
if (target != null)
|
||
{
|
||
// 目标等于自己时，面朝方向配置为当前面向
|
||
if (target == this)
|
||
{
|
||
worldAttackPoint = Vector2.zero;
|
||
dirRadian = CommonUtility.DirToServerRadian(m_ObjTransform.forward.RemoveY());
|
||
}
|
||
// 目标不等于自己时，配置攻击方向为目标位置
|
||
else
|
||
{
|
||
worldAttackPoint = target.Position.RemoveY();
|
||
var attackDir = worldAttackPoint - Position.RemoveY();
|
||
dirRadian = CommonUtility.DirToServerRadian(attackDir);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// 校正普攻空放和冲锋技能
|
||
var isChargeForward = skillEx.MaxMoveDistance > 0 || skillEx.IsMoveSkill();
|
||
var isTargetGround = skillEx.IsTargetGround();
|
||
// 冲锋类和对地攻击类技能使用目标位置作为攻击点
|
||
if (isTargetGround || isChargeForward)
|
||
{
|
||
var selector = skillEx.GetSkillSelector();
|
||
var isLine = selector != null && selector.RangType == 3;
|
||
// 直线或者冲锋会补正AttackPoint到最大值
|
||
if (isLine || isChargeForward)
|
||
{
|
||
if (attackPoint == default(Vector2))
|
||
attackPoint = IsDirectionalAttack(skillBase)
|
||
? GetCurrentInputDirectional().RemoveY()
|
||
: ObjTransform.forward.RemoveY();
|
||
worldAttackPoint = Position.RemoveY();
|
||
// 陷阱类带冲锋属性直接使用落地位置；非陷阱类补正到最大攻击距离；
|
||
if (skillEx.MaxMoveDistance > 0)
|
||
worldAttackPoint += attackPoint * skillEx.MaxMoveDistance * 0.01f;
|
||
else if (selector != null && selector.RangCenter >= 1)
|
||
worldAttackPoint += attackPoint;
|
||
else
|
||
worldAttackPoint += attackPoint.normalized * skillEx.Radius;
|
||
// 冲锋额外使用行走区域碰撞进行补正
|
||
if (isChargeForward)
|
||
{
|
||
NavMeshHit hit;
|
||
if (NavMesh.Raycast(Position, worldAttackPoint.InsertY(Position.y), out hit,
|
||
NavMesh.AllAreas))
|
||
worldAttackPoint = hit.position.RemoveY();
|
||
}
|
||
}
|
||
else
|
||
worldAttackPoint = Position.RemoveY() + attackPoint;
|
||
var dir = worldAttackPoint - Position.RemoveY();
|
||
if (dir == default(Vector2))
|
||
dir = attackPoint;
|
||
dirRadian = CommonUtility.DirToServerRadian(dir);
|
||
}
|
||
// 非陷阱非冲锋不上传攻击目标点
|
||
else
|
||
{
|
||
worldAttackPoint = Vector2.zero;
|
||
if (attackPoint == default(Vector2))
|
||
attackPoint = IsDirectionalAttack(skillBase)
|
||
? GetCurrentInputDirectional().RemoveY()
|
||
: ObjTransform.forward.RemoveY();
|
||
dirRadian = CommonUtility.DirToServerRadian(attackPoint);
|
||
}
|
||
}
|
||
// 快速处理一个关于治疗链的问题留下的坑。
|
||
// 当前目标为自己时，不发送目标
|
||
if (target == this)
|
||
target = null;
|
||
useSkill.SetDesposx(Mathf.FloorToInt(worldAttackPoint.x * 100f));
|
||
useSkill.SetDespoxz(Mathf.FloorToInt(worldAttackPoint.y * 100f));
|
||
useSkill.SetFacedir(dirRadian);
|
||
useSkill.SetTargetId(target == null ? 0 : target.ServerID);
|
||
useSkill.SetRoleposx(Position.x.ToServerPos());
|
||
useSkill.SetRoleposy(Position.y.ToServerPos());
|
||
useSkill.SetRolepoxz(Position.z.ToServerPos());
|
||
useSkill.SendPacket();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 计算两个角色之间的距离，会减去对方体型半径，不减自己半径
|
||
/// </summary>
|
||
// 该方法仅主角可以使用，检查两个非主角应该都是用ServerPos
|
||
public float DistanceToAnotherEdge(Obj_Character character)
|
||
{
|
||
var result = Vector2.Distance(character.Position.RemoveY(), Position.RemoveY());
|
||
if (character.BaseAttr != null && character.BaseAttr.RoleData != null)
|
||
result = Mathf.Max(0f, result - character.BaseAttr.RoleData.ModelRadius);
|
||
return result;
|
||
}
|
||
|
||
#region 寻路到目标再释放技能
|
||
|
||
private bool CreatePendingSkill(OwnSkillData ownSkill, Obj_Character target)
|
||
{
|
||
var result = false;
|
||
// 自动战斗期间，不允许叠加其他自动逻辑
|
||
// 原始结构修改需要改一些架构，暂时用这个标志位检查处理
|
||
if (!isAutoCombat)
|
||
{
|
||
// 特殊处理 - 如果是普攻技能，降低到第一段普攻的距离标准
|
||
if (ownSkill.SkillBaseTable.SkillClass.ContainFlag((int)SKILLCLASS.SIMPLEATTACK))
|
||
ownSkill = GetFirstSimpleAttack();
|
||
if (MainPlayMoveToTarget(target, new MoveToTargetTillSkill(ownSkill),
|
||
new MoveSuccessToUseSkill(this, ownSkill)))
|
||
{
|
||
result = true;
|
||
PendingSkillEx = ownSkill.ComboExTable;
|
||
}
|
||
else
|
||
{
|
||
CleanPendingSkill();
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
// 注：PendingSkill使用不修正的SkillEx
|
||
public Tab_SkillEx PendingSkillEx { get; private set; }
|
||
|
||
// 注：打断行为的操作，应该同时覆盖行为
|
||
private void CleanPendingSkill()
|
||
{
|
||
PendingSkillEx = null;
|
||
}
|
||
|
||
#endregion
|
||
|
||
// 注：主角除了SkillCore以外，自身会额外预判技能使用条件
|
||
// 自身预判依照技能协议被发出时机为准，然后使用协议返回数值予以校正
|
||
// 因此玩家连招输入频率不受到稳定ping值的影响
|
||
// 预判断仅仅影响玩家输入指令，不影响角色对指令的响应
|
||
|
||
#region 主角预判断技能状态记录
|
||
|
||
// 预判断使用的技能
|
||
// 预判使用等级修正后技能
|
||
public Tab_SkillEx PredictSkill { get; private set; }
|
||
|
||
// 预判断使用的技能BaseInfo
|
||
public Tab_SkillBase PredictSkillBase { get; private set; }
|
||
|
||
// 预判断技能开始时间
|
||
public float PredictSkillTime { get; private set; }
|
||
|
||
// 是否预判断使用技能
|
||
public bool IsPredictSkill
|
||
{
|
||
get
|
||
{
|
||
return PredictSkill != null &&
|
||
PredictSkillTime + SkillDuration(PredictSkill, PredictSkillBase) > Time.time;
|
||
}
|
||
}
|
||
|
||
private void SetPredictSkill(OwnSkillData ownSkill, bool skipWindup)
|
||
{
|
||
PredictSkillTime = Time.time - (skipWindup ? ownSkill.ComboExTableFinal.CradleTime.ToClientTime() : 0f);
|
||
PredictSkill = ownSkill.ComboExTableFinal;
|
||
PredictSkillBase = ownSkill.ComboBaseTable;
|
||
}
|
||
|
||
private void RemovePredictByBaseId(int baseId = -1)
|
||
{
|
||
if (PredictSkill != null && (baseId < 0 || baseId == PredictSkill.BaseId))
|
||
{
|
||
PredictSkill = null;
|
||
PredictSkillBase = null;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 技能状态是否允许移动
|
||
/// </summary>
|
||
// 技能衔接移动的条件，由SkillCore为准；Predict数值仅保证协议返回前不被主角打断
|
||
public override bool SkillAllowMove
|
||
{
|
||
get
|
||
{
|
||
if (FollowState == TeamFollowState.followMove)
|
||
{
|
||
return base.SkillAllowMove;
|
||
}
|
||
|
||
var result = !IsUsingSkill || SkillCore.CurrentSkillBase.IsMove > 0 || Time.time >
|
||
SkillToSimpleDelay(SkillCore.CurrentSkill, SkillCore.CurrentSkillBase) +
|
||
SkillCore.CurrentSkillTime;
|
||
if (result)
|
||
result = PredictSkill == null || PredictSkillBase.IsMove > 0 || Time.time >
|
||
SkillToSimpleDelay(PredictSkill, PredictSkillBase) + PredictSkillTime;
|
||
return result;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 技能状态是否允许角色进行普攻
|
||
/// </summary>
|
||
public bool SkillAllowSimpleAttack
|
||
{
|
||
get
|
||
{
|
||
if (IsPredictSkill)
|
||
if (PredictSkillBase.IsMove > 0)
|
||
return false;
|
||
else
|
||
return Time.time > SkillToSimpleDelay(PredictSkill, PredictSkillBase) + PredictSkillTime;
|
||
return true;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 技能状态是否允许角色释放技能
|
||
/// </summary>
|
||
public bool SkillAllowSkill
|
||
{
|
||
get
|
||
{
|
||
if (IsPredictSkill)
|
||
return Time.time > SkillToSkillDelay(PredictSkill, PredictSkillBase) + PredictSkillTime;
|
||
return true;
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
}
|
||
|
||
/// <summary>
|
||
/// 技能是否可以释放检查结果
|
||
/// </summary>
|
||
public enum SkillCastableCheckResult
|
||
{
|
||
Success, // 可以释放
|
||
FailCasterDeath, // 技能释放者已死亡
|
||
FailCurrent, // 已经预测当前技能
|
||
FailNoData, // 技能数据无法找到
|
||
FailCooldown, // 技能处于CD中
|
||
FailDisable, // 角色不能释放技能
|
||
FailSelect, // 角色不能选定目标
|
||
FailOtherSkill, // 其他技能阻止释放
|
||
FailNoCore, // 没有SkillCore
|
||
FailNoOwnSkill, // 没有服务器返回的技能注册
|
||
FailMission, // 任务期间不允许使用该技能
|
||
FailNoTarget, // 单体选定技能没有目标的情况
|
||
FailAutoRepeat, // 自动连续技能不允许打断自己的后续
|
||
FailPkProtection, // 不允许攻击PK保护的目标
|
||
FailCostHp, // 技能生命消耗不足
|
||
FailCostHpRate, // 技能生命百分比消耗不足
|
||
FailCostMp, // 技能法力消耗不足
|
||
FailCostMpRate, // 技能法力百分比消耗不足
|
||
FailCostXp, // 技能Xp消耗不足
|
||
FailCostXpRate, // 技能Xp百分比消耗不足
|
||
FailMovement, // 特殊移动状态不允许使用技能
|
||
FailScene, // 当前场景不允许释放技能
|
||
FailOther // 其他情况
|
||
}
|
||
/// <summary>
|
||
/// 技能目标选择顺序
|
||
/// </summary>
|
||
public enum TargetSelectOrder
|
||
{
|
||
Distance, // 最小距离优先
|
||
Angle, // 最小角度优先
|
||
HealthRatio, // 生命百分比最低优先
|
||
Health, // 生命绝对值最低优先
|
||
}
|
||
} |