public override void onAttackDamage(Unit from, AttackConfig config, SkillTargetData targetData)
{
if (!_g12)
{
_m12 = instance.Type.GetMethod("onAttackDamage", 3);
_g12 = true;
}
if (_m12 != null && !_b12)
{
_b12 = true;
_p3[0] = from;
_p3[1] = config;
_p3[2] = targetData;
appdomain.Invoke(_m12, instance, _p3);
_p3[0] = null;
_p3[1] = null;
_p3[2] = null;
_b12 = false;
}
else
{
base.onAttackDamage(from, config, targetData);
}
}
public override void onDamage(Unit from, AttackConfig config, DamageOneData data)
{
if (!_g25)
{
_m25 = instance.Type.GetMethod("onDamage", 3);
_g25 = true;
}
if (_m25 != null && !_b25)
{
_b25 = true;
_p3[0] = from;
_p3[1] = config;
_p3[2] = data;
appdomain.Invoke(_m25, instance, _p3);
_p3[0] = null;
_p3[1] = null;
_p3[2] = null;
_b25 = false;
}
else
{
base.onDamage(from, config, data);
}
}
public override void onUnitDamage(Unit unit, Unit from, AttackConfig config, DamageOneData data)
{
if (!_g13)
{
_m13 = instance.Type.GetMethod("onUnitDamage", 4);
_g13 = true;
}
if (_m13 != null && !_b13)
{
_b13 = true;
_p4[0] = unit;
_p4[1] = from;
_p4[2] = config;
_p4[3] = data;
appdomain.Invoke(_m13, instance, _p4);
_p4[0] = null;
_p4[1] = null;
_p4[2] = null;
_p4[3] = null;
_b13 = false;
}
else
{
base.onUnitDamage(unit, from, config, data);
}
}
/** 攻击伤害来自服务器 */
public void onAttackDamageFromServer(int fromInstanceID, int attackID, int attackLevel, SkillTargetData targetData, SList <DamageOneData> damages)
{
Unit from = _scene.getFightUnit(fromInstanceID);
if (from == null)
{
return;
}
AttackConfig config = AttackConfig.get(attackID);
onAttackDamage(from, config, targetData);
//有伤害
if (damages != null && !damages.isEmpty())
{
Unit attaker = from.fight.getAttackerUnit();
foreach (DamageOneData v in damages)
{
Unit target = _scene.getFightUnit(v.instanceID);
if (target != null)
{
target.fight.onDamage(from, attaker, config, v);
}
}
}
}
/** 初始化碰撞系列的子弹所需 */
protected void initBulletForHit()
{
//自身打击跳过
if (!BaseC.constlist.bulletCast_isSelfHit(_levelConfig.castType))
{
calculateSpeedByAngle();
}
if (!_unit.isSelfDriveAttackHapen())
{
return;
}
_attackConfig = AttackConfig.get(_config.attackID);
_hitTimePass = 0;
_hitDelay = _config.hitDelay;
if (_hitTargetNums == null)
{
_hitTargetNums = new IntIntMap();
}
if (_tempUnitList == null)
{
_tempUnitList = new SList <Unit>();
}
}
protected override void toMakeTargets(SList <Unit> list, Unit from, Unit attacker, Unit mTarget, SkillTargetData tData, AttackConfig config, AttackLevelConfig levelConfig)
{
if (!_g13)
{
_m13 = instance.Type.GetMethod("toMakeTargets", 7);
_g13 = true;
}
if (_m13 != null && !_b13)
{
_b13 = true;
_p7[0] = list;
_p7[1] = from;
_p7[2] = attacker;
_p7[3] = mTarget;
_p7[4] = tData;
_p7[5] = config;
_p7[6] = levelConfig;
appdomain.Invoke(_m13, instance, _p7);
_p7[0] = null;
_p7[1] = null;
_p7[2] = null;
_p7[3] = null;
_p7[4] = null;
_p7[5] = null;
_p7[6] = null;
_b13 = false;
}
else
{
base.toMakeTargets(list, from, attacker, mTarget, tData, config, levelConfig);
}
}
void Start()
{
hitList = new List <Collider2D>();
playerData = GetComponentInParent <PlayerData>();
playerMovement = GetComponentInParent <PlayerMovement>();
attackConfig = GetComponentInParent <PlayerAttack>().attackConfig;
state = playerMovement.state;
}
public virtual void Start()
{
this.m_AttackConfig = this.GetComponent <AttackConfig>();
this.m_AttackScopeSqr = this.AttackScope * this.AttackScope;
this.m_AttackScopeArray = RoundHelper.FillCircle(0, 0, Mathf.CeilToInt(this.AttackScope /
Mathf.Min(ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.width,
ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.height)));
}
public virtual void onDamage(Unit from, AttackConfig config, DamageOneData data)
{
if (config.hitEffect > 0)
{
_unit.show.playEffect(config.hitEffect);
}
_scene.show.onUnitDamage(_unit, from, config, data);
}
/** 清空 */
public override void clear()
{
config = null;
levelConfig = null;
targetData = null;
fromInstanceID = -1;
isBulletFirstHit = false;
isRecorded = false;
}
public override void Init()
{
base.Init();
Utils.GetPlayerEventManager(Player.Player1).StartListening(EPlayerEvent.OnDeath, OnPlayerDeath);
Utils.GetPlayerEventManager(Player.Player2).StartListening(EPlayerEvent.OnDeath, OnPlayerDeath);
m_GameFlowManager = GameManager.Instance.GetSubManager <GameFlowSubGameManager>(ESubManager.GameFlow);
m_TimeManager = GameManager.Instance.GetSubManager <TimeScaleSubGameManager>(ESubManager.TimeScale);
m_GameConfig = GameConfig.Instance;
m_AttackConfig = AttackConfig.Instance;
}
public static AttackConfig Create()
{
AttackConfig asset = ScriptableObject.CreateInstance <AttackConfig>();
AssetDatabase.CreateAsset(asset, "Assets/Data/Resources/Attack/AttackConfig.asset");
AssetDatabase.SaveAssets();
EditorUtility.FocusProjectWindow();
Selection.activeObject = asset;
return(asset);
}
/** 单位受伤 */
public virtual void onUnitDamage(Unit unit, Unit from, AttackConfig config, DamageOneData data)
{
//需要显示
if (unit.isSelfControl() || from.isSelfControl())
{
foreach (DIntData v in data.damages)
{
Ctrl.print("受击伤害", v.value);
showOneDamage(unit, v.key, v.value);
}
}
}
void InitAllFX()
{
AttackConfig attackConfig = AttackConfig.Instance;
int hitFXCount = attackConfig.m_HitFX.Count;
for (int i = 0; i < hitFXCount; i++)
{
GameObject player1HitFXInstance = GameObject.Instantiate(attackConfig.m_HitFX[i].m_FX);
InitFXInstanceForPlayer(Player.Player1, ref player1HitFXInstance);
m_Player1HitFXInstances.Add((EHitFXType)i, new List <GameObject>()
{
player1HitFXInstance
});
GameObject player2HitFXInstance = GameObject.Instantiate(attackConfig.m_HitFX[i].m_FX);
InitFXInstanceForPlayer(Player.Player2, ref player2HitFXInstance);
m_Player2HitFXInstances.Add((EHitFXType)i, new List <GameObject>()
{
player2HitFXInstance
});
}
int otherFXCount = attackConfig.m_OtherFX.Count;
for (int i = 0; i < otherFXCount; i++)
{
GameObject player1OtherFXInstance = GameObject.Instantiate(attackConfig.m_OtherFX[i].m_FX);
InitFXInstanceForPlayer(Player.Player1, ref player1OtherFXInstance);
m_Player1OtherFXInstances.Add((EFXType)i, new List <GameObject>()
{
player1OtherFXInstance
});
GameObject player2OtherFXInstance = GameObject.Instantiate(attackConfig.m_OtherFX[i].m_FX);
InitFXInstanceForPlayer(Player.Player2, ref player2OtherFXInstance);
m_Player2OtherFXInstances.Add((EFXType)i, new List <GameObject>()
{
player2OtherFXInstance
});
}
}
/** 攻击伤害来自服务器 */
public void onAttackDamageFromServer(int fromInstanceID, int attackID, int attackLevel, SkillTargetData targetData, DamageOneData damage)
{
Unit from = _scene.getFightUnit(fromInstanceID);
if (from == null)
{
return;
}
AttackConfig config = AttackConfig.get(attackID);
onAttackDamage(from, config, targetData);
Unit attaker = from.fight.getAttackerUnit();
Unit target = _scene.getFightUnit(damage.instanceID);
if (target != null)
{
target.fight.onDamage(from, attaker, config, damage);
}
}
public override void dispose()
{
base.dispose();
_scenePosLogic = null;
_targetUnit = null;
_targetPosSource = null;
_attackConfig = null;
_hitEnabled = true;
_hitTimePass = 0;
_hitDelay = 0;
if (_hitTargetNums != null)
{
_hitTargetNums.clear();
}
if (_tempUnitList != null)
{
_tempUnitList.clear();
}
}
void AttemptSpecialAttack()
{
// HARDCODED!!
AttackConfig specialCfg = Array.Find <AttackConfig>(m_specialAttacks, x => x.type == AttackType.kStun);
if (m_eloquence < specialCfg.minCost)
{
Debug.LogFormat("Not enough eloquence for {0}. Needed: {1}, Had: {2}", specialCfg.type.ToString(), specialCfg.minCost, m_eloquence);
return;
}
if (m_specialAttackActiveStart >= 0)
{
Debug.LogFormat("Still launching special attack. Don't be greedy!");
return;
}
if (m_specialAttackCooldownStart >= 0)
{
float cooldownLeft = specialCfg.cooldown - (Time.time - m_specialAttackCooldownStart);
Debug.LogFormat("Special attack on cooldown. Wait for {0:F2} more s", cooldownLeft);
return;
}
m_specialAttackActiveStart = Time.time;
switch (specialCfg.type)
{
case AttackType.kStun:
{
if (m_vfxAttachment != null)
{
if (m_stunAreaVfxPrefab != null)
{
GameObject obj = Instantiate <GameObject>(m_stunAreaVfxPrefab);
obj.GetComponent <DelayedDeath>().Play(0.3f);
obj.GetComponent <ScaleWithAlpha>().Play(0.3f, 0.5f, 1.0f, 0.4f, 1.0f);
obj.transform.parent = m_vfxAttachment;
obj.transform.localPosition = new Vector3(0.0f, 0.0f, 0.0f);
}
if (m_WOTPrefab != null)
{
GameObject obj = Instantiate <GameObject>(m_WOTPrefab);
obj.GetComponent <DelayedDeath>().Play(1.5f);
obj.GetComponent <WallOfText>().Play(1.5f, TextManager.Instance.GetRandomWallOfText());
obj.transform.parent = m_vfxAttachment;
obj.transform.localPosition = new Vector3(0.0f, 0.0f, 0.0f);
}
}
break;
}
default: break;
}
m_eloquence -= specialCfg.minCost;
if (m_eloquence < 0.0f)
{
m_eloquence = 0.0f;
// Event?
}
if (m_eloquenceBar != null)
{
m_eloquenceBar.SetValue(m_eloquence / m_baseEloquence);
}
}
public override AttackConfig OnCharacterAttacked(ICharacter victim, ICharacter assailant, AttackConfig attack)
{
if (IsExpired() || attack.IsReflected)
{
return(attack);
}
ICharacter caster;
var success = casterRef.TryGetTarget(out caster);
if (success)
{
caster.BeAttacked(victim, new AttackConfig(attack.Damage, true));
return(new AttackConfig());
}
return(attack);
}
public DashAttackState(AttackConfig config)
: base(config, config.Owner.Config.DashAttackDistance * 0.9f, 0.5f)
{
}
public RangedAttackState(AttackConfig config) : base(config, 50.0f, 2.0f)
{
}
/** 选择出目标 */
protected virtual void toMakeTargets(SList <Unit> list, Unit from, Unit attacker, Unit mTarget, SkillTargetData tData, AttackConfig config, AttackLevelConfig levelConfig)
{
float[] scopeArgs = levelConfig.scopeArgs;
switch (levelConfig.scope)
{
case AttackScopeType.None:
{
}
break;
case AttackScopeType.Self:
{
if (attacker.fight.checkTargetInfluence(attacker, config.influenceTypeT))
{
list.add(attacker);
}
}
break;
case AttackScopeType.Single:
{
if (mTarget == null)
{
return;
}
if (attacker.fight.checkTargetInfluence(mTarget, config.influenceTypeT))
{
list.add(mTarget);
}
}
break;
case AttackScopeType.SelfCircle:
{
getCircleFightUnits(list, from.pos.getPos(), scopeArgs[0], scopeArgs.Length > 1?scopeArgs[1]:0, attacker, config.influenceTypeT);
}
break;
case AttackScopeType.TargetCircle:
{
PosData posData;
if ((posData = tData.pos) != null)
{
getCircleFightUnits(list, posData, scopeArgs[0], scopeArgs.Length > 1?scopeArgs[1]:0, attacker, config.influenceTypeT);
}
else if (mTarget != null)
{
getCircleFightUnits(list, mTarget.pos.getPos(), scopeArgs[0], scopeArgs.Length > 1?scopeArgs[1]:0, attacker, config.influenceTypeT);
}
}
break;
case AttackScopeType.SelfRect:
{
PosData fromPos = from.pos.getPos();
DirData dir;
PosData posData;
if ((posData = tData.pos) != null)
{
_scene.pos.calculateDirByPos(dir = _tempDir, fromPos, posData);
}
else if ((dir = tData.dir) != null)
{
}
else if (mTarget != null)
{
if (from == mTarget)
{
dir = from.pos.getDir();
}
else
{
_scene.pos.calculateDirByPos(dir = _tempDir, fromPos, mTarget.pos.getPos());
}
}
else
{
dir = from.pos.getDir();
}
getRectFightUnits(list, fromPos, dir, scopeArgs[0], scopeArgs[1], scopeArgs.Length > 2?scopeArgs[2]:0, attacker, config.influenceTypeT);
}
break;
case AttackScopeType.SelfSector:
{
PosData fromPos = from.pos.getPos();
DirData dir;
PosData posData;
if ((posData = tData.pos) != null)
{
_scene.pos.calculateDirByPos(dir = _tempDir, fromPos, posData);
}
else if ((dir = tData.dir) != null)
{
}
else if (mTarget != null)
{
if (from == mTarget)
{
dir = from.pos.getDir();
}
else
{
_scene.pos.calculateDirByPos(dir = _tempDir, fromPos, mTarget.pos.getPos());
}
}
else
{
dir = from.pos.getDir();
}
getSectorFightUnits(list, fromPos, dir, scopeArgs[0], scopeArgs[1], scopeArgs.Length > 2?scopeArgs[2]:0, attacker, config.influenceTypeT);
}
break;
case AttackScopeType.SelfCircleNear:
{
getCircleNearFightUnits(list, from.pos.getPos(), scopeArgs[0], (int)scopeArgs[1], scopeArgs.Length > 2?scopeArgs[2]:0, attacker, config.influenceTypeT);
}
break;
case AttackScopeType.SelfCircleRandom:
{
getCircleRandomFightUnits(list, from.pos.getPos(), scopeArgs[0], (int)scopeArgs[1], scopeArgs.Length > 2?scopeArgs[2]:0, attacker, config.influenceTypeT);
}
break;
case AttackScopeType.SelfNearest:
{
Unit reUnit = getNearestFightUnits(from.pos.getPos(), scopeArgs[0], scopeArgs.Length > 1 ? scopeArgs[1] : 0, attacker, config.influenceTypeT);
if (reUnit != null)
{
list.add(reUnit);
}
}
break;
case AttackScopeType.AttackRect:
case AttackScopeType.Around2D:
{
SRect rect;
if (levelConfig.scope == AttackScopeType.AttackRect)
{
rect = from.fight.getAttackBox(levelConfig);
}
else
{
rect = from.fight.getAttackAround2DBox(scopeArgs[0], scopeArgs[1]);
}
Unit[] values = _scene.getFightUnitDic().getValues();
Unit unit;
for (int i = values.Length - 1; i >= 0; --i)
{
if ((unit = values[i]) != null)
{
if (attacker.fight.checkTargetInfluence(unit, config.influenceTypeT))
{
if (rect.overlap(unit.fight.getSelfBox()))
{
list.add(unit);
}
}
}
}
}
break;
}
}
/** 执行攻击数据 */
private void toExecuteAttack(AttackData data)
{
Unit from = _scene.getFightUnit(data.fromInstanceID);
if (from == null)
{
return;
}
Unit attacker = from.fight.getAttackerUnit();
if (attacker == null)
{
return;
}
int attackerInstanceID = attacker.instanceID;
SkillTargetData tData = data.targetData;
AttackConfig config = data.config;
AttackLevelConfig levelConfig = data.levelConfig;
//主目标
Unit mTarget = _scene.getFightUnit(tData.targetInstanceID);
SList <Unit> tempTargets = new SList <Unit>();
//构造目标组
toMakeTargets(tempTargets, from, attacker, mTarget, tData, config, levelConfig);
Unit target;
//TODO:攻击前动作组
//如果跳过伤害阶段
if (config.passDamage)
{
for (int i = 0, len = tempTargets.size(); i < len; ++i)
{
target = tempTargets[i];
//不可被攻击
if (target.fight.getStatusLogic().cantBeAttackTarget())
{
continue;
}
//添加buff
if (levelConfig.addBuffProbID > 0)
{
if (attacker.fight.randomProb(levelConfig.addBuffProbID))
{
int adderInstanceID = attackerInstanceID == target.instanceID ? -1 :attackerInstanceID;
foreach (DIntData v in levelConfig.addBuffs)
{
target.fight.getBuffLogic().addBuff(v.key, v.value, adderInstanceID);
}
}
}
//有子弹
if (levelConfig.bullet.key > 0)
{
from.fight.createAndExecuteBullet(levelConfig.bullet.key, levelConfig.bullet.value, tData);
}
}
}
else
{
doAttackMoment(AttackMomentType.AttackBeforeHit, @from, attacker, null, data, null);
if (!tempTargets.isEmpty())
{
SList <Unit> tempKilledUnits = null;
SList <DamageOneData> damageDataList = new SList <DamageOneData>();
StatusDataLogic attackerStatus = attacker.fight.getStatusLogic();
AttributeDataLogic attackerAttribute = attacker.fight.getAttributeLogic();
BuffDataLogic attackerBuffLogic = attacker.fight.getBuffLogic();
StatusDataLogic targetStatus;
AttributeDataLogic targetAttribute;
bool momentHitted = false;
for (int i = 0, len = tempTargets.size(); i < len; ++i)
{
target = tempTargets[i];
targetStatus = target.fight.getStatusLogic();
targetAttribute = target.fight.getAttributeLogic();
//不可被攻击
if (targetStatus.cantBeAttackTarget())
{
continue;
}
//上次血量
int lastHp = targetAttribute.getHp();
DamageOneData damageOneData = new DamageOneData();
damageOneData.instanceID = target.instanceID;
damageDataList.add(damageOneData);
SList <DIntData> damageList = new SList <DIntData>();
damageOneData.damages = damageList;
damageOneData.isHit = toCountIsHit(data, attacker, target);
doAttackMoment(AttackMomentType.BeAttackBeforeHit, target, target, attacker, data, damageOneData);
int realDamage = 0;
if (damageOneData.isHit)
{
if (!momentHitted)
{
momentHitted = true;
doAttackMoment(AttackMomentType.AttackOnHitAnyTarget, @from, attacker, target, data, damageOneData);
}
if (target == mTarget)
{
doAttackMoment(AttackMomentType.AttackBeforeDamageMainTarget, @from, attacker, target, data, damageOneData);
}
doAttackMoment(AttackMomentType.AttackBeforeDamageEachTarget, @from, attacker, target, data, damageOneData);
doAttackMoment(AttackMomentType.BeAttackBeforeDamage, target, target, attacker, data, damageOneData);
//添加buff
if (levelConfig.addBuffProbID > 0)
{
if (attacker.fight.randomProb(levelConfig.addBuffProbID))
{
int adderInstanceID = attackerInstanceID == target.instanceID ? -1 :attackerInstanceID;
foreach (DIntData v in levelConfig.addBuffs)
{
target.fight.getBuffLogic().addBuff(v.key, v.value, adderInstanceID);
}
}
}
//有子弹
DIntData levelConfigBullet;
if ((levelConfigBullet = levelConfig.bullet).key > 0)
{
from.fight.createAndExecuteBullet(levelConfigBullet.key, levelConfigBullet.value, tData);
}
bool isCrit = damageOneData.isCrit = toCountIsCrit(data, attacker, target);
SkillVarConfig varConfig;
int[] damages;
int damageType;
int damageValue;
int attackValue;
int damageVarIndex = 0;
//伤害组
for (int j = 0, jLen = levelConfig.damages.Length; j < jLen; ++j)
{
varConfig = levelConfig.varConfigT[j];
damages = levelConfig.damages[j];
damageType = damages[0];
if (data.isRecorded)
{
attackValue = BaseGameUtils.calculateSkillVarValueForSelf(varConfig, data.selfAttackValues, damageVarIndex, target.fight.getDataLogic());
damageVarIndex += varConfig.args.Length;
}
else
{
attackValue = BaseGameUtils.calculateSkillVarValueFull(varConfig, attacker.fight.getDataLogic(), target.fight.getDataLogic());
}
damageValue = toCalculateDamage(data, damageType, damages, attackValue, isCrit, attackerAttribute, targetAttribute, attacker, target);
if (damageValue > 0)
{
if (needDamageHurt(damageType))
{
int rd = 0;
if (!targetStatus.isDamageImmun())
{
rd = takeDamage(damageType, damageValue, targetAttribute, target);
}
if (Global.damageValueUseRealDamage)
{
damageValue = rd;
}
realDamage += rd;
}
//TODO:反伤类
damageList.add(DIntData.create(damageType, damageValue));
}
}
if (realDamage > 0)
{
_scene.method.onUnitTakeDamage(target, realDamage, attacker);
}
if (target == mTarget)
{
doAttackMoment(AttackMomentType.AttackAfterDamageMainTarget, @from, attacker, target, data, damageOneData);
}
doAttackMoment(AttackMomentType.AttackAfterDamageEachTarget, @from, attacker, target, data, damageOneData);
doAttackMoment(AttackMomentType.BeAttackAfterDamage, target, target, attacker, data, damageOneData);
//扣除buff次数
attackerBuffLogic.subBuffNumArr(BuffSubNumType.UseAttackFromGroup, config.groups);
attackerBuffLogic.subBuffNumArr(BuffSubNumType.MakeDamage, levelConfig.damageTypesT);
target.fight.getBuffLogic().subBuffNumArr(BuffSubNumType.BeDamage, levelConfig.damageTypesT);
//血减到0
if (lastHp > 0 && targetAttribute.getAttribute(AttributeType.Hp) <= 0 && targetStatus.isAlive())
{
if (tempKilledUnits == null)
{
tempKilledUnits = new SList <Unit>();
}
tempKilledUnits.add(target);
}
}
//受伤(客户端受伤即使realDamage为0也需要)
target.fight.onDamage(from, attacker, config, damageOneData);
}
onAttackDamage(from, config, tData);
//处理击杀
if (tempKilledUnits != null)
{
for (int i = 0, len = tempKilledUnits.size(); i < len; ++i)
{
//活着
if ((target = tempKilledUnits[i]).fight.isAlive())
{
//被击杀时刻
doAttackMoment(AttackMomentType.BeforeBeKill, target, target, attacker, data, null);
//可被伤害击杀
if (!target.fight.getStatusLogic().cantBeKillByDamage())
{
target.fight.doDead(attacker, config.killType);
}
//击杀时刻
doAttackMoment(AttackMomentType.AfterKill, from, attacker, target, data, null);
}
}
}
}
doAttackMoment(AttackMomentType.AttackAfterHit, from, attacker, null, data, null);
}
}
// Update is called once per frame
void Update()
{
AttackConfig specialCfg = m_specialAttacks[m_selectedSpecialIdx];
bool specialAvailable = (m_eloquence >= specialCfg.minCost && m_specialAttackActiveStart < 0 && m_specialAttackCooldownStart < 0);
if (m_stunIcon != null)
{
Color c = m_stunIcon.color;
c.a = specialAvailable ? 1.0f : 0.5f;
m_stunIcon.color = c;
}
bool defaultAvailable = (m_eloquence >= m_defaultAttack.minCost && m_defaultAttackStart < 0);
if (m_insultIcon != null)
{
Color c = m_insultIcon.color;
c.a = defaultAvailable ? 1.0f : 0.5f;
m_insultIcon.color = c;
}
float xValue = Input.GetAxis("Horizontal");
float yValue = Input.GetAxis("Vertical");
Vector3 movement = Vector3.zero;
movement.x = xValue;
movement.y = yValue;
movement.Normalize();
movement *= m_baseSpeed;
if (m_animator != null)
{
m_animator.speed = (Mathf.Approximately(movement.magnitude, 0.0f)) ? 0.0f : 1.0f;
}
m_bodyRef.velocity = movement;
// Eloquence refill
if (m_eloquence < m_baseEloquence)
{
m_eloquence += m_refillRate * Time.deltaTime;
if (m_eloquence > m_baseEloquence)
{
m_eloquence = m_baseEloquence;
}
if (m_eloquenceBar != null)
{
m_eloquenceBar.SetValue(m_eloquence / m_baseEloquence);
}
}
if (m_defaultAttackStart >= 0 && Time.time - m_defaultAttackStart >= m_defaultAttack.cooldown)
{
m_defaultAttackStart = -1.0f;
}
AttackConfig specialConfig = m_specialAttacks[m_selectedSpecialIdx];
if (m_specialAttackActiveStart >= 0.0f)
{
if (Time.time - m_specialAttackActiveStart >= specialConfig.castTime)
{
m_specialAttackActiveStart = -1.0f;
m_specialAttackCooldownStart = Time.time;
}
else
{
float range = specialConfig.minRadius;
List <Enemy> enemiesInRange = GameManager.Instance.GetEnemiesInRange(transform.position, range);
int rangeNum = enemiesInRange.Count;
for (int i = 0; i < rangeNum; ++i)
{
enemiesInRange[i].OnPlayerUsedSpecialAttack(specialConfig.type, specialConfig.minEffectTime);
}
}
}
if (m_specialAttackCooldownStart >= 0.0f)
{
if (Time.time - m_specialAttackCooldownStart >= specialConfig.cooldown)
{
m_specialAttackCooldownStart = -1.0f;
}
else
{
// Update some stuff?
}
}
// Default attack stuff
if (Input.GetButtonDown(defaultAttackButtonName))
{
}
else if (Input.GetButtonUp(defaultAttackButtonName))
{
AttemptDefaultAttack();
}
else if (Input.GetButton(defaultAttackButtonName))
{
}
if (Input.GetButtonDown(specialAttackButtonName))
{
AttemptSpecialAttack();
}
else if (Input.GetButtonUp(specialAttackButtonName))
{
}
else if (Input.GetButton(specialAttackButtonName))
{
}
// Cycling specials
if (Input.GetButtonDown(cycleSpecialNextButtonName))
{
NextSpecial();
}
else if (Input.GetButtonDown(cycleSpecialPrevButtonName))
{
PrevSpecial();
}
}
/** 攻击伤害 */
public void onAttackDamage(Unit from, AttackConfig config, SkillTargetData targetData)
{
_scene.show.onAttackDamage(from, config, targetData);
}
public override AttackConfig OnCharacterAttacked(ICharacter victim, ICharacter assailant, AttackConfig attack)
{
if (IsExpired() || attack.IsReflected)
{
return(attack);
}
assailant.BeAttacked(victim, new AttackConfig(5 * stacks, true));
return(attack);
}
public MeleeAttackState(AttackConfig config) : base(config, 10.0f, 1.0f) //bad, fix
{ }
public TargetObject(GameObject target, Vector2 targetPosition, Vector2 sourcePosition)
{
this.m_Target = target;
this.m_TargetConfig = target.GetComponent <AttackConfig>();
this.CalculateTargetPosition(sourcePosition, targetPosition);
}
public virtual void onAttackDamage(Unit from, AttackConfig config, SkillTargetData targetData)
{
if (config.attackEffect > 0)
{
Unit target = null;
switch (targetData.type)
{
case SkillTargetType.None:
{
target = from;
}
break;
case SkillTargetType.Single:
{
target = _scene.getFightUnit(targetData.targetInstanceID);
}
break;
case SkillTargetType.Ground:
{
}
break;
default:
{
target = from;
}
break;
}
if (target != null)
{
target.show.playEffect(config.attackEffect);
}
}
if (config.attackGroundEffect > 0)
{
PosData pos = null;
DirData dir = null;
switch (targetData.type)
{
case SkillTargetType.None:
{
pos = from.pos.getPos();
dir = from.pos.getDir();
}
break;
case SkillTargetType.Single:
{
Unit target = _scene.getFightUnit(targetData.targetInstanceID);
if (target != null)
{
pos = target.pos.getPos();
dir = target.pos.getDir();
}
}
break;
case SkillTargetType.Ground:
{
pos = targetData.pos;
dir = from.pos.getDir();
}
break;
default:
{
pos = from.pos.getPos();
dir = from.pos.getDir();
}
break;
}
if (pos != null)
{
playSceneEffect(config.attackGroundEffect, pos, dir);
}
}
}
public AttackState(AttackConfig config, float maxRange, float minAttackRange) : base(config)
{
_attackConfig = config;
_maxAttackRange = maxRange;
_minAttackRange = minAttackRange;
}
