public IEnumerator CooldownIndicator(Moves move, AttackEnum attackEnum)
{
_images[(int)attackEnum].color = Color.grey;
for (float i = move._coolDown; i > 0;)
{
if (move._isReadyAnimating)
{
if (move._coolDown >= 1)
{
yield return(new WaitForSeconds(1));
i--;
_timerText[(int)attackEnum].text = i + "";
}
else
{
i = 0;
}
}
else
{
yield return(new WaitForEndOfFrame());
}
}
_timerText[(int)attackEnum].text = "";
_images[(int)attackEnum].color = Color.white;
}
/// <summary>
/// 设置攻击效果
/// </summary>
/// <param name="skill">攻击模式</param>
/// <param name="target">目标</param>
private void setAttackEffect(AttackEnum skill, GameCharacter target)
{
switch (skill)
{
case AttackEnum.NORMAL_ATTACK:
if (IsFacingRight == true)
{
target.Rbody2D.AddForce(new Vector2(1.5f, 0), ForceMode2D.Impulse);
}
else
{
target.Rbody2D.AddForce(new Vector2(-1.5f, 0), ForceMode2D.Impulse);
}
break;
case AttackEnum.JUMP_ATTACK:
if (IsFacingRight == true)
{
target.Rbody2D.AddForce(new Vector2(2.5f, -2.5f), ForceMode2D.Impulse);
}
else
{
target.Rbody2D.AddForce(new Vector2(-2.5f, -2.5f), ForceMode2D.Impulse);
}
break;
default:
break;
}
}
public void RegisterAttack(AttackEnum ae)
{
if (!playerAttacks.Contains(ae))
{
playerAttacks.Add(ae);
}
}
public virtual void DoneAnimating(AttackEnum attack)
{
if (_attack == attack)
{
_isReadyAnimating = true;
Invoke("DoneCooldown", _coolDown);
}
}
/// <summary>
/// 开始攻击
/// </summary>
/// <param name="skill">攻击模式</param>
private void startAttack(AttackEnum skill)
{
// 攻击时不可转身
LockFlip = true;
IsHitting = true;
switch (skill)
{
case AttackEnum.NORMAL_ATTACK:
CurrentSpeed = 0.5f;
switch (AttackNum)
{
case 0:
MoveAnim.SetBool("normalAttack", true);
MoveAnim.SetInteger("AttackNum", AttackNum);
dealDamage(skill, DamageDegree.HEAVY_ATTACK, BasicDamage * 5, MyDamageType);
break;
case 1:
MoveAnim.SetBool("normalAttack", true);
MoveAnim.SetInteger("AttackNum", AttackNum);
dealDamage(skill, DamageDegree.HEAVY_ATTACK, BasicDamage * 5, MyDamageType);
break;
case 2:
MoveAnim.SetBool("normalAttack", true);
MoveAnim.SetInteger("AttackNum", AttackNum);
dealDamage(skill, DamageDegree.HEAVY_ATTACK, BasicDamage * 3, MyDamageType);
break;
default:
MoveAnim.SetBool("normalAttack", true);
MoveAnim.SetInteger("AttackNum", AttackNum);
dealDamage(skill, DamageDegree.HEAVY_ATTACK, BasicDamage * 3, MyDamageType);
break;
}
//Invoke("finishNormalAttack", 0.5f);
break;
case AttackEnum.JUMP_ATTACK:
CurrentSpeed = 0.5f;
Rbody2D.velocity = new Vector2(0, 0);
MoveAnim.SetBool("jumpAttack", true);
dealDamage(skill, DamageDegree.LIGHT_ATTACK, BasicDamage, MyDamageType);
//Invoke("finishJumpAttack", 0.3f);
break;
case AttackEnum.SPEEL_ATTACK:
MoveAnim.SetBool("speelAttack", true);
dealDamage(skill, DamageDegree.LIGHT_ATTACK, BasicDamage, MyDamageType);
Invoke("finishSpeelAttack", 0.3f);
break;
default:
break;
}
}
public void TakeDamages(AttackEnum attaque, float damages)
{
switch (attaque)
{
case AttackEnum.PHYSICAL_FIRE:
if (physic_fire == true)
{
return;
}
break;
case AttackEnum.PHYSICAL_THUNDER:
if (physic_thunder == true)
{
return;
}
break;
case AttackEnum.PHYSICAL_ICE:
if (physic_ice == true)
{
return;
}
break;
case AttackEnum.MAGICAL_FIRE:
if (magic_fire == true)
{
return;
}
break;
case AttackEnum.MAGICAL_THUNDER:
if (magic_thunder == true)
{
return;
}
break;
case AttackEnum.MAGICAL_ICE:
if (magic_ice == true)
{
return;
}
break;
}
hp = hp - damages;
PlayerObserver.instance.RegisterAttack(attaque);
if (hp <= 0)
{
Death(attaque);
}
}
// 添加攻击效果
// 限定效果
public override void setEffect(GameCharacter target, AttackEnum skill)
{
switch (skill)
{
case AttackEnum.NORMAL_ATTACK:
if (IsFacingRight == true)
{
target.Rbody2D.AddForce(new Vector2(5f, 0), ForceMode2D.Impulse);
}
else
{
target.Rbody2D.AddForce(new Vector2(-5f, 0), ForceMode2D.Impulse);
}
break;
}
}
public void ApplyRes(AttackEnum ae)
{
switch (ae)
{
case AttackEnum.MAGICAL_FIRE:
foreach (Enemy e in renforts)
{
e.magic_fire = true;
}
break;
case AttackEnum.MAGICAL_ICE:
foreach (Enemy e in renforts)
{
e.magic_ice = true;
}
break;
case AttackEnum.MAGICAL_THUNDER:
foreach (Enemy e in renforts)
{
e.magic_thunder = true;
}
break;
case AttackEnum.PHYSICAL_FIRE:
foreach (Enemy e in renforts)
{
e.physic_fire = true;
}
break;
case AttackEnum.PHYSICAL_ICE:
foreach (Enemy e in renforts)
{
e.physic_ice = true;
}
break;
case AttackEnum.PHYSICAL_THUNDER:
foreach (Enemy e in renforts)
{
e.physic_thunder = true;
}
break;
}
}
/// <summary>
/// 结束攻击
/// </summary>
private void finishAttack(AttackEnum skill)
{
switch (skill)
{
case AttackEnum.NORMAL_ATTACK:
Invoke("finishNormalAttack", 0);
break;
case AttackEnum.JUMP_ATTACK:
Invoke("finishJumpAttack", 0);
break;
case AttackEnum.SPEEL_ATTACK:
Invoke("finishSpeelAttack", 0);
break;
}
}
/// <summary>
/// 执行攻击行为
/// </summary>
/// <param name="skill">攻击模式</param>
/// <param name="damageDegree">伤害类型</param>
/// <param name="damage">伤害数值</param>
private void dealDamage(AttackEnum skill, DamageDegree damageDegree, float damage, DamageType damageType)
{
// 攻击NPC
for (int i = 0; i < GameCharacterManager.Instance.NPCList.Count; i++)
{
if (checkHit(GameCharacterManager.Instance.NPCList[i]))
{
hit(GameCharacterManager.Instance.NPCList[i], damageDegree, damage, damageType);
setAttackEffect(skill, GameCharacterManager.Instance.NPCList[i]);
//GameCharacterManager.Instance.NPCList[i].MyAI.setTarget(this);
GameCharacterManager.Instance.NPCList[i].Target = this;
}
}
// 攻击敌人
for (int i = 0; i < GameCharacterManager.Instance.EnemyList.Count; i++)
{
if (checkHit(GameCharacterManager.Instance.EnemyList[i]))
{
hit(GameCharacterManager.Instance.EnemyList[i], damageDegree, damage, damageType);
setAttackEffect(skill, GameCharacterManager.Instance.EnemyList[i]);
}
}
}
public AttackEnum this[int index]
{
get
{
switch (Math.Min(Math.Max(index, 0), 2))
{
case 0:
return(PrimaryAttack);
case 1:
return(SecondaryAttack);
case 2:
return(SecondaryAttack2);
default:
return(PrimaryAttack);
}
}
set
{
switch (Math.Min(Math.Max(index, 0), 2))
{
case 0:
primaryAttack = value;
break;
case 1:
secondaryAttack = value;
break;
case 2:
secondaryAttack2 = value;
break;
}
}
}
public override void DoneAnimating(AttackEnum attack)
{
base.DoneAnimating(attack);
_currentLerpSpeed = _lerpWalkSpeed;
}
// 添加攻击效果
/// <summary>
/// 限定效果
/// </summary>
/// <param name="target">目标</param>
/// <param name="skill">攻击方式</param>
public virtual void setEffect(GameCharacter target, AttackEnum skill)
{
}
/// <summary>
/// 更新状态
/// </summary>
/// <param name="state">状态枚举</param>
/// <param name="direction">方向</param>
/// <param name="speed">速度</param>
/// <param name="jumpForce">跳跃力</param>
/// <param name="up"></param>
/// <param name="skill">攻击模式</param>
public void updateState(StateEnum state, float direction = 0, float speed = 0, float jumpForce = 0, bool up = true, AttackEnum skill = AttackEnum.NORMAL_ATTACK)
{
switch (state)
{
case StateEnum.IDLE:
CurrentState = StateEnum.IDLE;
goToIdle();
break;
case StateEnum.WALK:
if (Rbody2D.velocity.x >= CurrentSpeed && CurrentState != StateEnum.ATTACK)
{
CurrentState = StateEnum.WALK;
}
goToWalk(direction, speed);
break;
case StateEnum.RUN:
if (Rbody2D.velocity.x >= CurrentSpeed && CurrentState != StateEnum.ATTACK)
{
CurrentState = StateEnum.RUN;
}
goToRun(direction, speed);
break;
case StateEnum.JUMP:
CurrentState = StateEnum.JUMP;
goToJump(jumpForce, up);
break;
case StateEnum.SPEEL:
CurrentState = StateEnum.SPEEL;
goToSpeel();
break;
case StateEnum.DEAD:
CurrentState = StateEnum.DEAD;
goToDead();
break;
case StateEnum.ALIVE:
CurrentState = StateEnum.ALIVE;
break;
case StateEnum.ATTACK:
CurrentState = StateEnum.ATTACK;
startAttack(skill);
break;
case StateEnum.CROUCH:
CurrentState = StateEnum.CROUCH;
startCrouch();
break;
case StateEnum.DASH:
CurrentState = StateEnum.DASH;
startDash(direction, speed);
break;
case StateEnum.ROLL:
CurrentState = StateEnum.ROLL;
startRoll(direction);
break;
default:
goToIdle();
break;
}
}
private void Update()
{
if (Time.timeScale == 0)
{
return;
}
// check alive
#region check alive
if (Alive == false)
{
Locked = true;
Rbody2D.velocity = new Vector2(0, Rbody2D.velocity.y);
if (!IsDead)
{
MoveAnim.SetBool("dead", true);
goToDead(-1f);
}
}
#endregion
// Hunger
#region Hunger
if (TC.Minutes - TimeOnHold >= 1)
{
CurrentHungerValue -= HungerCost;
TimeOnHold = TC.Minutes;
}
if (CurrentHungerValue <= 0)
{
CurrentHungerValue = 0;
if (!BM.containsBuff("Hungry0"))
{
BM.addBuff(BuffStock.findBuff("Hungry0"));
}
}
else if (CurrentHungerValue >= TotalHungerValue)
{
CurrentHungerValue = TotalHungerValue;
}
#endregion
// go to crouch
#region go to crouch
if ((Input.GetKeyDown(KeyCodeList.Instance.Crouch)) && OnGround == true && CurrentState != StateEnum.ATTACK)
{
IsCrouching = true;
}
else if (Input.GetKeyUp(KeyCodeList.Instance.Crouch) && CurrentState != StateEnum.ATTACK)
{
IsCrouching = false;
}
if (IsCrouching == true)
{
updateState(StateEnum.CROUCH);
}
else if (CurrentState == StateEnum.CROUCH)
{
finishCrouch();
}
#endregion
// operation
#region operation
if (Locked == false && IsRolling == false && IsCrouching == false)
{
// go to jump
#region go to jump
if (Input.GetKeyDown(KeyCodeList.Instance.Jump) && CurrentState != StateEnum.ATTACK &&
IsHealing == false &&
IsSpeeling == false)
{
if (OnGround == true && OnWall == false)
{
IsJumping = true;
OnGround = false;
updateState(StateEnum.JUMP, Direction, CurrentSpeed, CurrentJumpForce * (1 + (CurrentSpeed - WalkingSpeed) * 0.1f));
}
else if (ExtraJumpCount > 0 && IsSpeeling == false)
{
// extra jump
if (CurrentEnergy >= JumpCost)
{
ExtraJumpCount--;
CurrentEnergy -= JumpCost;
Rbody2D.velocity = new Vector2(0, 0);
updateState(StateEnum.JUMP, Direction, CurrentSpeed, CurrentJumpForce * ExtraJumpMultiple);
}
}
}
#endregion
// jump higher
#region jump higher
if (Input.GetKey(KeyCodeList.Instance.Jump) && IsJumping == true)
{
if (CurrentJumpDuration > 0)
{
Rbody2D.velocity += Vector2.up * CurrentJumpForce * DeltaJumpForcePercent;
CurrentJumpDuration -= Time.deltaTime;
}
else
{
IsJumping = false;
}
}
if (Input.GetKeyUp(KeyCodeList.Instance.Jump))
{
IsJumping = false;
}
#endregion
// go to attack
#region go to attack
if (ChainsDuration > 0)
{
ChainsDuration -= Time.deltaTime;
}
else
{
ChainsDuration = 0;
AttackNum = 0;
}
if (CurrentCoolDown < CoolDown)
{
// 更新冷却
CurrentCoolDown += Time.deltaTime;
}
if (CurrentCoolDown >= CoolDown && !IsRolling && !IsHealing)
{
if (Input.GetKeyDown(KeyCodeList.Instance.Attack) && OnGround == true)
{
if (IsDashing)
{
finishDash();
}
// 重置冷却时间
CurrentCoolDown = 0;
if (ChainsDuration > 0)
{
// 连续攻击
if (AttackNum < MaxAttackNum)
{
AttackNum++;
ChainsDuration = MaxChainsDuration;
}
else
{
AttackNum = 0;
ChainsDuration = MaxChainsDuration;
}
}
else
{
// 超时，重置
AttackNum = 0;
ChainsDuration = MaxChainsDuration;
}
updateState(StateEnum.ATTACK, Direction, CurrentSpeed, CurrentJumpForce, true, AttackEnum.NORMAL_ATTACK);
Skill = AttackEnum.NORMAL_ATTACK;
}
if (Input.GetKeyDown(KeyCodeList.Instance.Attack) && OnGround == false && !IsSpeeling)
{
// 重置冷却时间
CurrentCoolDown = 0;
updateState(StateEnum.ATTACK, Direction, CurrentSpeed, CurrentJumpForce, true, AttackEnum.JUMP_ATTACK);
Skill = AttackEnum.JUMP_ATTACK;
}
if (Input.GetKeyDown(KeyCodeList.Instance.Attack) && OnWall == true)
{
// 重置冷却时间
CurrentCoolDown = 0;
updateState(StateEnum.ATTACK, Direction, CurrentSpeed, CurrentJumpForce, true, AttackEnum.SPEEL_ATTACK);
Skill = AttackEnum.SPEEL_ATTACK;
}
}
#endregion
//roll
#region roll
if (/*CurrentState != StateEnum.ATTACK && */ !IsRolling && !IsHealing &&
checkGround() && CurrentEnergy >= RollingCost &&
Input.GetKeyDown(KeyCodeList.Instance.Roll))
{
if (IsDashing)
{
finishDash();
}
else
{
CurrentEnergy -= RollingCost;
}
IsRolling = true;
if (CurrentState == StateEnum.ATTACK)
{
finishAttack(Skill);
}
MoveAnim.SetBool("roll", true);
ChainsDuration = MaxChainsDuration;
}
#endregion
// dash
#region dash
if (IsRunning && Input.GetKey(KeyCodeList.Instance.Dash) && checkGround() && !IsHealing)
{
if (CurrentEnergy > 0)
{
IsDashing = true;
CurrentEnergy -= Time.deltaTime * DashingCost;
}
else
{
finishDash();
}
}
else
{
finishDash();
}
#endregion
}
#endregion
// cure energy
#region cure energy
if (!IsDashing && !IsRolling && !(IsRunning && OnGround) && !(IsJumping && ExtraJumpCount < MaxExtraJumpCount))
{
CurrentEnergy += Time.deltaTime * EnergyCure;
if (CurrentEnergy > TotalEnergy)
{
CurrentEnergy = TotalEnergy;
}
else if (CurrentEnergy < 0)
{
CurrentEnergy = 0;
}
}
#endregion
// cure shield
#region cure shield
if (CurrentShieldValue < 0)
{
CurrentShieldValue = 0;
}
else if (CurrentShieldValue < TotalShieldValue)
{
CurrentShieldValue += Time.deltaTime * ShieldCure;
}
else if (CurrentShieldValue > TotalShieldValue)
{
CurrentShieldValue = TotalShieldValue;
}
#endregion
}
void Death(AttackEnum ae)
{
EnemyManager.instance.ApplyRes(ae);
}
