public override void Update(double timeDelta, SpritePool spritePool, AbstractMap map)
{
isJustReceivedStrongPunch = false;
isJustReceivedStrongKick = false;
isJustReceivedFastAttack = false;
if (spinAttackCycle.IsFired)
{
if (spinAttackCycle.IsAtBegining)
{
AngleAtBeginingOfSpinAttackRadian = AngleRadian;
}
else if (spinAttackCycle.IsAtParoxism)
{
AngleRadian = AngleAtBeginingOfSpinAttackRadian;
}
else
{
AngleRadian = BattlePhysics.BuildSpinAttackRotation(AngleAtBeginingOfSpinAttackRadian, spinAttackCycle.PercentComplete);
}
}
strongAttackCycle.Update(timeDelta);
fastAttackCycle.Update(timeDelta);
blockSuccessCycle.Update(timeDelta);
spinAttackCycle.Update(timeDelta);
Physics.MakeFall(this, timeDelta);
}
private void Update(AbstractHumanoid attacker, SpritePool spritePool, SharedConsciousness sharedConsciousness, AbstractHumanoid currentPlayer)
{
bool IsAttackerAttackAtParoxism;
double damage;
bool isFastAttack = false;
if (attacker.StrongAttackCycle.IsAtParoxism)
{
damage = attacker.AttackPowerStrong;
IsAttackerAttackAtParoxism = true;
}
else if (attacker.FastAttackCycle.IsAtParoxism)
{
damage = attacker.AttackPowerFast;
IsAttackerAttackAtParoxism = true;
isFastAttack = true;
}
else if (attacker.SpinAttackCycle.IsFired)
{
damage = attacker.AttackPowerStrong;
IsAttackerAttackAtParoxism = true;
}
else
{
return;
}
if (IsAttackerAttackAtParoxism && attacker.ReceivedAttackCycle.GetCycleState() <= 0)
{
foreach (AbstractHumanoid attacked in spritePool)
{
if (attacked == attacker)
{
continue;
}
if (BattlePhysics.IsWithinAttackRange(attacker, attacked))
{
if (BattlePhysics.IsInAttackOrBlockAngle(attacker, attacked))
{
if (BattlePhysics.IsInAttackHeight(attacker, attacked))
{
if (!attacked.IsBlock || !BattlePhysics.IsInAttackOrBlockAngle(attacked, attacker) || !BattlePhysics.IsInBlockingHeight(attacked, attacker))
{
//We abort attacked's attack
attacked.FastAttackCycle.Reset();
attacked.StrongAttackCycle.Reset();
attacked.BlockSuccessCycle.Reset();
attacked.SpinChargeAttackCycle.Reset();
attacked.SpinAttackCycle.Reset();
attacked.FastAttackCycle.IsNeedToClickAgain = true;
attacked.StrongAttackCycle.IsNeedToClickAgain = true;
attacked.ReceivedAttackAngleRadian = attacker.AngleRadian;
attacked.ReceivedAttackCycle.Fire();
if (isFastAttack)
{
attacked.ReceivedAttackCycle.PercentComplete = 0.25;
attacked.ReceivedAttackCycle.IsForward = false;
attacked.IsJustReceivedFastAttack = true;
}
else
{
if (attacker.IsCrouch || attacker.PositionZ >= 0)
{
attacked.IsJustReceivedStrongKick = true;
}
else
{
attacked.IsJustReceivedStrongPunch = true;
}
}
attacked.LatestAttacker = attacker;
attacked.LatestAttackerDamage = damage;
if (!(attacked is Player))
{
attacked.StateJumpCrouch.Reset();
attacked.StateMovement.Reset();
attacked.StateAttackBlock.Reset();
if (attacked.StateAttackBlock.GetCurrentState() == SpriteStates.SpinCharge)
{
attacked.StateAttackBlock.Reset();
}
}
if (!(attacker is Player))
{
attacker.StateJumpCrouch.Renew();
attacker.StateMovement.Renew();
attacker.StateAttackBlock.Renew();
}
}
else if (attacked.IsBlock)
{
attacked.BlockSuccessCycle.Reset();
attacked.BlockSuccessCycle.Fire();
}
}
}
}
}
}
}
public void Animate(AbstractHumanoid predator, AbstractMap map, SpritePool spritePool, SharedConsciousness sharedConsciousness, double timeDelta, int fov, Random random, AbstractHumanoid currentPlayer)
{
AbstractHumanoid prey;
if (random.Next(howManyFrameBeforeChoosingPreyAgain) == 0)
{
prey = TryChoosePrey(predator, spritePool, sharedConsciousness, map, fov, currentPlayer);
predator.LatestSelectedPrey = prey;
}
else
{
prey = predator.LatestSelectedPrey;
}
predator.IsNeedToJumpAgain = false;
predator.IsBlock = false;
byte currentStateJumpCrouch = predator.StateJumpCrouch.GetCurrentState();
//We manage jumping state
if (currentStateJumpCrouch == SpriteStates.Jump)
{
predator.IsCrouch = false;
Physics.MakeJump(predator, timeDelta);
}
//We manage crouch state
if (currentStateJumpCrouch == SpriteStates.Crouch)
{
predator.IsCrouch = true;
}
//We manage standing state
if (currentStateJumpCrouch == SpriteStates.Stand)
{
predator.IsCrouch = false;
predator.IsNeedToJumpAgain = false;
}
//We manage walking
if (prey != null)
{
if (random.Next(5) == 0 && !predator.SpinAttackCycle.IsFired)
{
predator.AngleRadian = Optics.GetSpriteAngleToSpriteRadian(predator, prey);
}
byte currentAttackBlockState = predator.StateAttackBlock.GetCurrentState();
byte currentAttackTypeState = predator.StateAttackType.GetCurrentState();
byte currentMovementState = predator.StateMovement.GetCurrentState();
if (currentAttackBlockState == SpriteStates.SpinCharge)
{
predator.StateAttackType.Reset();
}
if (predator.SpinChargeAttackCycle.IsFired)
{
currentAttackBlockState = SpriteStates.SpinCharge;
}
if (currentMovementState == SpriteStates.Offensive)
{
Physics.TryMakeWalk(predator, spritePool, map, timeDelta);
}
else if (currentMovementState == SpriteStates.Defensive)
{
Physics.TryMakeWalk(predator, Math.PI, spritePool, map, timeDelta);
}
else if (currentMovementState == SpriteStates.FurtiveLeft)
{
Physics.TryMakeWalk(predator, Math.PI * 1.5, spritePool, map, timeDelta);
}
else if (currentMovementState == SpriteStates.FurtiveRight)
{
Physics.TryMakeWalk(predator, Math.PI * 0.5, spritePool, map, timeDelta);
}
//We manage attacking, and blocking
bool isWithinAttackRange = BattlePhysics.IsWithinAttackRange(predator, prey);
bool isWithinAttackOrBlockAngle = BattlePhysics.IsInAttackOrBlockAngle(predator, prey);
if (currentAttackBlockState == SpriteStates.Block && predator.PositionZ > 0)
{
currentAttackBlockState = SpriteStates.Attack;
}
if (isWithinAttackRange || isWithinAttackOrBlockAngle)
{
if (predator.ReceivedAttackCycle.IsAtBegining)
{
if (currentAttackBlockState == SpriteStates.Attack)
{
if (currentAttackTypeState == SpriteStates.FastAttack)
{
if (random.Next(2) == 1)
{
if (BattlePhysics.IsWithinAttackRange(predator, prey, 1.5) && isWithinAttackOrBlockAngle)
{
predator.FastAttackCycle.UnFire();
predator.FastAttackCycle.Fire();
}
}
}
else if (currentAttackTypeState == SpriteStates.StrongAttack)
{
if (random.Next(2) == 1)
{
if (BattlePhysics.IsWithinAttackRange(predator, prey, 1.5) && isWithinAttackOrBlockAngle)
{
predator.StrongAttackCycle.UnFire();
predator.StrongAttackCycle.Fire();
}
}
}
predator.SpinChargeAttackCycle.Reset();
}
else if (currentAttackBlockState == SpriteStates.SpinCharge)
{
if (IsReadyToSpin(predator) && BattlePhysics.IsWithinAttackRange(predator, prey, 1.5))
{
if (random.Next(3) == 1)
{
predator.SpinAttackCycle.Reset();
predator.SpinAttackCycle.Fire();
predator.SpinChargeAttackCycle.Reset();
predator.StateAttackBlock.Reset();
}
}
else if (!predator.SpinAttackCycle.IsFired)
{
if (predator.SpinChargeAttackCycle.IsFired)
{
predator.SpinChargeAttackCycle.Update(timeDelta);
}
else
{
predator.SpinChargeAttackCycle.Fire();
}
}
}
else if (currentAttackBlockState == SpriteStates.Block && !predator.SpinAttackCycle.IsFired)
{
predator.StrongAttackCycle.UnFire();
predator.SpinAttackCycle.UnFire();
predator.SpinChargeAttackCycle.Reset();
predator.FastAttackCycle.UnFire();
predator.IsBlock = true;
}
else
{
predator.SpinChargeAttackCycle.Reset();
}
}
}
predator.StateAttackBlock.Update(timeDelta, random);
predator.StateAttackType.Update(timeDelta, random);
predator.StateMovement.Update(timeDelta, random);
}
else
{
if (!predator.SpinAttackCycle.IsFired && !Physics.TryMakeWalk(predator, spritePool, map, timeDelta))
{
predator.AngleDegree = (double)random.Next(360);
}
}
predator.StateJumpCrouch.Update(timeDelta, random);
}
public override void Update(double timeDelta, SpritePool spritePool, AbstractMap map)
{
BattlePhysics.MoveProjectile(this, spritePool, map, timeDelta);
}
