override public bool Init(ObjectInitParam param)
{
if (!base.Init(param))
{
return(false);
}
mHomePosition.x = mPosition.x;
mHomePosition.y = mPosition.y;
mHomePosition.z = mPosition.z;
mProperty = new RoleProperty();
mActionCenter = new BattleUnitActionCenter(this);
mSkillContainer = new BattleUnitSkillContainer();
mSkillEffectManager = new SkillEffectManager(this);
mActiveFlagsContainer = new ActiveFlagsContainer();
mRandEventContainer = new BattleUnitRandEventContainer();
mHitMaterialEffectCdContainer = new HitMaterialEffectCdContainer();
// 默认透明度为100.
SetBaseProperty((int)PropertyTypeEnum.PropertyTypeAlpha, 100);
// 默认硬直抗性为100.
SetBaseProperty((int)PropertyTypeEnum.PropertyTypeSpasticityResistance, 100);
SetBaseProperty((int)PropertyTypeEnum.PropertyTypeScale_Rate, 100);
return(true);
}
/// <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);
}
override public void Destroy()
{
if (mBattleUintAI != null)
{
mBattleUintAI.Destory();
mBattleUintAI = null;
}
if (mActionCenter != null)
{
mActionCenter.Destroy();
mActionCenter = null;
}
if (mSkillEffectManager != null)
{
SkillDetails.OnSkillEffectOwnerEvent(mSkillEffectManager, SkillEffectOwnerEventDef.OwnerLeaveScene);
mSkillEffectManager.Destroy();
mSkillEffectManager = null;
}
mActiveFlagsContainer = null;
mRandEventContainer = null;
mHitMaterialEffectCdContainer = null;
mProperty = null;
mUIShield = null;
base.Destroy();
for (int i = 0; i < mAttachMents.Length; ++i)
{
AttachMent attach = mAttachMents[i];
if (attach != null && attach.visual != null)
{
attach.visual.Destroy();
}
mAttachMents[i] = null;
}
}
/// <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);
}
/// <summary>
/// 开始位移.
/// </summary>
/// <param name="actionCenter">动作控制器</param>
/// <param name="attackerAttr">发起这次位移的单位的属性(如果是突进, 那么是角色本身; 如果是击退, 为发起击退技能的单位)</param>
/// <param name="displacementRes"></param>
/// <returns></returns>
public static ErrorCode StartDisplace(BattleUnitActionCenter actionCenter, AttackerAttr attackerAttr, uint displacementResID)
{
SkillDisplacementTableItem displacementRes = DataManager.DisplacementTable[displacementResID] as SkillDisplacementTableItem;
if (displacementRes == null)
{
SkillUtilities.ResourceNotFound("displacement", displacementResID);
return(ErrorCode.ConfigError);
}
// 免疫控制(有害的位移, 都视为控制).
if (!actionCenter.Owner.CanBeStuned() && displacementRes.harmful)
{
return(ErrorCode.AddEffectFailedSkillEffectImmunity);
}
if ((actionCenter.GetActionByType(ActionTypeDef.ActionTypeDisplacement) as ActionDisplacement) != null)
{
return(ErrorCode.MaxStackCount);
}
Vector3 ownerPosition = actionCenter.Owner.GetPosition();
Vector3 targetPosition = ownerPosition;
float distance = displacementRes.distance;
if (distance < 0)
{
return(ErrorCode.ConfigError);
}
Vector3 displaceDirection = Vector3.zero;
// 确定方向.
switch (displacementRes.displacementType)
{
case SkillDisplacementType.Rush:
displaceDirection = Utility.RadianToVector3(actionCenter.Owner.GetDirection());
break;
case SkillDisplacementType.Beatback:
displaceDirection = Utility.RadianToVector3(attackerAttr.EffectStartDirection);
break;
default:
return(ErrorCode.ConfigError);
}
displaceDirection.y = 0;
// 速度为负, 取反方向.
if (displacementRes.speed < 0f)
{
displaceDirection = Vector3.zero - displaceDirection;
}
// beatback时, 特殊处理距离与朝向.
if (displacementRes.displacementType == SkillDisplacementType.Beatback)
{
// 击退, 且速度为负时, 表示牵引向目标点.
if (displacementRes.speed < 0f)
{
float magnitude = displaceDirection.magnitude;
// 牵引的位置不会超过目标点的位置, 且与目标点的位置至少为0.5f.
if (magnitude < distance)
{
distance = Mathf.Max(0f, magnitude - 0.5f);
}
}
else // 击退时, 面朝起始点方向(后仰).
{
actionCenter.Owner.SetDirection(Utility.Vector3ToRadian(displaceDirection) + Mathf.PI);
}
}
displaceDirection.Normalize();
displaceDirection *= distance;
targetPosition += displaceDirection;
BaseScene scn = SceneManager.Instance.GetCurScene();
if (scn == null)
{
return(ErrorCode.LogicError);
}
targetPosition = scn.FarthestWalkable(ownerPosition, targetPosition);
ActionDisplacementInitParam param = new ActionDisplacementInitParam();
param.targetPosition = targetPosition;
param.displacementResource = displacementRes;
param.mAttackerAttr = attackerAttr;
return(actionCenter.StartAction(param));
}
/// <summary>
/// 开始硬直.
/// </summary>
public static ErrorCode StartSpasticity(BattleUnitActionCenter actionCenter,
AttackerAttr attackerAttr,
uint spasticityResID,
ref uint cdMilliseconds
)
{
if (cdMilliseconds != 0)
{
return(ErrorCode.CoolingDown);
}
// 无法被控制.
if (!actionCenter.Owner.CanBeStuned())
{
return(ErrorCode.AddEffectFailedSkillEffectImmunity);
}
// 硬直抗性.
int resistance = actionCenter.Owner.GetPropertyValue((int)PropertyTypeEnum.PropertyTypeSpasticityResistance);
// 硬直抗性不低于抗性最大值, 无法触发硬直.
if (resistance >= GameConfig.MaxSpasticityResistance)
{
return(ErrorCode.AddEffectFailedSkillEffectImmunity);
}
SkillSpasticityTableItem spasticityRes = DataManager.SkillSpasticityTable[spasticityResID] as SkillSpasticityTableItem;
if (spasticityRes == null)
{
SkillUtilities.ResourceNotFound("skillspasticity", spasticityResID);
return(ErrorCode.ConfigError);
}
Vector3 ownerPosition = actionCenter.Owner.GetPosition();
Vector3 targetPosition = ownerPosition;
Vector3 spasticityDirection = Utility.RadianToVector3(attackerAttr.EffectStartDirection);
spasticityDirection.y = 0;
// 被硬直的单位的朝向为硬直位移方向的反方向.
actionCenter.Owner.SetDirection(Utility.Vector3ToRadian(spasticityDirection) + Mathf.PI);
// 计算硬直位移的距离.
float distance = spasticityRes.distance;
// 如果硬直抗性低于默认值, 击退距离 *= (100 / 抗性).
if (resistance > 100)
{
resistance *= (100 / resistance);
}
spasticityDirection.Normalize();
spasticityDirection *= distance;
targetPosition += spasticityDirection;
BaseScene scn = SceneManager.Instance.GetCurScene();
if (scn == null)
{
return(ErrorCode.LogicError);
}
// 检测场景阻挡, 确定终点位置.
targetPosition = scn.FarthestWalkable(ownerPosition, targetPosition);
ActionSpasticityInitParam param = new ActionSpasticityInitParam();
param.spasticityRes = spasticityRes;
param.targetPosition = targetPosition;
param.mAttackerAttr = attackerAttr;
// 当前的硬直动作.
ActionSpasticity spasticityAction = actionCenter.GetActionByType(ActionTypeDef.ActionTypeSpasticity) as ActionSpasticity;
ErrorCode err = ErrorCode.Succeeded;
// 重新开始硬直.
err = (spasticityAction != null) ? spasticityAction.Restart(param) : actionCenter.StartAction(param);
if (err == ErrorCode.Succeeded)
{
// 硬直抗性, 可以用来增加硬直的CD时间.
cdMilliseconds = (uint)(param.spasticityRes.cdMilliseconds * resistance / 100f);
}
return(err);
}
