sneak/Shared/Player.cs

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using System;
using System.Collections.Generic;

namespace SemiColinGames {

  interface IPlayerState : IState<History<Input>> {
    public Vector2 Movement { get; }
    public void PostUpdate(bool standingOnGround);
  }

  class StandState : IPlayerState {
    private Vector2 result;

    // private double swordSwingTime = 0;
    // private int swordSwingNum = 0;
    private float ySpeed = 0;
    private int jumps = 1;
    private const int jumpSpeed = -600;
    private const int moveSpeed = 180;
    private const int gravity = 1600;

    public void Enter() {
    }

    public string Update(float modelTime, World world, History<Input> input) {
      result = new Vector2() {
        X = input[0].Motion.X * moveSpeed * modelTime
      };

      if (input[0].Jump && !input[1].Jump && jumps > 0) {
        jumps--;
        ySpeed = jumpSpeed;
      }

      // if (input[0].Attack && !input[1].Attack && swordSwingTime <= 0) {
      //   swordSwingTime = 0.3;
      //   swordSwingNum++;
      //   SoundEffects.SwordSwings[swordSwingNum % SoundEffects.SwordSwings.Length].Play();
      // }

      result.Y = ySpeed * modelTime;
      ySpeed += gravity * modelTime;
      // swordSwingTime -= modelTime;

      if (input[0].IsAbsoluteMotion) {
        if (input[1].Motion.X == 0) {
          result.X = input[0].Motion.X;
        } else {
          result.X = 0;
        }
      }

      return null;
    }

    public Vector2 Movement {
      get { return result; }
    }

    // TODO: Maybe this should be Update(), and CalculateMovement() should be the Player-specific
    // function?
    public void PostUpdate(bool standingOnGround) {
      if (standingOnGround) {
        jumps = 1;
        ySpeed = -0.0001f;
        // Debug.AddRect(Box(position), Color.Cyan);
      } else {
        jumps = 0;
        // Debug.AddRect(Box(position), Color.Orange);
      }
    }
  }

  public class Player {
    private readonly FSM<History<Input>> fsm;
    // TODO: get rid of Pose.
    private enum Pose { Walking, Standing, SwordSwing, Jumping };

    // Details of the sprite image.
    // player_1x is 48 x 48, yOffset=5, halfSize=(7, 14)
    // Ninja_Female is 96 x 64, yOffset=1, halfSize=(11, 24)
    private const int spriteWidth = 96;
    private const int spriteHeight = 64;
    private const int spriteCenterYOffset = 1;

    // Details of the actual Player model.

    // Position is tracked at the Player's center. The Player's bounding box is a rectangle
    // centered at that point and extending out by halfSize.X and halfSize.Y.
    private Vector2 position;
    private Vector2 halfSize = new Vector2(11, 24);
    // Fractional-pixel movement that was left over from a previous frame's movement.
    // Useful so that we can run at a slow time-step and still get non-zero motion.
    private Vector2 residual = Vector2.Zero;

    private Pose pose = Pose.Jumping;
    private float invincibilityTime = 0;

    // For passing into Line.Rasterize() during movement updates.
    private readonly IList<Point> movePoints = new ProfilingList<Point>(64, "Player.movePoints");
    // Possible hitboxes for player <-> obstacles.
    private readonly IList<AABB> candidates = new ProfilingList<AABB>(16, "Player.candidates");

    public Player(Vector2 position, int facing) {
      this.position = position;
      Facing = facing;
      Health = MaxHealth;
      StandingOnGround = false;
      fsm = new FSM<History<Input>>("run", new Dictionary<string, IState<History<Input>>> {
        { "run", new StandState() },
      });
    }

    public bool StandingOnGround { get; private set; }

    public int MaxHealth { get; private set; } = 3;

    public int Health { get; private set; }

    public int Facing { get; private set; }

    public Vector2 Position { get { return position; } }

    public void Update(float modelTime, World world, History<Input> input) {
      AABB BoxOffset(Vector2 position, int yOffset) {
        return new AABB(new Vector2(position.X, position.Y + yOffset), halfSize);
      }

      AABB Box(Vector2 position) {
        return BoxOffset(position, 0);
      }

      invincibilityTime -= modelTime;

      Vector2 inputMovement = HandleInput(modelTime, world, input);
      Vector2 movement = Vector2.Add(residual, inputMovement);
      residual = new Vector2(movement.X - (int) movement.X, movement.Y - (int) movement.Y);

      // Broad test: remove all collision targets nowhere near the player.
      candidates.Clear();
      // Expand the box in the direction of movement. The center is the midpoint of the line
      // between the player's current position and their desired movement. The width increases by
      // the magnitude of the movement in each direction. We add 1 to each dimension just to be
      // sure (the only downside is a small number of false-positive AABBs, which should be
      // discarded by later tests anyhow.)
      AABB largeBox = new AABB(
        Vector2.Add(position, Vector2.Divide(movement, 2)),
        Vector2.Add(halfSize, new Vector2(Math.Abs(movement.X) + 1, Math.Abs(movement.Y) + 1)));
      foreach (var box in world.CollisionTargets) {
        if (box.Intersect(largeBox) != null) {
          // Debug.AddRect(box, Color.Green);
          candidates.Add(box);
        }
      }

      bool harmedByCollision = false;
      Line.Rasterize(0, 0, (int) movement.X, (int) movement.Y, movePoints);
      for (int i = 1; i < movePoints.Count; i++) {
        int dx = movePoints[i].X - movePoints[i - 1].X;
        int dy = movePoints[i].Y - movePoints[i - 1].Y;
        if (dy != 0) {
          Vector2 newPosition = new Vector2(position.X, position.Y + dy);
          AABB player = Box(newPosition);
          bool reject = false;
          foreach (var box in candidates) {
            if (box.Intersect(player) != null) {
              Debug.AddRect(box, Color.Cyan);
              reject = true;
              if (box.Tile?.IsHazard ?? false) {
                Debug.AddRect(box, Color.Red);
                harmedByCollision = true;
              }
            }
          }
          if (!reject) {
            position = newPosition;
          }
        }
        if (dx != 0) {
          Vector2 newPosition = new Vector2(position.X + dx, position.Y);
          AABB player = Box(newPosition);
          bool reject = false;
          foreach (var box in candidates) {
            if (box.Intersect(player) != null) {
              Debug.AddRect(box, Color.Cyan);
              reject = true;
              if (box.Tile?.IsHazard ?? false) {
                Debug.AddRect(box, Color.Red);
                harmedByCollision = true;
              }
            }
          }
          if (!reject) {
            position = newPosition;
          }
        }
      }

      StandingOnGround = false;
      AABB groundIntersect = BoxOffset(position, 1);
      foreach (var box in candidates) {
        if (groundIntersect.Intersect(box) != null) {
          Debug.AddRect(box, Color.Cyan);
          StandingOnGround = true;
          if (box.Tile?.IsHazard ?? false) {
            Debug.AddRect(box, Color.Red);
            harmedByCollision = true;
          }
        }
      }

      ((IPlayerState) fsm.State).PostUpdate(StandingOnGround);

      if (harmedByCollision && invincibilityTime <= 0) {
        world.ScreenShake();
        Health -= 1;
        invincibilityTime = 0.6f;
      }

      if (inputMovement.X > 0) {
        Facing = 1;
      } else if (inputMovement.X < 0) {
        Facing = -1;
      }
      if (inputMovement.X != 0) {
        pose = Pose.Walking;
      } else {
        pose = Pose.Standing;
      }
    }

    // Returns the desired (dx, dy) for the player to move this frame.
    Vector2 HandleInput(float modelTime, World world, History<Input> input) {
      fsm.Update(modelTime, world, input);
      // TODO: remove ugly cast.
      return ((IPlayerState) fsm.State).Movement;
    }

    private Rectangle GetTextureSource(Pose pose) {
      double time = Clock.ModelTime.TotalSeconds;
      switch (pose) {
        case Pose.Walking:
        case Pose.Jumping:
          return Sprites.Ninja.GetTextureSource("run", time);
        case Pose.SwordSwing:
          // TODO: make a proper animation class & FSM-driven animations.
          //return Sprites.Ninja.GetTextureSource(
          //    "attack_sword", 0.3 - swordSwingTime);
        case Pose.Standing:
        default:
          return Sprites.Ninja.GetTextureSource("idle", time);
      }
    }

    public void Draw(SpriteBatch spriteBatch) {
      Rectangle textureSource = GetTextureSource(pose);
      Vector2 spriteCenter = new Vector2(spriteWidth / 2, spriteHeight / 2 + spriteCenterYOffset);
      SpriteEffects effect = Facing == 1 ?
        SpriteEffects.None : SpriteEffects.FlipHorizontally;
      Color color = Color.White;
      if (invincibilityTime > 0 && invincibilityTime % 0.2f > 0.1f) {
        color = new Color(0.5f, 0.5f, 0.5f, 0.5f);
      }
      spriteBatch.Draw(Textures.Ninja.Get, Vector2.Floor(position), textureSource, color, 0f,
        spriteCenter, Vector2.One, effect, 0f);
    }
  }
}