sneak/Shared/Player.cs

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

namespace SemiColinGames {
  class Player {
    private enum Pose { Walking, Standing, Crouching, Stretching, SwordSwing, Jumping };

    private const int moveSpeed = 180;
    private const int jumpSpeed = -600;
    private const int gravity = 1600;

    // 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 Point position = new Point(64, 16 * 12);
    private Vector2 halfSize = new Vector2(11, 24);
    private Vector2 eyeOffsetStanding = new Vector2(7, -14);
    private Vector2 eyeOffsetWalking = new Vector2(15, -7);

    private int jumps = 0;
    private Pose pose = Pose.Jumping;
    private double swordSwingTime = 0;
    private int swordSwingNum = 0;
    private const int swordSwingMax = 6;
    private float ySpeed = 0;
    private double jumpTime = 0;

    public Player() {
    }

    public int Facing { get; private set; } = 1;

    public Point Position { get { return position; } }

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

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

      Vector2 movement = HandleInput(modelTime, input);

      // Broad test: remove all collision targets nowhere near the player.
      // TODO: don't allocate a list here.
      var candidates = new List<AABB>();
      // 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(
        new Vector2(position.X + movement.X / 2, position.Y + movement.Y / 2),
        new Vector2(halfSize.X + Math.Abs(movement.X) + 1, halfSize.Y + Math.Abs(movement.Y) + 1));
      foreach (var box in collisionTargets) {
        if (box.Intersect(largeBox) != null) {
          // Debug.AddRect(box, Color.Green);
          candidates.Add(box);
        }
      }

      Point[] movePoints = Line.Rasterize(0, 0, (int) movement.X, (int) movement.Y);
      for (int i = 1; i < movePoints.Length; i++) {
        int dx = movePoints[i].X - movePoints[i - 1].X;
        int dy = movePoints[i].Y - movePoints[i - 1].Y;
        if (dy != 0) {
          Point newPosition = new Point(position.X, position.Y + dy);
          AABB player = Box(newPosition);
          bool reject = false;
          foreach (var box in candidates) {
            if (box.Intersect(player) != null) {
              reject = true;
              break;
            }
          }
          if (!reject) {
            position = newPosition;
          }
        }
        if (dx != 0) {
          Point newPosition = new Point(position.X + dx, position.Y);
          AABB player = Box(newPosition);
          bool reject = false;
          foreach (var box in candidates) {
            if (box.Intersect(player) != null) {
              reject = true;
              break;
            }
          }
          if (!reject) {
            position = newPosition;
          }
        }
      }

      bool standingOnGround = false;
      AABB groundIntersect = BoxOffset(position, 1);
      foreach (var box in candidates) {
        if (groundIntersect.Intersect(box) != null) {
          standingOnGround = true;
          break;
        }
      }

      if (standingOnGround) {
        jumps = 1;
        ySpeed = -0.0001f;
        // Debug.AddRect(Box(position), Color.Cyan);
        double jumpElapsed = Clock.ModelTime.TotalSeconds - jumpTime;
        if (jumpElapsed > 0.2) {
          Debug.WriteLine("jump time: " + jumpElapsed);
        }
        jumpTime = Clock.ModelTime.TotalSeconds;
      } else {
        jumps = 0;
        // Debug.AddRect(Box(position), Color.Orange);
      }

      if (movement.X > 0) {
        Facing = 1;
      } else if (movement.X < 0) {
        Facing = -1;
      }
      if (swordSwingTime > 0) {
        pose = Pose.SwordSwing;
      } else if (jumps == 0) {
        pose = Pose.Jumping;
      } else if (movement.X != 0) {
        pose = Pose.Walking;
      } else if (input[0].Motion.Y > 0) {
        pose = Pose.Stretching;
      } else if (input[0].Motion.Y < 0) {
        pose = Pose.Crouching;
      } else {
        pose = Pose.Standing;
      }
    }

    public Vector2 EyePosition {
      get {
        bool walking = pose == Pose.Walking || pose == Pose.Jumping;
        Vector2 eyeOffset = walking ? eyeOffsetWalking : eyeOffsetStanding;
        return Vector2.Add(
            Position.ToVector2(), new Vector2(eyeOffset.X * Facing, eyeOffset.Y));
      }
    }

    public float VisionRange {
      get {
        return 150;
      }
    }

    public float FieldOfView {
      get {
        return FMath.DegToRad(120);
      }
    }

    public Vector2 VisionRay {
      get {
        Vector2 ray = new Vector2(VisionRange * Facing, 0);
        if (pose == Pose.Stretching) {
          ray = ray.Rotate(Facing * FMath.DegToRad(-30));
        }
        if (pose == Pose.Crouching) {
          ray = ray.Rotate(Facing * FMath.DegToRad(30));
        }
        return ray;
      }
    }

    // Returns the desired (dx, dy) for the player to move this frame.
    Vector2 HandleInput(float modelTime, History<Input> input) {
      Vector2 result = new Vector2() {
        X = (int) (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 = (swordSwingNum + 1) % swordSwingMax;
      }

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

    private int SpriteIndex(Pose pose) {
      int frameNum = (int) Clock.ModelTime.TotalMilliseconds / 125 % 4;
      switch (pose) {
        case Pose.Walking:
          return 35 + frameNum;
        case Pose.Jumping:
          return 35 + frameNum;
        case Pose.SwordSwing:
          if (swordSwingTime > 0.2) {
            return 0 + swordSwingNum * 3;
          } else if (swordSwingTime > 0.1) {
            return 1 + swordSwingNum * 3;
          } else {
            return 2 + swordSwingNum * 3;
          }
        case Pose.Crouching:
        case Pose.Stretching:
        case Pose.Standing:
        default: {
            if (frameNum == 3) {
              frameNum = 1;
            }
            return 29 + frameNum;
          }
      }
    }

    public void Draw(SpriteBatch spriteBatch) {
      int index = SpriteIndex(pose);
      Rectangle textureSource = new Rectangle(index * spriteWidth, 0, spriteWidth, spriteHeight);
      Vector2 spriteCenter = new Vector2(spriteWidth / 2, spriteHeight / 2 + spriteCenterYOffset);
      SpriteEffects effect = Facing == 1 ?
        SpriteEffects.FlipHorizontally : SpriteEffects.None;
      spriteBatch.Draw(Textures.Player, position.ToVector2(), textureSource, Color.White, 0f,
        spriteCenter, Vector2.One, effect, 0f);
    }
  }
}