public override void Update()
{
base.Update();
switch (currentState)
{
case State.Idle:
#region Idle
switch (currentSubState)
{
case subState.Invisible:
if (Invisible == false)
{
currentSubState = subState.FadeIn;
}
break;
case subState.Talking:
if (Talking == false)
{
currentSubState = subState.FadeOut;
}
break;
case subState.FadeIn:
if (FadeIn == false)
{
currentSubState = subState.Talking;
}
break;
case subState.FadeOut:
if (FadeOut == false)
{
currentSubState = subState.Invisible;
}
break;
}
#endregion
break;
}
if (currentSubState == subState.Invisible)
Invisible = true;
else
Invisible = false;
if (currentSubState == subState.FadeIn)
FadeIn = true;
else
FadeIn = false;
if (currentSubState == subState.Talking)
Talking = true;
else
Talking = false;
if (currentSubState == subState.FadeOut)
FadeOut = true;
else
FadeOut = false;
}
public override void Initialize(Vector3 enemyPosition)
{
currentSubState = subState.Invisible;
base.Initialize(enemyPosition);
NPC = true;
enemyType = EnemyType.CheshireCat;
enemyModel = new BasicModel(Engine.GameContainer, ModelProperties.Alpha, Assets.PLANE6, enemyPosition);
Speed = 1.0f;
PerceptionDistance = 60f;
enemyModel.Link.Texture = Engine.GameContainer.Load<Texture2D>("Textures\\Animations\\Cat\\catFadeIn0");
}
public void ThrownInitialize(Vector3 enemyPosition)
{
base.Initialize(enemyPosition);
NPC = true;
enemyType = EnemyType.Hedgehog;
enemyModel = new BasicModel(Engine.GameContainer, ModelProperties.Alpha, Assets.PLANE4, enemyPosition);
enemyModel.Link.Texture = Engine.GameContainer.Load<Texture2D>("Textures\\Enemies\\Hedgehog");
currentState = State.Moving;
currentSubState = subState.ThrownByQueen;
thrownSpeed = Engine.Randomize(1.0f, 1.5f);
DetermineVector();
}
public void changeSub(subState newSub)
{
currentSub = newSub;
switch (currentSub)
{
case subState.Idle:
IdleState.enabled = true;
break;
case subState.Moving:
MovingState.enabled = true;
break;
case subState.Aerial:
AerialState.enabled = true;
break;
}
}
public override void Update()
{
base.Update();
#region Determine currentState
if (currentState == State.Moving &&
currentSubState == subState.MoveRight ||
currentSubState == subState.MoveLeft)
{
nextThrowTime -= mTimer.Peek.ElapsedGameTime.Milliseconds;
if (nextThrowTime < 0)
{
ThrowTeaCup();
ResetThrowTime();
}
}
if (PlayerCollide)
{
//stop throwing teacups?
}
else if (currentState != State.Idle)
{
currentState = State.Moving;
}
#endregion
switch (currentState)
{
case State.Idle:
#region Idle
if (DistanceFromPlayer <= PerceptionDistance)
{
//talk and then ->
currentSubState = subState.MoveLeft;
currentState = State.Moving;
}
#endregion
break;
case State.Moving:
#region Moving
switch (currentSubState)
{
case subState.MoveRight:
enemyPosition.X += Speed;
SetNewPosition(enemyPosition);
if (enemyPosition.X >= distMoveRight)
{
currentSubState = subState.MoveLeft;
}
break;
case subState.MoveLeft:
enemyPosition.X -= Speed;
SetNewPosition(enemyPosition);
if (enemyPosition.X <= distMoveLeft)
{
currentSubState = subState.MoveRight;
}
break;
}
#endregion
break;
}
}
public override void Update()
{
base.Update();
#region Determine currentState
if (PlayerCollide &&
currentState != State.KnockBack &&
!mAvatar.Peek.Defending)
currentState = State.Attacking;
else if (currentState != State.Idle &&
currentState != State.KnockBack)
{
currentState = State.Moving;
}
#endregion
switch (currentState)
{
case State.Idle:
#region Idle
if (DistanceFromPlayer <= PerceptionDistance)
{
currentSubState = subState.FindPlayer;
currentState = State.Moving;
}
#endregion
break;
case State.Moving:
#region Moving
switch (currentSubState)
{
case subState.FindPlayer:
//(determine vector)
enemyVector = Engine.TempVector3(mAvatar.Peek.PlayerModel.Link.Position.X, mAvatar.Peek.PlayerModel.Link.Position.Y + 5, mAvatar.Peek.PlayerModel.Link.Position.Z) - Engine.TempVector3(enemyModel.Link.Position.X, enemyModel.Link.Position.Y, enemyModel.Link.Position.Z);
enemyVector.Normalize();
enemyVector *= Speed;
currentSubState = subState.Chase;
break;
case subState.Chase:
enemyPosition.X += enemyVector.X;
enemyPosition.Z += enemyVector.Z;
SetNewPosition(enemyPosition);
if (DistanceFromPlayer >= 90 ||
enemyPosition.X <= boundNegX ||
enemyPosition.X >= boundPosX ||
enemyPosition.Z <= boundNegZ ||
enemyPosition.Z >= boundPosZ)
{
currentSubState = subState.FindPlayer;
}
break;
}
#endregion
break;
case State.Attacking:
#region Attacking
mAvatar.Peek.HitPlayer(enemyPosition.X, AttackDamage);
#endregion
break;
case State.KnockBack:
#region KnockBack
//Mathew Kane***************************************************************************************************************************
if (!check)
{
Distance = mAvatar.Peek.PlayerModel.Link.Position.X - enemyModel.Link.Position.X;//Get the distance between the character and enemy
if (Distance > 0)//Finds what side the enemy is to the player
{
Neg = false;
}
else
{
Neg = true;
Distance *= -1;// makes sure the distance is postive
}
Distance /= 2;//cut it to reduse how far the enemy gose when hit
while (AY >= 0)//finds X when Y is 0
{
AY = -10 * ((float)Math.Pow((AX / Distance), 2)) + (13 - Distance);//The math will be replaced with something better don't worry
AX--;
}
AY = 0;//reset Y
AX += 2;//Set the x two steps back
X = -1 * AX;// Used for distance
check = true;//makes sure this if statement is only looked at once till everything is done
}
else
{
DelayTime += mTimer.Peek.ElapsedGameTime.Milliseconds;
if (DelayTime > 30)
{
Delay = true;
DelayTime = 0;
}
else
{
Delay = false;
}
}
if (Delay)
{
AY = -10 * ((float)Math.Pow((AX / Distance), 2)) + (13 - Distance);//The math
if (Neg)//Finds what direction should the enemy go when hit
{
enemyModel.Link.Position.Y += AY;
enemyModel.Link.Position.X += AX + X;
}
else
{
enemyModel.Link.Position.Y += AY;
enemyModel.Link.Position.X -= AX + X;
}
AX++;
}
if (enemyModel.Link.Position.Y < 0.0f)//Once the enemy hits the ground (y=0 for now ), resets everything
{
Health -= 15;
enemyModel.Link.Position.Y = 0;
currentState = State.Moving;
currentSubState = subState.FindPlayer;
AX = 0;
AY = 0;
check = false;
}
//************************************************************************************************************************************
#endregion
break;
}
}
public override void Update()
{
base.Update();
switch (currentState)
{
case State.Idle:
#region Idle
#endregion
break;
case State.Moving:
#region Moving
switch (currentSubState)
{
case subState.Moving2Target:
if (Vector3.Distance(targetPosition, enemyPosition) <= 1.0)
{
enemyPosition = targetPosition;
currentState = State.Idle;
}
if (targetPosition.X < enemyPosition.X)
{
FacingRight = false;
enemyPosition.X -= Speed;
SetNewPosition(enemyPosition);
}
if (targetPosition.X > enemyPosition.X)
{
FacingRight = true;
enemyPosition.X += Speed;
SetNewPosition(enemyPosition);
}
if (targetPosition.Z < enemyPosition.Z)
{
enemyPosition.Z -= Speed;
SetNewPosition(enemyPosition);
}
if (targetPosition.Z > enemyPosition.Z)
{
enemyPosition.Z += Speed;
SetNewPosition(enemyPosition);
}
break;
case subState.ThrownByQueen:
break;
}
#endregion
break;
case State.KnockBack:
#region KnockBack
//MATHEW KANE***************************************************************************************************************************
if (!check)
{
Distance = mAvatar.Peek.PlayerModel.Link.Position.X - enemyModel.Link.Position.X;//Get the distance between the character and enemy
if (Distance > 0)//Finds what side the enemy is to the player
{
Neg = false;
}
else
{
Neg = true;
Distance *= -1;// makes sure the distance is postive
}
Distance /= 2;//cut it to reduse how far the enemy gose when hit
while (AY >= 0)//finds X when Y is 0
{
AY = -10 * ((float)Math.Pow((AX / Distance), 2)) + (13 - Distance);//The math will be replaced with something better don't worry
AX--;
}
AY = 0;//reset Y
AX += 2;//Set the x two steps back
X = -1 * AX;// Used for distance
check = true;//makes sure this if statement is only looked at once till everything is done
}
else
{
DelayTime += mTimer.Peek.ElapsedGameTime.Milliseconds;
if (DelayTime > 30)
{
Delay = true;
DelayTime = 0;
}
else
{
Delay = false;
}
}
if (Delay)
{
AY = -10 * ((float)Math.Pow((AX / Distance), 2)) + (13 - Distance);//The math
if (Neg)//Finds what direction should the enemy go when hit
{
enemyModel.Link.Position.Y += AY;
enemyModel.Link.Position.X += AX + X;
}
else
{
enemyModel.Link.Position.Y += AY;
enemyModel.Link.Position.X -= AX + X;
}
AX++;
}
if (enemyModel.Link.Position.Y < 0.0f)//Once the enemy hits the ground (y=0 for now ), resets everything
{
Health -= 50;
enemyModel.Link.Position.Y = 0;
currentState = State.Moving;
currentSubState = subState.Moving2Target;
AX = 0;
AY = 0;
check = false;
}
//************************************************************************************************************************************
#endregion
break;
}
}
public override void Update()
{
base.Update();
//Animation Fixes!!***********************************************
if (currentSubState == subState.MoveUp)
MoveUp = true;
else
MoveUp = false;
if (currentSubState == subState.MoveDown)
MoveDown = true;
else
MoveDown = false;
if (currentSubState == subState.SpawnCards)
SpawnCards = true;
else
SpawnCards = false;
if (currentSubState == subState.ThrowHedgeHogs)
ThrowHedgeHogs = true;
else
ThrowHedgeHogs = false;
if (currentSubState == subState.Chasing)
Chasing = true;
else
Chasing = false;
if (currentSubState == subState.Return2Throne)
Return2Throne = true;
else
Return2Throne = false;
if (currentSubState == subState.Stunned)
Stunned = true;
else
Stunned = false;
//***************************************************************
//debugState.Text = "QueenState: " + Convert.ToString(currentState);
//debugSubState.Text = "QueenSubState: " + Convert.ToString(currentSubState);
//debugWake.Text = "WakeTime: " + Convert.ToString(currentWakeUpTime);
#region Determine currentState
for (int i = 0; i < mAI.Peek.enemyList.Count; i++)
{
if (currentSubState != subState.Stunned &&
mAI.Peek.enemyList[i].currentState == State.KnockBack &&
mAI.Peek.enemyList[i].enemyType == EnemyType.Hedgehog &&
Vector3.Distance(mAI.Peek.enemyList[i].enemyModel.Link.Position, enemyPosition) <= 20.0)
{
currentSubState = subState.Stunned;
currentState = State.Idle;
ResetWakeUpTime();
}
}
if (DistanceFromPlayer <= 21.0 &&
currentSubState != subState.Stunned)
{
currentState = State.Attacking;
}
else if (currentState != State.Idle)
{
currentState = State.Moving;
if (countHedgeHogs >= numHedgeHogs)
{
countHedgeHogs = 0;
ResetSwitch2SpawnTime();
currentSubState = subState.SpawnCards;
}
if (currentSubState == subState.MoveUp ||
currentSubState == subState.MoveDown &&
currentSubState != subState.ThrowHedgeHogs)
{
nextThrowTime -= mTimer.Peek.ElapsedGameTime.Milliseconds;
if (nextThrowTime <= 0)
{
if (currentSubState == subState.MoveUp)
previousSubState = subState.MoveUp;
if (currentSubState == subState.MoveDown)
previousSubState = subState.MoveDown;
if (countHedgeHogs < numHedgeHogs)
{
currentSubState = subState.ThrowHedgeHogs;
}
}
}
}
#endregion
switch (currentState)
{
case State.Idle:
#region Idle
if (currentSubState != subState.Stunned)
{
if (DistanceFromPlayer <= PerceptionDistance)
{
//talk and then ->
currentSubState = subState.MoveUp;
currentState = State.Moving;
}
}
else
{
currentWakeUpTime -= mTimer.Peek.ElapsedGameTime.Milliseconds;
if (currentWakeUpTime <= 0)
{
currentSubState = subState.Chasing;
currentState = State.Moving;
ResetChaseTime();
}
}
#endregion
break;
case State.Moving:
#region Moving
switch (currentSubState)
{
case subState.Chasing:
#region Chasing
currentChaseTime -= mTimer.Peek.ElapsedGameTime.Milliseconds;
if (currentChaseTime <= 0)
{
currentSubState = subState.Return2Throne;
}
if (playerPosition.X < enemyPosition.X)
{
FacingRight = false;
enemyPosition.X -= Speed;
SetNewPosition(enemyPosition);
}
if (playerPosition.X > enemyPosition.X)
{
FacingRight = true;
enemyPosition.X += Speed;
SetNewPosition(enemyPosition);
}
if (playerPosition.Z < enemyPosition.Z)
{
enemyPosition.Z -= Speed;
SetNewPosition(enemyPosition);
}
if (playerPosition.Z > enemyPosition.Z)
{
enemyPosition.Z += Speed;
SetNewPosition(enemyPosition);
}
#endregion
break;
case subState.MoveDown:
#region MoveDown
currentSwitch2ThrowTime -= mTimer.Peek.ElapsedGameTime.Milliseconds;
if (currentSwitch2ThrowTime <= 0)
{
enemyPosition.Z += Speed;
SetNewPosition(enemyPosition);
if (playerPosition.X < enemyPosition.X)
FacingRight = false;
else
FacingRight = true;
if (enemyPosition.Z >= distMoveUp)
{
currentSubState = subState.MoveUp;
}
}
#endregion
break;
case subState.MoveUp:
#region MoveUp
currentSwitch2ThrowTime -= mTimer.Peek.ElapsedGameTime.Milliseconds;
if (currentSwitch2ThrowTime <= 0)
{
enemyPosition.Z -= Speed;
SetNewPosition(enemyPosition);
if (playerPosition.X < enemyPosition.X)
FacingRight = false;
else
FacingRight = true;
if (enemyPosition.Z <= distMoveDown)
{
currentSubState = subState.MoveDown;
}
}
#endregion
break;
case subState.SpawnCards:
#region SpawnCards
currentSwitch2SpawnTime -= mTimer.Peek.ElapsedGameTime.Milliseconds;
if (currentSwitch2SpawnTime <= 0)
{
spawnPosition = Engine.TempVector3(enemyPosition.X, enemyPosition.Y, -enemyPosition.Z);
if (countCards < numCards)
{
nextThrowTime -= mTimer.Peek.ElapsedGameTime.Milliseconds;
if (nextThrowTime <= 0)
{
mAI.Peek.SpawnRandomCard(spawnPosition);
countCards++;
ResetThrowTime();
}
}
else
{
if (mAI.Peek.enemyList.Count == 1)
{
countCards = 0;
ResetSwitch2ThrowTime();
currentState = State.Moving;
currentSubState = subState.MoveUp;
}
}
}
#endregion
break;
case subState.ThrowHedgeHogs:
#region ThrowHedgehogs
spawnPosition = Engine.TempVector3(enemyModel.Link.Position.X, enemyModel.Link.Position.Y + 7, -enemyModel.Link.Position.Z);
mAI.Peek.ThrowHedgehog(spawnPosition);
ResetThrowTime();
countHedgeHogs++;
currentSubState = previousSubState;
#endregion
break;
case subState.Return2Throne:
#region Return2Throne
if (Vector3.Distance(enemyPosition, targetPosition) <= 1.0)
{
currentSubState = subState.MoveUp;
}
if (targetPosition.X < enemyPosition.X)
{
FacingRight = false;
enemyPosition.X -= Speed;
SetNewPosition(enemyPosition);
}
if (targetPosition.X > enemyPosition.X)
{
FacingRight = true;
enemyPosition.X += Speed;
SetNewPosition(enemyPosition);
}
if (targetPosition.Z < enemyPosition.Z)
{
enemyPosition.Z -= Speed;
SetNewPosition(enemyPosition);
}
if (targetPosition.Z > enemyPosition.Z)
{
enemyPosition.Z += Speed;
SetNewPosition(enemyPosition);
}
#endregion
break;
}
#endregion
break;
case State.Attacking:
#region Attacking
mAvatar.Peek.HitPlayer(enemyPosition.X, AttackDamage);
//mAudio.Peek.PlaySound("PlayerHit");
#endregion
break;
}
}
public override void Update()
{
base.Update();
#region Determine currentState
if (PlayerCollide &&
currentSubState != subState.Recovering &&
currentState != State.KnockBack)
currentState = State.Attacking;
else if (currentState != State.Idle &&
currentState != State.KnockBack)
{
currentState = State.Moving;
}
#endregion
switch (currentState)
{
case State.Idle:
#region Idle
if (currentSubState != subState.Recovering)
{
if (DistanceFromPlayer <= PerceptionDistance)
{
currentSubState = subState.ChaseZ;
currentState = State.Moving;
}
}
else
{
currentRecoverTime -= mTimer.Peek.ElapsedGameTime.Milliseconds;
if (currentRecoverTime <= 0)
{
currentSubState = subState.ChaseZ;
currentState = State.Moving;
}
}
#endregion
break;
case State.Moving:
#region Moving
switch (currentSubState)
{
case subState.ChaseZ:
#region ChaseZ
if (playerPosition.Z < enemyPosition.Z)
{
enemyPosition.Z -= Speed;
SetNewPosition(enemyPosition);
}
if (playerPosition.Z > enemyPosition.Z)
{
enemyPosition.Z += Speed;
SetNewPosition(enemyPosition);
}
if (playerPosition.Z > enemyPosition.Z - 1.5f && playerPosition.Z < enemyPosition.Z + 1.5f)
{
if (playerPosition.X < enemyPosition.X)
{
currentSubState = subState.ChaseXLeft;
}
if (playerPosition.X > enemyPosition.X)
{
currentSubState = subState.ChaseXRight;
}
}
#endregion
break;
case subState.ChaseXLeft:
#region ChaseXLeft
enemyPosition.X -= Speed * 9;
SetNewPosition(enemyPosition);
if (enemyPosition.X <= playerPosition.X - 90 ||
enemyPosition.X <= boundNegX)
{
FacingRight = true;
ResetRecoverTime();
currentSubState = subState.Recovering;
currentState = State.Idle;
}
#endregion
break;
case subState.ChaseXRight:
#region ChaseXRight
enemyPosition.X += Speed * 9;
SetNewPosition(enemyPosition);
if (enemyPosition.X >= playerPosition.X + 90 ||
enemyPosition.X >= boundPosX)
{
FacingRight = false;
ResetRecoverTime();
currentSubState = subState.Recovering;
currentState = State.Idle;
}
#endregion
break;
}
#endregion
break;
case State.Attacking:
#region Attacking
mAvatar.Peek.HitPlayer(enemyPosition.X, AttackDamage);
ResetRecoverTime();
currentSubState = subState.Recovering;
currentState = State.Idle;
#endregion
break;
case State.KnockBack:
#region KnockBack
//MATHEW KANE***************************************************************************************************************************
if (!check)
{
Distance = mAvatar.Peek.PlayerModel.Link.Position.X - enemyModel.Link.Position.X;//Get the distance between the character and enemy
if (Distance > 0)//Finds what side the enemy is to the player
{
Neg = false;
}
else
{
Neg = true;
Distance *= -1;// makes sure the distance is postive
}
Distance /= 2;//cut it to reduse how far the enemy gose when hit
while (AY >= 0)//finds X when Y is 0
{
AY = -10 * ((float)Math.Pow((AX / Distance), 2)) + (13 - Distance);//The math will be replaced with something better don't worry
AX--;
}
AY = 0;//reset Y
AX += 2;//Set the x two steps back
X = -1 * AX;// Used for distance
check = true;//makes sure this if statement is only looked at once till everything is done
}
else
{
DelayTime += mTimer.Peek.ElapsedGameTime.Milliseconds;
if (DelayTime > 30)
{
Delay = true;
DelayTime = 0;
}
else
{
Delay = false;
}
}
if (Delay)
{
AY = -10 * ((float)Math.Pow((AX / Distance), 2)) + (13 - Distance);//The math
if (Neg)//Finds what direction should the enemy go when hit
{
enemyModel.Link.Position.Y += AY;
enemyModel.Link.Position.X += AX + X;
}
else
{
enemyModel.Link.Position.Y += AY;
enemyModel.Link.Position.X -= AX + X;
}
AX++;
}
if (enemyModel.Link.Position.Y < 0.0f)//Once the enemy hits the ground (y=0 for now ), resets everything
{
Health -= 15;
enemyModel.Link.Position.Y = 0;
currentState = State.Idle;
currentSubState = subState.Recovering;
AX = 0;
AY = 0;
check = false;
}
//************************************************************************************************************************************
#endregion
break;
}
}
public override void Update()
{
base.Update();
if (bouncecount > 2)
Health = 0;
if (PlayerCollide &&
currentState != State.KnockBack)
{
if (currentSubState == subState.ThrownByQueen)
mAvatar.Peek.HitPlayer(enemyPosition.X, 2);
else
mAvatar.Peek.HitPlayer(enemyPosition.X, 0);
}
switch (currentState)
{
case State.Idle:
#region Idle
#endregion
break;
case State.Moving:
#region Moving
switch (currentSubState)
{
case subState.Moving2Target:
#region Moving2Target
if (Vector3.Distance(targetPosition, enemyPosition) <= 1.0)
{
enemyPosition = targetPosition;
currentState = State.Idle;
}
if (targetPosition.X < enemyPosition.X)
{
FacingRight = false;
enemyPosition.X -= Speed;
SetNewPosition(enemyPosition);
}
if (targetPosition.X > enemyPosition.X)
{
FacingRight = true;
enemyPosition.X += Speed;
SetNewPosition(enemyPosition);
}
if (targetPosition.Z < enemyPosition.Z)
{
enemyPosition.Z -= Speed;
SetNewPosition(enemyPosition);
}
if (targetPosition.Z > enemyPosition.Z)
{
enemyPosition.Z += Speed;
SetNewPosition(enemyPosition);
}
#endregion
break;
case subState.ThrownByQueen:
#region ThrownbyQueen
enemyPosition += enemyVector;
SetNewPosition(enemyPosition);
if (Vector3.Distance(enemyPosition, playerPosition) >= 300)
{
Health = 0;
}
for (int i = 0; i < obstacles.Length; i++)
{
int collide = mPhysics.Peek.BoxCollision(enemyModel, obstacles[i]);
switch (collide)
{
case 1:
enemyVector.Y *= -1;
bouncecount++;
break;
case 2:
enemyVector.Y *= -1;
bouncecount++;
break;
case 3:
enemyVector.X *= -1;
bouncecount++;
break;
case 4:
enemyVector.Z *= -1;
bouncecount++;
break;
case 5:
enemyVector.X *= -1;
bouncecount++;
break;
case 6:
enemyVector.Z *= -1;
bouncecount++;
break;
}
}
#endregion
break;
}
#endregion
break;
case State.KnockBack:
#region KnockBack
//Mathew Kane***************************************************************************************************************************
if (!check)
{
Distance = mAvatar.Peek.PlayerModel.Link.Position.X - enemyModel.Link.Position.X;//Get the distance between the character and enemy
if (Distance > 0)//Finds what side the enemy is to the player
{
Neg = false;
}
else
{
Neg = true;
Distance *= -1;// makes sure the distance is postive
}
Distance /= 2;//cut it to reduse how far the enemy gose when hit
while (AY >= 0)//finds X when Y is 0
{
AY = -10 * ((float)Math.Pow((AX / Distance), 2)) + (13 - Distance);//The math will be replaced with something better don't worry
AX--;
}
AY = 0;//reset Y
AX += 2;//Set the x two steps back
X = -1 * AX;// Used for distance
check = true;//makes sure this if statement is only looked at once till everything is done
}
else
{
DelayTime += mTimer.Peek.ElapsedGameTime.Milliseconds;
if (DelayTime > 30)
{
Delay = true;
DelayTime = 0;
}
else
{
Delay = false;
}
}
if (Delay)
{
AY = -10 * ((float)Math.Pow((AX / Distance), 2)) + (13 - Distance);//The math
if (Neg)//Finds what direction should the enemy go when hit
{
enemyModel.Link.Position.Y += AY;
enemyModel.Link.Position.X += AX + X;
}
else
{
enemyModel.Link.Position.Y += AY;
enemyModel.Link.Position.X -= AX + X;
}
AX++;
}
if (enemyModel.Link.Position.Y < 0.0f)//Once the enemy hits the ground (y=0 for now ), resets everything
{
Health = 0;
enemyModel.Link.Position.Y = 0;
currentState = State.Moving;
currentSubState = subState.Moving2Target;
AX = 0;
AY = 0;
check = false;
}
//************************************************************************************************************************************
#endregion
break;
}
}
public override void Update()
{
base.Update();
#region Determine currentState
if (Hit && currentState != State.KnockBack)
{
currentState = State.Moving;
currentSubState = subState.Switch2Flee;
}
else if (currentState != State.Idle &&
currentState != State.KnockBack &&
currentSubState != subState.Switch2Flee &&
currentSubState != subState.Fleeing &&
currentSubState != subState.Back2Chase)
{
if (PlayerCollide)
currentState = State.Attacking;
else
{
currentState = State.Moving;
currentSubState = subState.Chasing;
}
}
#endregion
switch (currentState)
{
case State.Idle:
#region Idle
if (DistanceFromPlayer <= PerceptionDistance)
{
if (enemyPosition.Y < 0)
{
currentState = State.Moving;
currentSubState = subState.Back2Chase;
}
else
{
currentState = State.Moving;
currentSubState = subState.Chasing;
}
}
#endregion
break;
case State.Moving:
#region Moving
switch (currentSubState)
{
case subState.Chasing:
#region Chasing
mAudio.Peek.PlaySound(mAudio.SoundName.WormChase, enemyPosition);
if (playerPosition.X < enemyPosition.X)
{
FacingRight = false;
enemyPosition.X -= Speed;
SetNewPosition(enemyPosition);
}
if (playerPosition.X > enemyPosition.X)
{
FacingRight = true;
enemyPosition.X += Speed;
SetNewPosition(enemyPosition);
}
if (playerPosition.Z < enemyPosition.Z)
{
enemyPosition.Z -= Speed;
SetNewPosition(enemyPosition);
}
if (playerPosition.Z > enemyPosition.Z)
{
enemyPosition.Z += Speed;
SetNewPosition(enemyPosition);
}
#endregion
break;
case subState.Switch2Flee:
#region Switch2Flee
if (enemyPosition.Y > -20)
{
enemyPosition.Y -= 0.6f;
SetNewPosition(enemyPosition);
}
if (enemyPosition.Y < -20)
{
enemyPosition.Y = -20;
SetNewPosition(enemyPosition);
}
if (enemyPosition.Y == -20)
{
currentSubState = subState.Fleeing;
}
#endregion
break;
case subState.Fleeing:
#region Fleeing
if (mAvatar.Peek.FacingRight)
{
targetPosition = Engine.TempVector3(playerPosition.X - 40, -10, playerPosition.Z);
}
else
{
targetPosition = Engine.TempVector3(playerPosition.X + 40, -10, playerPosition.Z);
}
if (enemyPosition.X < targetPosition.X + 0.5 &&
enemyPosition.X > targetPosition.X - 0.5)
{
currentSubState = subState.Back2Chase;
}
if (targetPosition.X < enemyPosition.X)
{
FacingRight = false;
enemyPosition.X -= Speed;
SetNewPosition(enemyPosition);
}
if (targetPosition.X > enemyPosition.X)
{
FacingRight = true;
enemyPosition.X += Speed;
SetNewPosition(enemyPosition);
}
if (targetPosition.Z < enemyPosition.Z)
{
enemyPosition.Z -= Speed;
SetNewPosition(enemyPosition);
}
if (targetPosition.Z > enemyPosition.Z)
{
enemyPosition.Z += Speed;
SetNewPosition(enemyPosition);
}
#endregion
break;
case subState.Back2Chase:
#region Back2Chase
if (playerPosition.X < enemyPosition.X)
FacingRight = false;
if (playerPosition.X > enemyPosition.X)
FacingRight = true;
if (enemyPosition.Y < 0)
{
enemyPosition.Y += 0.6f;
SetNewPosition(enemyPosition);
}
if (enemyPosition.Y > 0)
{
enemyPosition.Y = 0;
SetNewPosition(enemyPosition);
}
if (enemyPosition.Y == 0)
{
currentSubState = subState.Chasing;
}
#endregion
break;
}
#endregion
break;
case State.Attacking:
#region Attacking
mAvatar.Peek.HitPlayer(enemyPosition.X, AttackDamage);
//mAudio.Peek.PlaySound("PlayerHit");
#endregion
break;
case State.KnockBack:
#region KnockBack
//Mathew Kane***************************************************************************************************************************
if (!check)
{
Distance = mAvatar.Peek.PlayerModel.Link.Position.X - enemyModel.Link.Position.X;//Get the distance between the character and enemy
if (Distance > 0)//Finds what side the enemy is to the player
{
Neg = false;
}
else
{
Neg = true;
Distance *= -1;// makes sure the distance is postive
}
Distance /= 2;//cut it to reduse how far the enemy gose when hit
while (AY >= 0)//finds X when Y is 0
{
AY = -10 * ((float)Math.Pow((AX / Distance), 2)) + (13 - Distance);//The math will be replaced with something better don't worry
AX--;
}
AY = 0;//reset Y
AX += 2;//Set the x two steps back
X = -1 * AX;// Used for distance
check = true;//makes sure this if statement is only looked at once till everything is done
}
else
{
DelayTime += mTimer.Peek.ElapsedGameTime.Milliseconds;
if (DelayTime > 30)
{
Delay = true;
DelayTime = 0;
}
else
{
Delay = false;
}
}
if (Delay)
{
AY = -10 * ((float)Math.Pow((AX / Distance), 2)) + (13 - Distance);//The math
if (Neg)//Finds what direction should the enemy go when hit
{
enemyModel.Link.Position.Y += AY;
enemyModel.Link.Position.X += AX + X;
}
else
{
enemyModel.Link.Position.Y += AY;
enemyModel.Link.Position.X -= AX + X;
}
AX++;
}
if (enemyModel.Link.Position.Y < 0.0f)//Once the enemy hits the ground (y=0 for now ), resets everything
{
Health -= 15;
enemyModel.Link.Position.Y = 0;
currentState = State.Moving;
currentSubState = subState.Chasing;
AX = 0;
AY = 0;
check = false;
}
//************************************************************************************************************************************
#endregion
break;
}
}
