//public void CheckForPlatformCollision(IEnumerable<IBoundable> platforms)
//{
// Debug.WriteLine($"Checking collisions against {platforms.Count()} platforms");
// if (verticalState != VerticalMovementState.Jumping)
// {
// verticalState = VerticalMovementState.Falling;
// foreach (Platform platform in platforms)
// {
// if (Bounds.CollidesWith(platform.Bounds))
// {
// Position.Y = platform.Bounds.Y - 1;
// verticalState = VerticalMovementState.OnGround;
// }
// }
// }
//}
private void CheckForObjectCollision(GameTime gameTime, TilemapObject[] objects)
{
BoundingRectangle bounds;
//check for platform object collision
foreach (TilemapObject item in objects)
{
bounds = new BoundingRectangle(item.X, item.Y, item.Width, item.Height);
if (item.Type == "Platform")
{
if (verticalState != VerticalMovementState.Jumping)
{
if (Bounds.CollidesWith(bounds))
{
Position.Y = bounds.Y - 1;
if (Keyboard.GetState().IsKeyDown(Keys.Space))
{
verticalState = VerticalMovementState.Jumping;
jumpTimer = new TimeSpan(0);
}
}
else
{
verticalState = VerticalMovementState.Falling;
}
}
}
}
}
private void CheckForJumpStart()
{
if (Input.GetKeyDown(KeyCode.W))
{
_rigidBody2D.AddForce(new Vector2(0.0f, Jump_Power));
_verticalMovementState = VerticalMovementState.Rising;
_animator.SetBool("Jumping", true);
}
}
public void Initialize()
{
Position = new Vector2(240, 500);
state = State.Idle;
animationState = PlayerAnimState.Idle;
verticalState = VerticalMovementState.OnGround;
Bounds.Width = FRAME_WIDTH;
Bounds.Height = FRAME_HEIGHT;
}
private void HandleFalling()
{
if (_rigidBody2D.velocity.y >= 0.0f)
{
_verticalMovementState = VerticalMovementState.OnGround;
_animator.SetBool("Falling", false);
_animator.SetBool("Walking", _rigidBody2D.velocity.x != 0.0f);
}
}
public void Reset()
{
life = 4;
animationState = PlayerAnimState.Idle;
verticalState = VerticalMovementState.OnGround;
spriteEffects = SpriteEffects.None;
color = Color.White;
Position = new Vector2(200, 200);
}
public void Dead()
{
verticalState = VerticalMovementState.Dead;
Position.Y += 100 * PLAYER_SPEED;
// TODO: This needs to be replaced with collision logic
if (Position.Y > 1000)
{
Position.Y = 1000;
}
}
public void Reset()
{
life = 4;
animationState = PlayerAnimState.Idle;
verticalState = VerticalMovementState.OnGround;
spriteEffects = SpriteEffects.None;
color = Color.White;
Position = OriginalPosition;
dead = false;
}
private void CheckForJumpStart()
{
if (Input.GetKeyDown(KeyCode.W))
{
_rigidBody2D.AddForce(new Vector2(0.0f, 300.0f));
_verticalMovementState = VerticalMovementState.Rising;
_animator.SetBool("Jumping", true);
SoundEffectManager.PlaySound("Jump");
}
}
public void CheckForPlatformCollision(IEnumerable <IBoundable> platforms)
{
if (verticalState != VerticalMovementState.Jumping)
{
verticalState = VerticalMovementState.Falling;
foreach (Platform platform in platforms)
{
if (Bounds.CollidesWith(platform.Bounds))
{
Position.Y = platform.Bounds.Y - 1;
verticalState = VerticalMovementState.OnGround;
}
}
}
}
public void CheckForBlockCollision(IEnumerable <IBoundable> blocks)
{
foreach (Block block in blocks)
{
if ((block.Bounds.X < position.X + FRAME_WIDTH) && (position.X < (block.Bounds.X + block.Bounds.Width)) && (block.Bounds.Y < position.Y + FRAME_HEIGHT) && (position.Y < block.Bounds.Y + block.Bounds.Height))
{
position.Y = block.Bounds.Y - FRAME_HEIGHT;
verticalState = VerticalMovementState.OnGround;
}
else
{
verticalState = VerticalMovementState.Falling;
}
}
}
public void CheckForPlatformCollision(IEnumerable <IBoundable> platforms)
{
Debug.WriteLine($"Checking collisions against {platforms.Count()} platforms");
if (verticalState != VerticalMovementState.Jumping)
{
verticalState = VerticalMovementState.Falling;
foreach (Platform platform in platforms)
{
if (Bounds.CollidesWith(platform.Bounds))
{
Position.Y = platform.Bounds.Y - 1;
verticalState = VerticalMovementState.OnGround;
}
}
}
}
public void Initialize()
{
// For testing purposes
Position = new Vector2(40, 450); // Start position could change with preference
Health = 200; // Could also change with preference
direction = Direction.Idle;
verticalState = VerticalMovementState.OnGround;
Bounds.Width = FRAME_WIDTH;
Bounds.Height = FRAME_HEIGHT;
IsDead = false;
IsHit = false;
flicker = new InterpolationTimer(TimeSpan.FromSeconds(0.25), 0.0f, 1.0f);
fade = new InterpolationTimer(TimeSpan.FromSeconds(2), 1.0f, 0.0f);
multiple = 1;
Element = Element.None;
elementalOrb.Initialize();
}
/// <summary>
/// checks and updates the player's vertical movement.
/// NOTE: MEANT TO BE USED IN THE UPDATE METHOD ONLY.
/// </summary>
/// <param name="gameTime">the current game time.</param>
/// <param name="keyboard">the state of the keyboard.</param>
private void UpdateVertical(GameTime gameTime, KeyboardState keyboard)
{
switch (verticalState)
{
case VerticalMovementState.OnGround:
Debug.WriteLine("OnGround");
if (keyboard.IsKeyDown(Keys.Space))
{
verticalState = VerticalMovementState.Jumping;
jumpTimer = new TimeSpan(0);
}
break;
case VerticalMovementState.Jumping:
Debug.WriteLine("Jumping");
jumpTimer += gameTime.ElapsedGameTime;
// Simple jumping with platformer physics
Position.Y -= (250 / (float)jumpTimer.TotalMilliseconds);
if (jumpTimer.TotalMilliseconds >= JUMP_TIME)
{
verticalState = VerticalMovementState.Falling;
}
break;
case VerticalMovementState.Falling:
Position.Y += PLAYER_SPEED;
Debug.WriteLine("Falling");
// TODO: This needs to be replaced with collision logic
if (Position.Y >= 300)
{
Position.Y = 299;
}
break;
}
}
private void Start()
{
_starsCollected = 0;
_facingRight = true;
_verticalMovementState = VerticalMovementState.OnGround;
}
private void Reset()
{
_facingRight = (_transform.localScale.x > 0.0f);
_verticalMovementState = VerticalMovementState.OnGround;
_lockMovement = false;
_isMoving = false;
_activeGateType = GateType.None;
_gateCenterX = 0.0f;
_enteringGate = false;
_activeTool = null;
}
public void Update(GameTime gameTime)
{
var keyboard = Keyboard.GetState();
if (Position.Y > 522)
{
dead = true;
game.victory.AnnounceVictory();
}
if (Position.X < -game.offset.X)
{
Position.X = -game.offset.X + 12;
}
if (Position.X > game.graphics.PreferredBackBufferWidth - game.offset.X)
{
Position.X = game.graphics.PreferredBackBufferWidth - game.offset.X;
}
// Vertical movement
switch (verticalState)
{
case VerticalMovementState.OnGround:
if (keyboard.IsKeyDown(jump))
{
verticalState = VerticalMovementState.Jumping;
jumpTimer = new TimeSpan(0);
}
break;
case VerticalMovementState.Jumping:
jumpTimer += gameTime.ElapsedGameTime;
// Simple jumping with platformer physics
Position.Y -= (450 / (float)jumpTimer.TotalMilliseconds);
if (jumpTimer.TotalMilliseconds >= JUMP_TIME)
{
verticalState = VerticalMovementState.Falling;
}
break;
case VerticalMovementState.Falling:
Position.Y += speed;
break;
}
// Horizontal movement
if (keyboard.IsKeyDown(left))
{
if (verticalState == VerticalMovementState.Jumping || verticalState == VerticalMovementState.Falling)
{
animationState = PlayerAnimState.JumpingLeft;
}
else
{
animationState = PlayerAnimState.WalkingLeft;
}
Position.X -= speed;
}
else if (keyboard.IsKeyDown(right))
{
if (verticalState == VerticalMovementState.Jumping || verticalState == VerticalMovementState.Falling)
{
animationState = PlayerAnimState.JumpingRight;
}
else
{
animationState = PlayerAnimState.WalkingRight;
}
Position.X += speed;
}
else
{
animationState = PlayerAnimState.Idle;
}
// Apply animations
switch (animationState)
{
case PlayerAnimState.Idle:
currentFrame = 0;
animationTimer = new TimeSpan(0);
break;
case PlayerAnimState.JumpingLeft:
spriteEffects = SpriteEffects.FlipHorizontally;
currentFrame = 7;
break;
case PlayerAnimState.JumpingRight:
spriteEffects = SpriteEffects.None;
currentFrame = 7;
break;
case PlayerAnimState.WalkingLeft:
animationTimer += gameTime.ElapsedGameTime;
spriteEffects = SpriteEffects.FlipHorizontally;
// Walking frames are 9 & 10
if (animationTimer.TotalMilliseconds > FRAME_RATE * 2)
{
animationTimer = new TimeSpan(0);
}
currentFrame = (int)Math.Floor(animationTimer.TotalMilliseconds / FRAME_RATE) + 9;
break;
case PlayerAnimState.WalkingRight:
animationTimer += gameTime.ElapsedGameTime;
spriteEffects = SpriteEffects.None;
// Walking frames are 9 & 10
if (animationTimer.TotalMilliseconds > FRAME_RATE * 2)
{
animationTimer = new TimeSpan(0);
}
currentFrame = (int)Math.Floor(animationTimer.TotalMilliseconds / FRAME_RATE) + 9;
break;
}
}
public void Update(GameTime gameTime)
{
//Movement
KeyboardState keyboard = Keyboard.GetState();
float delta = (float)gameTime.ElapsedGameTime.TotalSeconds;
Bounds.X = Position.X;
Bounds.Y = Position.Y;
// So the player can't go backwards, would need to change as they
// progress through the levels
if (Position.X < 40)
{
Position.X = 40;
}
// Vertical movement
switch (verticalState)
{
case VerticalMovementState.OnGround:
if (keyboard.IsKeyDown(Keys.Up))
{
verticalState = VerticalMovementState.Jumping;
jumpTimer = new TimeSpan(0);
}
if (keyboard.IsKeyDown(Keys.Up) && oldState.IsKeyUp(Keys.Up))
{
verticalState = VerticalMovementState.DoubleJump;
jumpTimer = new TimeSpan(0);
}
break;
case VerticalMovementState.Jumping:
jumpTimer += gameTime.ElapsedGameTime;
// Simple jumping and start fallings right after
Position.Y -= (600 / (float)jumpTimer.TotalMilliseconds);
if (jumpTimer.TotalMilliseconds >= JUMP_TIME)
{
verticalState = VerticalMovementState.Falling;
}
break;
case VerticalMovementState.DoubleJump:
jumpTimer += gameTime.ElapsedGameTime;
// Simple jumping and start fallings right after
Position.Y -= (900 / (float)jumpTimer.TotalMilliseconds);
if (jumpTimer.TotalMilliseconds >= JUMP_TIME)
{
verticalState = VerticalMovementState.Falling;
}
break;
case VerticalMovementState.Falling:
Position.Y += delta * FALL_SPEED;
// Come back to the ground
if (Position.Y > 450)
{
Position.Y = 450;
verticalState = VerticalMovementState.OnGround;
}
break;
}
if (IsHit)
{
// for when the player collides with the enenmy
Position.X -= 200 * delta;
direction = Direction.East;
if (flicker.TimeElapsed.TotalSeconds >= 0.20)
{
flicker.Stop();
flicker = new InterpolationTimer(TimeSpan.FromSeconds(0.25), 0.0f, 1.0f);
IsHit = false;
multiple = 1.0f;
}
else
{
if (!flicker.IsRunning)
{
flicker.Start();
}
if (flicker.IsRunning)
{
flicker.Update(gameTime.ElapsedGameTime);
}
multiple = flicker.CurrentValue;
}
}
if (IsDead)
{
if (fade.TimeElapsed.TotalSeconds >= 1.75)
{
fade.Stop();
multiple = 0;
}
if (!fade.IsRunning && multiple != 0)
{
fade.Start();
}
else if (multiple != 0)
{
if (fade.IsRunning)
{
fade.Update(gameTime.ElapsedGameTime);
}
multiple = fade.CurrentValue;
}
}
if (keyboard.IsKeyDown(Keys.Left))
{
if (verticalState == VerticalMovementState.Jumping || verticalState == VerticalMovementState.Falling)
{
direction = Direction.West;
}
else
{
direction = Direction.West;
}
Position.X -= delta * PLAYER_SPEED;
}
else if (keyboard.IsKeyDown(Keys.Right))
{
if (verticalState == VerticalMovementState.Jumping || verticalState == VerticalMovementState.Falling)
{
direction = Direction.East;
}
else
{
direction = Direction.East;
}
Position.X += delta * PLAYER_SPEED;
}
else
{
direction = Direction.Idle;
}
if (keyboard.IsKeyDown(Keys.K) && !oldState.IsKeyDown(Keys.K))
{
UpdateHealth(Health);
}
// Elemental Orb Activate and Update
if (keyboard.IsKeyDown(Keys.Space) && !oldState.IsKeyDown(Keys.Space) && elementalOrb.State == ElementalOrb.ActiveState.Idle)
{
Vector2 orbVelocity = new Vector2(1, 0);
switch (direction)
{
case Direction.East:
orbVelocity = new Vector2(1, 0);
break;
case Direction.West:
orbVelocity = new Vector2(-1, 0);
break;
case Direction.Idle:
orbVelocity = new Vector2(1, 0);
break;
}
elementalOrb.Attack(Position, orbVelocity, Element);
SetDamage(game.GameState, Element);
}
elementalOrb.Update(gameTime);
if (keyboard.IsKeyDown(Keys.LeftAlt) && !oldState.IsKeyDown(Keys.LeftAlt) && elementalOrb.State == ElementalOrb.ActiveState.Idle)
{
CycleElement();
}
oldState = keyboard;
}
private void HandleNormalVerticalMovement()
{
if ((_rigidBody2D.velocity.y < Fall_Velocity_Threshold) && (_verticalMovementState != VerticalMovementState.Falling)) { StartFalling(); }
if (_rigidBody2D.velocity.y > Normal_Jump_Max_Vertical_Velocity)
{
_rigidBody2D.velocity = new Vector2(_rigidBody2D.velocity.x, Normal_Jump_Max_Vertical_Velocity);
}
switch (_verticalMovementState)
{
case VerticalMovementState.OnGround: CheckForJumpStart(); break;
case VerticalMovementState.Falling: HandleFalling(); break;
}
if ((PickaxeHasGripped) && (_verticalMovementState == VerticalMovementState.Falling))
{
_rigidBody2D.velocity = new Vector2(_rigidBody2D.velocity.x, 0.0f);
_rigidBody2D.gravityScale = 0.0f;
_verticalMovementState = VerticalMovementState.OnGround;
_animator.SetBool("Pickaxe", true);
}
else if ((_rigidBody2D.gravityScale != 1.0f) && ((!PickaxeHasGripped) || (_verticalMovementState == VerticalMovementState.Rising)))
{
_animator.SetBool("Pickaxe", false);
_rigidBody2D.gravityScale = 1.0f;
}
if (_verticalMovementState != VerticalMovementState.OnGround) { _isMoving = true; }
}
/// <summary>
/// Update the sprite, moving and animating it
/// </summary>
/// <param name="gameTime">The GameTime object</param>
public void Update(GameTime gameTime)
{
KeyboardState keyboard = Keyboard.GetState();
float delta = (float)gameTime.ElapsedGameTime.TotalSeconds;
// Vertical movement
switch (verticalState)
{
case VerticalMovementState.OnGround:
if (keyboard.IsKeyDown(Keys.Space))
{
verticalState = VerticalMovementState.Jumping;
jumpTimer = new TimeSpan(0);
}
break;
case VerticalMovementState.Jumping:
jumpTimer += gameTime.ElapsedGameTime;
// Simple jumping with platformer physics
position.Y -= (350 / (float)jumpTimer.TotalMilliseconds);
if (jumpTimer.TotalMilliseconds >= JUMP_TIME)
{
verticalState = VerticalMovementState.Falling;
}
break;
case VerticalMovementState.Falling:
position.Y += speed;
//collision logic
if (position.Y > 351)
{
position.Y = 351;
verticalState = VerticalMovementState.OnGround;
}
break;
}
// Horizontal movement
if (keyboard.IsKeyDown(Keys.Left))
{
state = State.West;
position.X -= delta * PLAYER_SPEED;
}
else if (keyboard.IsKeyDown(Keys.Right))
{
state = State.East;
position.X += delta * PLAYER_SPEED;
}
else
{
state = State.Idle;
}
// Update the player animation timer when the player is moving
if (state != State.Idle)
{
timer += gameTime.ElapsedGameTime;
}
// Determine the frame should increase. Using a while
// loop will accomodate the possiblity the animation should
// advance more than one frame.
while (timer.TotalMilliseconds > ANIMATION_FRAME_RATE)
{
// increase by one frame
frame++;
// reduce the timer by one frame duration
timer -= new TimeSpan(0, 0, 0, 0, ANIMATION_FRAME_RATE);
}
// Keep the frame within bounds (there are four frames)
frame %= 4;
//Will need to comment this out for project 4
if (position.X < 0)
{
//position.X = game.GetWidth() - FRAME_WIDTH;
position.X = 0;
}
if (position.X + FRAME_WIDTH >= 1390)
{
position.X = 1390 - FRAME_WIDTH;
}
//Ensures the player falls off the blocks
if ((position.X > 170 && position.X < 550) && (position.Y + FRAME_HEIGHT <= 300))
{
verticalState = VerticalMovementState.Falling;
}
if ((position.X > 720 && position.X < 995) && (position.Y + FRAME_HEIGHT <= 300))
{
verticalState = VerticalMovementState.Falling;
}
if ((position.X < 995 && position.X > 1165) && (position.Y + FRAME_HEIGHT <= 300))
{
verticalState = VerticalMovementState.Falling;
}
if ((position.X > 1165) && (position.Y + FRAME_HEIGHT <= 300))
{
verticalState = VerticalMovementState.Falling;
}
}
public void Hit()
{
verticalState = VerticalMovementState.Hit;
jumpTimer = TimeSpan.Zero;
Position -= new Vector2(-10, 70);
}
/// <summary>
/// Updates the player, applying movement and physics
/// </summary>
/// <param name="gameTime">The GameTime object</param>
public void Update(GameTime gameTime)
{
var keyboard = Keyboard.GetState();
if (gameState == 0)
{
// Vertical movement
switch (verticalState)
{
case VerticalMovementState.OnGround:
if (keyboard.IsKeyDown(Keys.Space))
{
verticalState = VerticalMovementState.Jumping;
jumpTimer = new TimeSpan(0);
}
break;
case VerticalMovementState.Jumping:
jumpTimer += gameTime.ElapsedGameTime;
// Simple jumping with platformer physics
Position.Y -= (250 / (float)jumpTimer.TotalMilliseconds);
if (jumpTimer.TotalMilliseconds >= JUMP_TIME)
{
verticalState = VerticalMovementState.Falling;
}
if (playerBounce == 1)
{
jumpTimer = new TimeSpan(0);
Position.Y -= (250 / (float)jumpTimer.TotalMilliseconds);
playerBounce = 0;
}
if (Position.X - 16 < 0)
{
Position.X = 16;
}
if (Position.X + 20 > 1600)
{
Position.X = 1580;
}
break;
case VerticalMovementState.Falling:
Position.Y += speed;
// TODO: This needs to be replaced with collision logic
if (Position.Y > 1000)
{
Position.Y = 1000;
}
if (Position.X - 16 < 0)
{
Position.X = 16;
}
if (Position.X + 20 > 1600)
{
Position.X = 1580;
}
break;
}
// Horizontal movement
if (keyboard.IsKeyDown(Keys.Left))
{
if (verticalState == VerticalMovementState.Jumping || verticalState == VerticalMovementState.Falling)
{
animationState = PlayerState.JumpingLeft;
}
else
{
animationState = PlayerState.WalkingLeft;
}
Position.X -= speed;
if (Position.X - 16 < 0)
{
Position.X = 16;
}
}
else if (keyboard.IsKeyDown(Keys.Right))
{
if (verticalState == VerticalMovementState.Jumping || verticalState == VerticalMovementState.Falling)
{
animationState = PlayerState.JumpingRight;
}
else
{
animationState = PlayerState.WalkingRight;
}
Position.X += speed;
if (Position.X - 16 < 0)
{
Position.X = 16;
}
if (Position.X + 20 > 1600)
{
Position.X = 1580;
}
}
else
{
animationState = PlayerState.Idle;
}
}
if (Position.X >= 1556 && Position.Y <= 349) //if player gets to the end of the level, they win!
{
gameState = 1;
speed = 0;
}
// Apply animations
switch (animationState)
{
case PlayerState.Idle:
currentFrame = 0;
animationTimer = new TimeSpan(0);
break;
case PlayerState.JumpingLeft:
spriteEffects = SpriteEffects.FlipHorizontally;
currentFrame = 7;
break;
case PlayerState.JumpingRight:
spriteEffects = SpriteEffects.None;
currentFrame = 7;
break;
case PlayerState.WalkingLeft:
animationTimer += gameTime.ElapsedGameTime;
spriteEffects = SpriteEffects.FlipHorizontally;
// Walking frames are 9 & 10
if (animationTimer.TotalMilliseconds > (FRAME_RATE * 2 - (FRAME_RATE * 0.05))) //this slight adjustment fixes the issue of seeing a small blip of frame 11 pop up
{
animationTimer = new TimeSpan(0);
}
currentFrame = (int)Math.Floor(animationTimer.TotalMilliseconds / FRAME_RATE) + 9;
break;
case PlayerState.WalkingRight:
animationTimer += gameTime.ElapsedGameTime;
spriteEffects = SpriteEffects.None;
// Walking frames are 9 & 10
if (animationTimer.TotalMilliseconds > (FRAME_RATE * 2 - (FRAME_RATE * 0.05)))
{
animationTimer = new TimeSpan(0);
}
currentFrame = (int)Math.Floor(animationTimer.TotalMilliseconds / FRAME_RATE) + 9;
break;
}
}
public void Update(GameTime gameTime)
{
//Movement
KeyboardState keyboard = Keyboard.GetState();
float delta = (float)gameTime.ElapsedGameTime.TotalSeconds;
Bounds.X = Position.X;
Bounds.Y = Position.Y;
if (Position.X < 250)
{
Position.X = 250;
}
// Vertical movement
switch (verticalState)
{
case VerticalMovementState.OnGround:
if (keyboard.IsKeyDown(Keys.Up))
{
verticalState = VerticalMovementState.Jumping;
jumpTimer = new TimeSpan(0);
}
break;
case VerticalMovementState.Jumping:
jumpTimer += gameTime.ElapsedGameTime;
// Simple jumping with platformer physics
Position.Y -= (600 / (float)jumpTimer.TotalMilliseconds);
if (jumpTimer.TotalMilliseconds >= JUMP_TIME)
{
verticalState = VerticalMovementState.Falling;
}
break;
case VerticalMovementState.Falling:
Position.Y += delta * PLAYER_SPEED;
// TODO: This needs to be replaced with collision logic
if (Position.Y > 500)
{
Position.Y = 500;
verticalState = VerticalMovementState.OnGround;
}
break;
case VerticalMovementState.Hit:
jumpTimer += gameTime.ElapsedGameTime;
// Simple jumping with platformer physics
Position.Y -= (350 / (float)jumpTimer.TotalMilliseconds);
if (jumpTimer.TotalMilliseconds >= JUMP_TIME)
{
verticalState = VerticalMovementState.Falling;
}
break;
}
if (verticalState == VerticalMovementState.Hit)
{
Position.X -= 100 * delta;
animationState = PlayerAnimState.JumpingLeft;
}
else if (keyboard.IsKeyDown(Keys.Left))
{
if (verticalState == VerticalMovementState.Jumping || verticalState == VerticalMovementState.Falling)
{
animationState = PlayerAnimState.JumpingLeft;
}
else
{
state = State.West;
animationState = PlayerAnimState.WalkingLeft;
}
Position.X -= delta * PLAYER_SPEED;
}
else if (keyboard.IsKeyDown(Keys.Right))
{
if (verticalState == VerticalMovementState.Jumping || verticalState == VerticalMovementState.Falling)
{
animationState = PlayerAnimState.JumpingRight;
}
else
{
state = State.East;
animationState = PlayerAnimState.WalkingRight;
}
Position.X += delta * PLAYER_SPEED;
}
else
{
state = State.Idle;
animationState = PlayerAnimState.Idle;
}
// Apply animations
switch (animationState)
{
case PlayerAnimState.Idle:
currentFrame = 0;
animationTimer = new TimeSpan(0);
break;
case PlayerAnimState.JumpingLeft:
currentFrame = 7;
break;
case PlayerAnimState.JumpingRight:
currentFrame = 7;
break;
case PlayerAnimState.WalkingLeft:
animationTimer += gameTime.ElapsedGameTime;
// Walking frames are 9 & 10
if (animationTimer.TotalMilliseconds > FRAME_RATE * 2)
{
animationTimer = new TimeSpan(0);
}
currentFrame = (int)Math.Floor(animationTimer.TotalMilliseconds / FRAME_RATE) + 9;
break;
case PlayerAnimState.WalkingRight:
animationTimer += gameTime.ElapsedGameTime;
// Walking frames are 9 & 10
if (animationTimer.TotalMilliseconds > FRAME_RATE * 2)
{
animationTimer = new TimeSpan(0);
}
currentFrame = (int)Math.Floor(animationTimer.TotalMilliseconds / FRAME_RATE) + 9;
break;
}
// update animation timer when the player is moving
if (animationState != PlayerAnimState.Idle)
{
animationTimer += gameTime.ElapsedGameTime;
}
// Check if animation should increase by more than one frame
while (animationTimer.TotalMilliseconds > FRAME_RATE)
{
// increase frame
frame++;
// Decrease the timer by one frame duration
animationTimer -= new TimeSpan(0, 0, 0, 0, FRAME_RATE);
}
frame %= 4;
oldState = keyboard;
}
protected virtual void CheckForJumpStart()
{
if ((!_lockMovement) && (Input.GetKeyDown(KeyCode.W)))
{
if (CurrentGame.GameData.ActiveTool == ToolType.SuperJump)
{
_rigidBody2D.AddForce(new Vector2(0.0f, Super_Jump_Power));
CurrentGame.UseSuperJump();
}
else
{
_rigidBody2D.AddForce(new Vector2(0.0f, Jump_Power));
}
_verticalMovementState = VerticalMovementState.Rising;
_animator.SetBool("Jumping", true);
}
}
private void Start()
{
_verticalMovementState = VerticalMovementState.OnGround;
}
/// <summary>
/// Updates the player, applying movement and physics
/// </summary>
/// <param name="gameTime">The GameTime object</param>
public void Update(GameTime gameTime)
{
var keyboard = Keyboard.GetState();
if (gameState == 0)
{
// Vertical movement
switch (verticalState)
{
case VerticalMovementState.OnGround:
if (keyboard.IsKeyDown(Keys.Space))
{
verticalState = VerticalMovementState.Jumping;
jumpTimer = new TimeSpan(0);
}
break;
case VerticalMovementState.Jumping:
jumpTimer += gameTime.ElapsedGameTime;
// Simple jumping with platformer physics
Position.Y -= (250 / (float)jumpTimer.TotalMilliseconds);
if (jumpTimer.TotalMilliseconds >= JUMP_TIME)
{
verticalState = VerticalMovementState.Falling;
}
if (playerBounce == 1)
{
jumpTimer = new TimeSpan(0);
Position.Y -= (250 / (float)jumpTimer.TotalMilliseconds);
playerBounce = 0;
}
if (Position.X - 16 < 0)
{
Position.X = 16;
}
if (Position.X + 20 > 2100)
{
Position.X = 2100;
}
break;
case VerticalMovementState.Falling:
Position.Y += speed;
if (Position.X - 16 < 0)
{
Position.X = 16;
}
if (Position.X + 20 > 2100)
{
Position.X = 2100;
}
break;
}
// Horizontal movement
if (keyboard.IsKeyDown(Keys.Left))
{
if (verticalState == VerticalMovementState.Jumping || verticalState == VerticalMovementState.Falling)
{
animationState = PlayerState.JumpingLeft;
}
else
{
animationState = PlayerState.WalkingLeft;
}
Position.X -= speed;
/*
* if (Position.X - 16 < 0)
* {
* Position.X = 16;
* }*/
}
else if (keyboard.IsKeyDown(Keys.Right))
{
if (verticalState == VerticalMovementState.Jumping || verticalState == VerticalMovementState.Falling)
{
animationState = PlayerState.JumpingRight;
}
else
{
animationState = PlayerState.WalkingRight;
}
Position.X += speed;
if (Position.X - 16 < 0)
{
Position.X = 16;
}
if (Position.X + 20 > 2100)
{
Position.X = 2100;
}
}
else
{
animationState = PlayerState.Idle;
}
}
if (Position.X >= 2090 && Position.Y <= 1500) //if player gets to the end of the level, they win!
{
gameState = 1;
speed = 0;
}
if (Position.Y > 1870)
{
gameState = 3;
}
// Apply animations
switch (animationState)
{
case PlayerState.Idle:
currentFrame = 0;
animationTimer = new TimeSpan(0);
break;
case PlayerState.JumpingLeft:
spriteEffects = SpriteEffects.FlipHorizontally;
currentFrame = 7;
break;
case PlayerState.JumpingRight:
spriteEffects = SpriteEffects.None;
currentFrame = 7;
break;
case PlayerState.WalkingLeft:
animationTimer += gameTime.ElapsedGameTime;
spriteEffects = SpriteEffects.FlipHorizontally;
// Walking frames are 9 & 10
if (animationTimer.TotalMilliseconds > FRAME_RATE * 2)
{
animationTimer = new TimeSpan(0);
}
currentFrame = (int)Math.Floor(animationTimer.TotalMilliseconds / FRAME_RATE) + 9;
break;
case PlayerState.WalkingRight:
animationTimer += gameTime.ElapsedGameTime;
spriteEffects = SpriteEffects.None;
// Walking frames are 9 & 10
if (animationTimer.TotalMilliseconds > FRAME_RATE * 2)
{
animationTimer = new TimeSpan(0);
}
currentFrame = (int)Math.Floor(animationTimer.TotalMilliseconds / FRAME_RATE) + 9;
break;
}
}
private void StartFalling()
{
_verticalMovementState = VerticalMovementState.Falling;
_animator.SetBool("Falling", true);
_animator.SetBool("Jumping", false);
}
protected virtual void Reset()
{
_facingRight = (_transform.localScale.x > 0.0f);
_verticalMovementState = VerticalMovementState.OnGround;
_isMoving = false;
_invincibilityEffect.SetActive(false);
_animator.SetBool("Jetpack", false);
_animator.SetBool("Extinguisher", false);
_animator.SetBool("Walking", false);
_animator.SetBool("Pickaxe", false);
_rigidBody2D.gravityScale = 1.0f;
_lockMovement = false;
PickaxeHasGripped = false;
CurrentGame.DeactivateTool();
}
/// <summary>
/// Updates the player, applying movement and physics
/// </summary>
/// <param name="gameTime">The GameTime object</param>
public void Update(GameTime gameTime)
{
var keyboard = Keyboard.GetState();
// Vertical movement
switch (verticalState)
{
case VerticalMovementState.OnGround:
if (keyboard.IsKeyDown(Keys.Space))
{
verticalState = VerticalMovementState.Jumping;
jumpTimer = new TimeSpan(0);
}
break;
case VerticalMovementState.Jumping:
jumpTimer += gameTime.ElapsedGameTime;
// Simple jumping with platformer physics
Position.Y -= (250 / (float)jumpTimer.TotalMilliseconds);
if (jumpTimer.TotalMilliseconds >= JUMP_TIME)
{
verticalState = VerticalMovementState.Falling;
}
break;
case VerticalMovementState.Falling:
Position.Y += speed;
// TODO: This needs to be replaced with collision logic
if (Position.Y > 500)
{
Position.Y = 500;
}
break;
}
// Horizontal movement
if (keyboard.IsKeyDown(Keys.Left))
{
if (verticalState == VerticalMovementState.Jumping || verticalState == VerticalMovementState.Falling)
{
animationState = PlayerAnimState.JumpingLeft;
}
else
{
animationState = PlayerAnimState.WalkingLeft;
}
Position.X -= speed;
}
else if (keyboard.IsKeyDown(Keys.Right))
{
if (verticalState == VerticalMovementState.Jumping || verticalState == VerticalMovementState.Falling)
{
animationState = PlayerAnimState.JumpingRight;
}
else
{
animationState = PlayerAnimState.WalkingRight;
}
Position.X += speed;
}
else
{
animationState = PlayerAnimState.Idle;
}
// Apply animations
switch (animationState)
{
case PlayerAnimState.Idle:
currentFrame = 0;
animationTimer = new TimeSpan(0);
break;
case PlayerAnimState.JumpingLeft:
spriteEffects = SpriteEffects.FlipHorizontally;
currentFrame = 7;
break;
case PlayerAnimState.JumpingRight:
spriteEffects = SpriteEffects.None;
currentFrame = 7;
break;
case PlayerAnimState.WalkingLeft:
animationTimer += gameTime.ElapsedGameTime;
spriteEffects = SpriteEffects.FlipHorizontally;
// Walking frames are 9 & 10
if (animationTimer.TotalMilliseconds > FRAME_RATE * 2)
{
animationTimer = new TimeSpan(0);
}
currentFrame = (int)Math.Floor(animationTimer.TotalMilliseconds / FRAME_RATE) + 9;
break;
case PlayerAnimState.WalkingRight:
animationTimer += gameTime.ElapsedGameTime;
spriteEffects = SpriteEffects.None;
// Walking frames are 9 & 10
if (animationTimer.TotalMilliseconds > FRAME_RATE * 2)
{
animationTimer = new TimeSpan(0);
}
currentFrame = (int)Math.Floor(animationTimer.TotalMilliseconds / FRAME_RATE) + 9;
break;
}
}
public void Update(GameTime gameTime)
{
var keyboard = Keyboard.GetState();
//walking left and right
if (keyboard.IsKeyDown(Keys.Left))
{
if (jumping || falling)
{
animationState = PlayerAnimState.JumpingLeft;
}
else
{
animationState = PlayerAnimState.WalkingLeft;
}
Position.X -= playerSpeed;
}
else if (keyboard.IsKeyDown(Keys.Right))
{
if (jumping || falling)
{
animationState = PlayerAnimState.JumpingRight;
}
else
{
animationState = PlayerAnimState.WalkingRight;
}
Position.X += playerSpeed;
}
else
{
animationState = PlayerAnimState.Idle;
}
//jumping and falling
if (jumping)
{
jumpTime += gameTime.ElapsedGameTime;
// Simple jumping with platformer physics
Position.Y -= (250 / (float)jumpTime.TotalMilliseconds);
if (jumpTime.TotalMilliseconds >= JUMP_HEIGHT)
{
jumping = false;
falling = true;
verticalState = VerticalMovementState.Falling;
}
}
if (falling)
{
Position.Y += playerSpeed;
// TODO: This needs to be replaced with collision logic
if (Position.Y > 400)
{
Position.Y = 400;
falling = false;
verticalState = VerticalMovementState.OnGround;
}
}
if (!jumping && !falling && keyboard.IsKeyDown(Keys.Up))
{
jumping = true;
jumpTime = new TimeSpan(0);
verticalState = VerticalMovementState.Jumping;
if (!soundHasPlayed)
{
jumpSFX.Play();
soundHasPlayed = false;
}
}
bounds.X = Position.X;
bounds.Y = Position.Y;
//frames may change depending on sprite sheet
switch (animationState)
{
case PlayerAnimState.Idle:
currentFrame = 0;
animateTime = new TimeSpan(0);
break;
case PlayerAnimState.JumpingLeft:
spriteEffects = SpriteEffects.FlipHorizontally;
currentFrame = 3;
break;
case PlayerAnimState.JumpingRight:
spriteEffects = SpriteEffects.None;
currentFrame = 3;
break;
case PlayerAnimState.WalkingLeft:
animateTime += gameTime.ElapsedGameTime;
spriteEffects = SpriteEffects.FlipHorizontally;
if (animateTime.TotalMilliseconds > FRAME * 2)
{
animateTime = new TimeSpan(0);
}
currentFrame = (int)animateTime.TotalMilliseconds / FRAME + 2;
break;
case PlayerAnimState.WalkingRight:
animateTime += gameTime.ElapsedGameTime;
spriteEffects = SpriteEffects.None;
if (animateTime.TotalMilliseconds > FRAME * 2)
{
animateTime = new TimeSpan(0);
}
currentFrame = (int)animateTime.TotalMilliseconds / FRAME + 2;
break;
}
//staying in the screen
if (bounds.X < 0)
{
bounds.X = 0;
Position.X = 0;
}
if (bounds.X > game.GraphicsDevice.Viewport.Width - bounds.Width)
{
bounds.X = game.GraphicsDevice.Viewport.Width - bounds.Width;
Position.X = game.GraphicsDevice.Viewport.Width - bounds.Width;
}
if (bounds.Y < 0)
{
bounds.Y = 0;
Position.Y = 0;
}
//if (bounds.Y > groundLevel)
//{
// bounds.Y = groundLevel;
// Position.Y = groundLevel;
//}
}
