protected override ErrorCode doStart(ActionInitParam param)
{
ActionSkillInitParam asInit = param as ActionSkillInitParam;
mSkillUsing = asInit.skill;
mSkillUseStateLoopLeft = mSkillUsing.skillRes.skillUseStateLoopLeft;
mTaskManager = new SkillUtilities.TaskManager(onTaskFinished);
mOwner.EnterFightState();
if (IsRegularAttack)
{
//如果是普通攻击，武器播放射击动画
mOwner.PlayWeaponAnim(AnimationNameDef.WeaponFire);
}
if (mOwner.IsCanRotation() && mSkillUsing.skillRes.autoAim)
{
ownerLookAt(asInit.targetPosition);
}
SkillTargetPosition = asInit.targetPosition;
switch2State(ActionSkillState.Invalid);
return(canEnterState(ActionSkillState.Charging, asInit.targetPosition));
}
/// <summary>
/// 技能产生效果后.
/// </summary>
public static void OnSkillEffected(BattleUnit user, BattleUnitSkill skill)
{
// 在技能产生效果, 即子弹确保已经产生之后, 再扣子弹.
if (skill.skillRes.bulletCost != 0)
{
user.CostWeaponBullet((int)skill.skillRes.bulletCost);
}
}
/// <summary>
/// 技能正常结束之后.
/// </summary>
public static void OnSkillFinished(BattleUnit user, BattleUnitSkill skill)
{
// 只有非普通攻击, 才会触发攻击者的使用技能之后的随机事件.
if (!skill.IsRegularAttack)
{
user.ApplyRandEvent(null, RandEventTriggerType.OnSkillFinished, new OnSkillFinishedEventArg(skill.skillRes));
}
}
public void ResetSkillCD(int resID)
{
BattleUnitSkill skill = mSkillContainer[resID] as BattleUnitSkill;
if (skill != null)
{
skill.ResetCd();
}
}
/// <summary>
/// <para>向targetPosition使用技能.</para>
/// 如果targetPosition为zero, 那么会根据技能索敌等情况, 自动确定目标点.
/// </summary>
public ErrorCode UseSkill(int resID, Vector3 targetPosition)
{
if (mSkillContainer == null)
{
return(ErrorCode.InvalidParam);
}
if (mScene == null || mScene.isSafeScene())
{
return(ErrorCode.NotBattleScene);
}
BattleUnitSkill skill = mSkillContainer.GetSkill(resID);
if (skill == null)
{
return(ErrorCode.InvalidParam);
}
if (skill.IsRegularAttack)
{
// 使用武器技能时, 检查随机事件, 从而确定是否需要改变武器技能的ID.
StartRegularSkillEventArg argument = new StartRegularSkillEventArg((uint)resID);
ApplyRandEvent(null, RandEventTriggerType.OnStartRegularSkill, argument);
if (resID != (int)argument.SkillResID &&
(skill = mSkillContainer.GetSkill((int)argument.SkillResID)) == null)
{
return(ErrorCode.InvalidParam);
}
}
// 检查技能基本信息.
ErrorCode err = SkillUtilities.CheckSkillGeneralInfo(this, skill);
if (err != ErrorCode.Succeeded)
{
ErrorHandler.Parse(err, "failed to CheckSkillGeneralInfo");
return(err);
}
// 检查技能使用者的当前技能状态.
if ((err = SkillUtilities.CheckUserSkillUsingState(mActionCenter, skill)) != ErrorCode.Succeeded)
{
ErrorHandler.Parse(err, "failed to CheckUserSkillUsingState");
return(err);
}
// 无效的目标点, 重新确定目标点.
if (targetPosition == Vector3.zero &&
(!skill.skillRes.autoAim || (targetPosition = GetAimTargetPos()) == Vector3.zero))
{
targetPosition = Utility.MoveVector3Towards(GetPosition(), GetDirection(), 10f);
}
return(StartSkill(skill, targetPosition));
}
/// <summary>
/// 检查skill是否启用, CD时间, 消耗, 距离这些技能基本信息从而决定该技能可否使用.
/// </summary>
public static ErrorCode CheckSkillGeneralInfo(BattleUnit user, BattleUnitSkill skill, Vector3 startPosition, Vector3 targetPosition)
{
ErrorCode err = CheckSkillGeneralInfo(user, skill);
if (err != ErrorCode.Succeeded)
{
return(err);
}
return(CheckDistance(skill, startPosition, targetPosition));
}
/// <summary>
/// 检查skill是否启用, CD时间, 消耗这些技能基本信息<b>(与另一重载的区别在于该方法不检查距离)</b>从而决定该技能可否使用.
/// </summary>
public static ErrorCode CheckSkillGeneralInfo(BattleUnit user, BattleUnitSkill skill)
{
if (!skill.enabled)
{
return(ErrorCode.SkillDisabled);
}
if (!CheckSkillCd(skill))
{
return(ErrorCode.CoolingDown);
}
return(CheckCost(user, skill));
}
public float GetSkillCD(int skillID)
{
if (mSkillContainer == null)
{
return(0.0f);
}
BattleUnitSkill skill = mSkillContainer.GetSkill(skillID);
if (skill == null)
{
return(0.0f);
}
return(skill.CdMilliseconds);
}
public ErrorCode CheckSkillCost(int skillID)
{
if (mSkillContainer == null)
{
return(ErrorCode.InvalidParam);
}
BattleUnitSkill skill = mSkillContainer.GetSkill(skillID);
if (skill == null)
{
return(ErrorCode.InvalidParam);
}
return(SkillUtilities.CheckCost(this, skill));
}
public BattleUnitSkill GetSkill(int resID)
{
if (!mSkillContainer.ContainsKey(resID))
{
BattleUnitSkill skill = new BattleUnitSkill((uint)resID);
if (skill.skillRes == null)
{
return(null);
}
mSkillContainer.Add(resID, skill);
return(skill);
}
return(mSkillContainer[resID] as BattleUnitSkill);
}
protected override void onStopped(bool finished)
{
if (mSkillUsing.skillRes.buffToSkillUser != uint.MaxValue)
{
ErrorHandler.Parse(
mOwner.RemoveSkillBuffByResID(mSkillUsing.skillRes.buffToSkillUser),
"failed to remove skill buff on skill stopped"
);
}
if (finished)
{
SkillDetails.OnSkillFinished(mOwner, mSkillUsing);
}
mSkillUsing = null;
}
public static ErrorCode CheckCost(BattleUnit user, BattleUnitSkill skill)
{
if (skill.skillRes == null)
{
return(ErrorCode.InvalidParam);
}
if (user.GetPropertyValue((int)PropertyTypeEnum.PropertyTypeMana) < skill.skillRes.manaCost)
{
return(ErrorCode.InsufficientMana);
}
if (user.GetWeaponBullet() < skill.skillRes.bulletCost)
{
return(ErrorCode.InsufficientBullet);
}
return(ErrorCode.Succeeded);
}
/// <summary>
/// 对targetPosition使用skill技能.
/// </summary>
private ErrorCode StartSkill(BattleUnitSkill skill, Vector3 targetPosition)
{
if (skill == null)
{
return(ErrorCode.InvalidParam);
}
if (skill.IsRegularAttack)
{
if (!CanRegularAttack())
{
return(ErrorCode.UnableToAttack);
}
}
else if (!CanUseSkill())
{
return(ErrorCode.UnableToUseSkill);
}
return(SkillDetails.StartSkillAction(mActionCenter, skill, targetPosition));
}
/// <summary>
/// 创建技能Action. 开始向targetPosition使用技能.
/// </summary>
/// <remarks>
/// <para>普通攻击可以被其他非普通攻击, 无条件打断</para>
/// <para>非普通攻击只有在准备阶段, 且配置中指定了可被打断才可以被打断</para>
/// <para>非普通攻击被相同的技能打断, 表示从使用阶段切换到使用阶段</para>
/// 非普通攻击被其他技能打断, 直接停止当前技能, 开始新的技能.
/// </remarks>
public static ErrorCode StartSkillAction(BattleUnitActionCenter actionCenter,
BattleUnitSkill skill, Vector3 targetPosition)
{
if (skill == null)
{
return(ErrorCode.InvalidParam);
}
ActionSkill currentAs = actionCenter.GetActionByType(ActionTypeDef.ActionTypeSkill) as ActionSkill;
ErrorCode err = ErrorCode.Succeeded;
if (currentAs == null)
{
ActionSkillInitParam param = new ActionSkillInitParam();
param.skill = skill;
param.targetPosition = targetPosition;
err = actionCenter.StartAction(param);
if (err != ErrorCode.Succeeded)
{
return(err);
}
}
else
{
// 如果此时的currentAs不为null, 那么它必然为一个正在准备状态的技能且可以切换状态.
#if UNITY_EDITOR
if (!(currentAs.InChargingState && currentAs.Interruptable))
{
ErrorHandler.Parse(ErrorCode.LogicError, "技能处于错误的状态.");
}
#endif
err = currentAs.EnterUseState(targetPosition);
}
return(err);
}
public static ErrorCode CheckDistance(BattleUnitSkill skill, Vector3 startPosition, Vector3 targetPosition)
{
if (skill.skillRes == null)
{
return(ErrorCode.InvalidParam);
}
Vector3 v3 = targetPosition - startPosition;
v3.y = 0;
float magnitudeSquared = v3.sqrMagnitude;
if (magnitudeSquared < skill.skillRes.minRange * skill.skillRes.minRange)
{
return(ErrorCode.TooClose);
}
else if (magnitudeSquared > skill.skillRes.maxRange * skill.skillRes.maxRange)
{
return(ErrorCode.TooFar);
}
return(ErrorCode.Succeeded);
}
/// <summary>
/// 检查skill的CD时间, 返回该技能是否在CD中.
/// </summary>
public static bool CheckSkillCd(BattleUnitSkill skill)
{
return(skill.skillRes != null && skill.CdMilliseconds == 0);
}
public bool SameSkill(BattleUnitSkill skill)
{
return(mSkillUsing.skillRes.resID == skill.skillRes.resID);
}
/// <summary>
/// 技能开始使用.
/// </summary>
public static void OnSkillStarted(BattleUnit user, BattleUnitSkill skill)
{
// 消耗.
user.ModifyPropertyValue((int)PropertyTypeEnum.PropertyTypeMana, -((int)skill.skillRes.manaCost));
}
/// <summary>
/// 技能开始使用之后调用, 用来置CD.
/// 技能进入使用阶段才会设置CD, 也就是说, 如果一个技能在准备阶段不会设置CD.
/// </summary>
public static void OnActionEnterUseState(BattleUnit user, BattleUnitSkill skill)
{
// CD.
skill.lastUseTime = TimeUtilities.GetNow();
}
/// <summary>
/// 检查技能使用者的当前状态, 可否使用skill标识的技能, 并返回错误码.
/// </summary>
public static ErrorCode CheckUserSkillUsingState(BattleUnitActionCenter actionCenter, BattleUnitSkill skill)
{
ActionSkill currentAs = actionCenter.GetActionByType(ActionTypeDef.ActionTypeSkill) as ActionSkill;
if (currentAs == null)
{
return(ErrorCode.Succeeded);
}
// 当前正在进行技能动作.
// 执行相同的技能.
if (currentAs.SameSkill(skill))
{
// 正在使用阶段则无法被打断(因为是相同的技能, 不存在非普通攻击打断普通攻击的情况).
if (currentAs.InUsingState)
{
return(ErrorCode.SkillAlreadyUsing);
}
// 当前技能正在准备, 如果不能切换, 那么返回错误.
else if (!currentAs.Interruptable)
{
return(ErrorCode.SkillUninterruptable);
}
}
else // 其他技能使用.
{
// 普通攻击, 在任何情况下都被打断.
if (currentAs.IsRegularAttack)
{
}
// 非普通攻击, 在准备阶段. 检查它可否被打断.
else if (currentAs.InChargingState)
{
if (!currentAs.Interruptable)
{
return(ErrorCode.SkillUninterruptable);
}
}
// 非普通攻击, 在使用阶段.
else
{
return(ErrorCode.SkillAlreadyUsing);
}
// 当前的技能被打断.
actionCenter.RemoveActionByType(ActionTypeDef.ActionTypeSkill);
currentAs = null;
}
return(ErrorCode.Succeeded);
}
