270 lines
6.8 KiB
Rust
270 lines
6.8 KiB
Rust
use std::time::{Duration, Instant};
|
|
|
|
use sfml::graphics::{FloatRect, IntRect, View};
|
|
use sfml::system::Vector2;
|
|
use sfml::window::Event;
|
|
|
|
use crate::engine::controls::{Action, Controls};
|
|
use crate::engine::math::{clamp, duration_as_f32, duration_as_frame};
|
|
use crate::engine::physics;
|
|
use crate::engine::renderer::Drawable;
|
|
use crate::engine::scene::Updatable;
|
|
use crate::engine::texture::Texture;
|
|
|
|
/// The different sides a character can face.
|
|
pub enum Side {
|
|
/// The character looks to the left.
|
|
Left,
|
|
|
|
/// The character looks to the right.
|
|
Right,
|
|
}
|
|
|
|
/// This enum represents the type of damages that the character can get.
|
|
#[derive(Copy, Clone)]
|
|
pub enum Damage {
|
|
/// No damage were made
|
|
None,
|
|
|
|
/// A single point of life has been taken from the character.
|
|
One,
|
|
|
|
/// The character died.
|
|
Death,
|
|
}
|
|
|
|
impl Side {
|
|
/// Returns the side corresponding to the force.
|
|
///
|
|
/// Returns None if the force is null.
|
|
pub fn from_force(force: Vector2<f32>) -> Option<Side> {
|
|
if force.x > 0.0 {
|
|
Some(Side::Right)
|
|
} else if force.x < 0.0 {
|
|
Some(Side::Left)
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
/// Returns the offset in the texture.
|
|
pub fn offset(&self) -> i32 {
|
|
match *self {
|
|
Side::Left => 32,
|
|
Side::Right => 0,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// A character, enemy or controllable.
|
|
pub struct Character {
|
|
/// The position of the character.
|
|
pub position: Vector2<f32>,
|
|
|
|
/// The speed of the character.
|
|
pub speed: Vector2<f32>,
|
|
|
|
/// If the player is controlling a character.
|
|
controls: Option<Controls>,
|
|
|
|
/// The side of the character.
|
|
side: Side,
|
|
|
|
/// The number of hp of the character.
|
|
hp: u32,
|
|
|
|
/// The counter of jumps.
|
|
///
|
|
/// When it's 0, the character can no longer jump.
|
|
jump_counter: usize,
|
|
|
|
/// The maximum number of jumps a character can do.
|
|
///
|
|
/// It's reset when the character hits the ground.
|
|
max_jump: usize,
|
|
|
|
/// The timer of the character's animation.
|
|
animation_timer: Instant,
|
|
|
|
/// Whether the character is walking or not.
|
|
walking: bool,
|
|
|
|
/// Indicates that the player has released the jump button.
|
|
can_jump: bool,
|
|
}
|
|
|
|
impl Character {
|
|
/// Creates a character in (0, 0).
|
|
fn generic(controls: Option<Controls>) -> Character {
|
|
Character {
|
|
position: Vector2::new(0.0, 0.0),
|
|
speed: Vector2::new(0.0, 0.0),
|
|
controls,
|
|
side: Side::Right,
|
|
hp: 1,
|
|
jump_counter: 1,
|
|
max_jump: 1,
|
|
animation_timer: Instant::now(),
|
|
can_jump: true,
|
|
walking: false,
|
|
}
|
|
}
|
|
|
|
/// Creates a character in (0, 0).
|
|
pub fn new() -> Character {
|
|
Character::generic(None)
|
|
}
|
|
|
|
/// Creates a character with the specified controls.
|
|
pub fn with_controls(controls: Controls) -> Character {
|
|
Character::generic(Some(controls))
|
|
}
|
|
|
|
/// Sets the position of the character.
|
|
pub fn set_position<S: Into<Vector2<f32>>>(&mut self, position: S) {
|
|
self.position = position.into();
|
|
}
|
|
|
|
/// Makes the character jump.
|
|
pub fn jump(&mut self) {
|
|
if self.can_jump && self.jump_counter > 0 {
|
|
self.jump_counter -= 1;
|
|
self.speed.y = physics::JUMP_SPEED.y;
|
|
}
|
|
}
|
|
|
|
/// Resets the jump counter.
|
|
pub fn ground_collision(&mut self) {
|
|
self.jump_counter = self.max_jump;
|
|
}
|
|
|
|
/// Make the player fall.
|
|
pub fn fall_off(&mut self) {
|
|
if self.jump_counter == self.max_jump {
|
|
self.jump_counter -= 1;
|
|
}
|
|
}
|
|
|
|
/// Returns a reference to the controls.
|
|
pub fn controls(&self) -> &Option<Controls> {
|
|
&self.controls
|
|
}
|
|
|
|
/// Returns a view that looks at the character.
|
|
pub fn view(&self) -> View {
|
|
View::new(self.position, Vector2::new(24.0 * 16.0, 24.0 * 9.0))
|
|
}
|
|
|
|
/// Returns the collision bounding box of the character.
|
|
pub fn bbox(&self) -> FloatRect {
|
|
FloatRect::new(self.position.x + 8.0, self.position.y, 16.0, 32.0)
|
|
}
|
|
|
|
/// Returns the number of hp of the character.
|
|
pub fn hp(&self) -> u32 {
|
|
self.hp
|
|
}
|
|
|
|
/// Returns true if the character is alive.
|
|
pub fn is_alive(&self) -> bool {
|
|
self.hp > 0
|
|
}
|
|
|
|
/// Returns true if the character is dead.
|
|
pub fn is_dead(&self) -> bool {
|
|
self.hp == 0
|
|
}
|
|
|
|
/// Takes the corresponding damage.
|
|
pub fn take_damage(&mut self, damage: Damage) {
|
|
match damage {
|
|
Damage::None => (),
|
|
Damage::One => self.hp -= 1,
|
|
Damage::Death => self.hp = 0,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Updatable for Character {
|
|
fn update(&mut self, duration: &Duration) {
|
|
let mut force: Vector2<f32> = Vector2::new(0.0, 0.0);
|
|
|
|
if let Some(ref controls) = self.controls {
|
|
force += controls.direction();
|
|
}
|
|
|
|
if let Some(side) = Side::from_force(force) {
|
|
if !self.walking {
|
|
self.animation_timer = Instant::now();
|
|
}
|
|
self.walking = true;
|
|
self.side = side;
|
|
} else {
|
|
if self.walking {
|
|
self.animation_timer = Instant::now();
|
|
}
|
|
self.walking = false;
|
|
}
|
|
|
|
let duration = duration_as_f32(duration);
|
|
|
|
// Compute acceleration
|
|
let accel = physics::G + force * 64.0 * 64.0;
|
|
|
|
// Compute speed
|
|
self.speed.x *= physics::GROUND_FRICTION.x;
|
|
self.speed += accel * duration;
|
|
|
|
if self.speed.y > physics::MAXIMUM_VERTICAL_SPEED {
|
|
self.speed.y = physics::MAXIMUM_VERTICAL_SPEED;
|
|
}
|
|
|
|
let limit = match self.controls {
|
|
Some(controls) if controls.is_running() => physics::MAXIMUM_RUNNING_SPEED,
|
|
_ => physics::MAXIMUM_WALKING_SPEED,
|
|
};
|
|
|
|
self.speed.x = clamp(self.speed.x, -limit, limit);
|
|
|
|
// Compute position
|
|
self.position += self.speed * duration;
|
|
}
|
|
|
|
fn manage_event(&mut self, event: &Event) {
|
|
let action = if let Some(ref controls) = self.controls {
|
|
controls.convert(event)
|
|
} else {
|
|
None
|
|
};
|
|
|
|
match action {
|
|
Some(Action::Jump(true)) => {
|
|
self.jump();
|
|
self.can_jump = false;
|
|
}
|
|
|
|
Some(Action::Jump(false)) => {
|
|
self.can_jump = true;
|
|
}
|
|
|
|
_ => (),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Drawable for Character {
|
|
fn texture(&self) -> Texture {
|
|
Texture::Rusty
|
|
}
|
|
|
|
fn texture_rect(&self) -> IntRect {
|
|
let frame = duration_as_frame(&Instant::now().duration_since(self.animation_timer), 4);
|
|
let offset = if self.walking { 64 } else { 0 };
|
|
IntRect::new(self.side.offset() + offset, frame * 32, 32, 32)
|
|
}
|
|
|
|
fn position(&self) -> Vector2<f32> {
|
|
self.position
|
|
}
|
|
}
|