sneak/Shared/Player.cs

276 lines
8.8 KiB
C#
Raw Normal View History

using Microsoft.Xna.Framework;
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;
private float invincibilityTime = 0;
public Player() {
Health = MaxHealth;
}
public int MaxHealth { get; private set; } = 3;
public int Health { get; private set; }
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);
}
invincibilityTime -= modelTime;
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);
}
}
bool harmedByCollision = false;
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) {
Debug.AddRect(box, Color.Cyan);
reject = true;
if (box.Terrain.IsHarmful) {
Debug.AddRect(box, Color.Red);
harmedByCollision = true;
}
}
}
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) {
Debug.AddRect(box, Color.Cyan);
reject = true;
if (box.Terrain.IsHarmful) {
Debug.AddRect(box, Color.Red);
harmedByCollision = true;
}
}
}
if (!reject) {
position = newPosition;
}
}
}
bool 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.Terrain.IsHarmful) {
Debug.AddRect(box, Color.Red);
harmedByCollision = true;
}
}
}
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 (harmedByCollision && invincibilityTime <= 0) {
Health -= 1;
invincibilityTime = 0.6f;
}
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;
SoundEffects.SwordSwings[swordSwingNum % SoundEffects.SwordSwings.Length].Play();
}
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.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.Player.Get, position.ToVector2(), textureSource, color, 0f,
spriteCenter, Vector2.One, effect, 0f);
}
}
}