diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/components.rs | 17 | ||||
| -rw-r--r-- | src/main.rs | 20 | ||||
| -rw-r--r-- | src/math/mod.rs | 93 | ||||
| -rw-r--r-- | src/math/rect.rs | 203 | ||||
| -rw-r--r-- | src/math/vec2.rs | 231 | ||||
| -rw-r--r-- | src/systems/draw.rs | 40 | ||||
| -rw-r--r-- | src/systems/input.rs | 88 | ||||
| -rw-r--r-- | src/systems/mod.rs | 3 | ||||
| -rw-r--r-- | src/systems/movement.rs | 43 |
9 files changed, 720 insertions, 18 deletions
diff --git a/src/components.rs b/src/components.rs index c92ca03..9b51bc6 100644 --- a/src/components.rs +++ b/src/components.rs @@ -1,15 +1,22 @@ +use sdl2::rect::Rect; use specs::prelude::*; use specs_derive::*; +use crate::math::Vec2; + #[derive(Component, Debug, Clone, Copy)] -pub struct Pos -{ - pub x: f64, - pub y: f64, -} +pub struct Pos(pub Vec2<f64>); + +#[derive(Component, Debug, Clone, Copy)] +pub struct Velocity(pub Vec2<f64>); #[derive(Component)] pub struct StaticDrawable { pub texture_name: String, + pub source_rect: Rect, } + +#[derive(Component, Default)] +#[storage(NullStorage)] +pub struct Player; diff --git a/src/main.rs b/src/main.rs index 60186b3..8bc4faf 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,11 +1,16 @@ +#![allow(dead_code)] + pub mod components; +pub mod math; pub mod systems; pub mod texture_manager; -use components::{Pos, StaticDrawable}; +use components::*; +use math::Vec2; +use sdl2::rect::Rect; use specs::prelude::*; use specs::{DispatcherBuilder, World}; -use systems::{SysDraw, SysInput}; +use systems::{SysDraw, SysInput, SysMovement}; fn main() { @@ -23,23 +28,30 @@ fn main() let mut world = World::new(); world.register::<Pos>(); world.register::<StaticDrawable>(); + world.register::<Velocity>(); + world.register::<Player>(); world .create_entity() - .with(Pos { x: 0., y: 0. }) + .with(Pos(Vec2::new(0., 0.))) + .with(Velocity(Vec2::new(0., 0.))) .with(StaticDrawable { texture_name: "portraits.png".to_string(), + source_rect: Rect::new(0, 0, 40, 40), }) + .with(Player) .build(); let sys_input = SysInput::new(&sdl); let sys_draw = SysDraw::new(window); + let sys_move = SysMovement::new(); let mut dispatcher = DispatcherBuilder::new() + .with(sys_move, "move", &[]) .with_thread_local(sys_input) .with_thread_local(sys_draw) .build(); loop { - dispatcher.dispatch(&mut world); + dispatcher.dispatch(&world); } } diff --git a/src/math/mod.rs b/src/math/mod.rs new file mode 100644 index 0000000..8b22972 --- /dev/null +++ b/src/math/mod.rs @@ -0,0 +1,93 @@ +//! Useful mathematical operations in graphical contexts. + +pub mod rect; +pub mod vec2; + +use std::cmp::Ordering; + +use nalgebra::RealField; +use num_traits::Pow; + +pub use self::rect::*; +pub use self::vec2::*; + +/// Round a floating point number to the nearest step given by the step +/// argument. For instance, if the step is 0.5, then all numbers from 0.0 to +/// 0.24999... will be 0., while all numbers from 0.25 to 0.74999... will be 0.5 +/// and so on. +pub fn round<T>(num: T, step: T) -> T +where + T: RealField, +{ + // Only positive steps will be accepted. + assert!(step > T::zero()); + + let lower_bound = (num / step).floor() * step; + let upper_bound = lower_bound + step; + + // Compare the distances and prefer the smaller. If they are the same, prefer + // the upper bound. + if (num - lower_bound) < (upper_bound - num) { + lower_bound + } + else { + upper_bound + } +} + +/// Like round, but instead of rounding to a certain fraction, rounds to the nth +/// decimal place instead of taking a granularity. +pub fn round_nth_decimal<T>(num: T, decimal_place: u16) -> T +where + T: RealField + Pow<u16, Output = T>, +{ + round(num, nalgebra::convert::<f64, T>(0.1).pow(decimal_place)) +} + +/// Works like `std::cmp::max`, however also allows partial comparisons. It is +/// specifically designed so functions that should be able to use f32 and f64 +/// work, eventhough these do not implement Ord. The downside of this function +/// however is, that its behaviour is undefined when `f32::NaN` for instance +/// were to be passed. +pub(crate) fn partial_max<T>(a: T, b: T) -> T +where + T: PartialOrd, +{ + match a.partial_cmp(&b) { + Some(Ordering::Greater) => a, + _ => b, + } +} +/// Like `partial_max`, but for minimum values. Comes with the same downside, +/// too. +pub(crate) fn partial_min<T>(a: T, b: T) -> T +where + T: PartialOrd, +{ + match a.partial_cmp(&b) { + Some(Ordering::Less) => a, + _ => b, + } +} + +#[cfg(test)] +mod test +{ + #[test] + fn partial_max() + { + assert_eq!(super::partial_max(0., 0.), 0.); + assert_eq!(super::partial_max(-1., 1.), 1.); + assert_eq!(super::partial_max(-2., -1.), -1.); + assert_eq!(super::partial_max(2., 1.), 2.); + } + + #[test] + fn partial_min() + { + assert_eq!(super::partial_min(0., 0.), 0.); + assert_eq!(super::partial_min(-1., 1.), -1.); + assert_eq!(super::partial_min(-2., -1.), -2.); + assert_eq!(super::partial_min(2., 1.), 1.); + } +} diff --git a/src/math/rect.rs b/src/math/rect.rs new file mode 100644 index 0000000..55e0b1c --- /dev/null +++ b/src/math/rect.rs @@ -0,0 +1,203 @@ +//! Rectangles where the sides are parallel to the x and y-axes. + +use std::ops::{Add, AddAssign, Sub}; + +//use alga::general::{Additive, Identity}; +use nalgebra::Scalar; +use num_traits::sign::{self, Signed}; +use num_traits::Zero; +use serde::{Deserialize, Serialize}; + +use super::Vec2; + +/// Represents a Rectangle with the value type T. +#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)] +pub struct Rect<T: Scalar + Copy> +{ + /// The x coordinate, or leftmost coordinate of the Rect. + pub x: T, + /// The y coordinate, or rightmost coordinate of the Rect. + pub y: T, + /// The width of the Rect. + pub w: T, + /// The height of the Rect. + pub h: T, +} + +impl<T: Scalar + Copy> Rect<T> +{ + /// Create a new Rectangle from the internal values, where it might be nicer + /// to use a function instead of setting the values directly. + pub fn new(x: T, y: T, w: T, h: T) -> Self { Self { x, y, w, h } } + + /// Create a Rectangle from a slice. Indices are [x, y, w, h]. + pub fn from_slice(slice: [T; 4]) -> Rect<T> + where + T: Copy, + { + Rect { + x: slice[0], + y: slice[1], + w: slice[2], + h: slice[3], + } + } + + /// Move by the Vec provided. + pub fn translate(&mut self, by: Vec2<T>) + where + T: AddAssign, + { + self.x += by.x; + self.y += by.y; + } + + /// Set the posiotien of the rectangle to the given one without changing its + /// size + pub fn set_pos(&mut self, pos: Vec2<T>) + { + self.x = pos.x; + self.y = pos.y; + } + + /// Test if two rectangles intersect. + pub fn intersect<'a>(this: &'a Rect<T>, other: &'a Rect<T>) -> bool + where + T: Add<Output = T> + PartialOrd + Copy, + { + !(this.x > other.x + other.w + || this.x + this.w < other.x + || this.y > other.y + other.h + || this.y + this.h < other.y) + } + + /// Function to calculate the bounding rectangle that is between two + /// vectors. The order of the vectors is irrelevent for this. As long as + /// they are diagonally opposite of each other, this function will work. + pub fn bounding_rect(pos1: Vec2<T>, pos2: Vec2<T>) -> Self + where + T: PartialOrd + Sub<Output = T>, + { + let vertices = [pos1, pos2]; + + Self::bounding_rect_n(&vertices) + } + + /// Function to calculate the bounding rectangle of n vertices provided. The + /// order of them is not relevant and a point that is contained by the + /// vertices will not change the result. + /// + /// # Panics + /// If there is not at least one vertex in the vertices slice, the function + /// will panic, since it is impossible to calculate any bounds in such a + /// case. + pub fn bounding_rect_n(vertices: &[Vec2<T>]) -> Self + where + T: PartialOrd + Sub<Output = T>, + { + if vertices.is_empty() { + panic!("Cannot create bounding rectangle without any vertices"); + } + + let mut min = vertices[0]; + let mut max = vertices[0]; + + for vertex in vertices.iter().skip(1) { + min.x = super::partial_min(min.x, vertex.x); + min.y = super::partial_min(min.y, vertex.y); + max.x = super::partial_max(max.x, vertex.x); + max.y = super::partial_max(max.y, vertex.y); + } + + Self { + x: min.x, + y: min.y, + w: max.x - min.x, + h: max.y - min.y, + } + } + + /// Get the shortest way that must be applied to this Rect to clear out of + /// another Rect of the same type so that they would not intersect any more. + pub fn shortest_way_out(&self, of: &Rect<T>) -> Vec2<T> + where + T: Add<Output = T> + Sub<Output = T> + Signed + PartialOrd, + { + // Check upwards + let mut move_y = of.y - self.y - self.h; + // Check downwards + let move_down = of.y + of.h - self.y; + if move_down < -move_y { + move_y = move_down; + } + + // Check left + let mut move_x = of.x - self.x - self.w; + // Check right + let move_right = of.x + of.w - self.x; + if move_right < -move_x { + move_x = move_right; + } + + if move_x.abs() < move_y.abs() { + Vec2::new(move_x, T::zero()) + } + else { + Vec2::new(T::zero(), move_y) + } + } + + /// Calculate the area of the rectangle. + pub fn area(&self) -> T + where + T: Signed, + { + sign::abs(self.w) * sign::abs(self.h) + } + + fn contains_point(&self, point: &Vec2<T>) -> bool + where + T: Add<Output = T> + PartialOrd, + { + point.x >= self.x + && point.x <= self.x + self.w + && point.y >= self.y + && point.y <= self.y + self.h + } + + fn contains_rect(&self, rect: &Rect<T>) -> bool + where + T: Add<Output = T> + Sub<Output = T> + Zero + PartialOrd, + { + /* True, if the rightmost x-coordinate of the called rectangle is further + * right or the same as the rightmost coordinate of the given rect. + */ + let x_exceeds = self.x + self.w - rect.x - rect.w >= T::zero(); + // The same for the y-coordinates + let y_exceeds = self.y + self.h - rect.y - rect.h >= T::zero(); + + x_exceeds && y_exceeds && self.x <= rect.x && self.y <= rect.y + } + + fn is_inside_rect(&self, rect: &Rect<T>) -> bool + where + T: Add<Output = T> + Sub<Output = T> + Zero + PartialOrd, + { + rect.contains_rect(&self) + } +} + +#[cfg(test)] +mod test +{ + use super::*; + + #[test] + fn test_intersect() + { + let a = Rect::from_slice([0, 0, 4, 4]); + let b = Rect::from_slice([-1, -1, 1, 1]); + + assert!(Rect::intersect(&a, &b)); + } +} diff --git a/src/math/vec2.rs b/src/math/vec2.rs new file mode 100644 index 0000000..5ae0024 --- /dev/null +++ b/src/math/vec2.rs @@ -0,0 +1,231 @@ +//! Two-dimensional vectors and useful operations on them. + +use std::cmp::Ordering; +use std::ops::{Add, AddAssign, Div, Mul, MulAssign, Neg, Sub, SubAssign}; +use std::{fmt, mem}; + +use nalgebra::{RealField, Scalar}; +use num_traits::One; +use serde::{Deserialize, Serialize}; + +use crate::math::Rect; + +/// Describes a vector, which may be a point or a directed length, depending on +/// the interpretation. +#[allow(missing_docs)] +#[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize, Eq, Hash)] +pub struct Vec2<T: Scalar + Copy> +{ + pub x: T, + pub y: T, +} + +impl<T: Scalar + Copy> Vec2<T> +{ + /// Create a new vector from its internal values. + pub fn new(x: T, y: T) -> Self { Self { x, y } } + + /// Finds the euclidian length and returns it. + pub fn length(&self) -> T + where + T: RealField, + { + (self.x * self.x + self.y * self.y).sqrt() + } + + /// Consumes the vector and returns a vector that is rotated by Pi/2 in + /// clockwise direction. This is a special case of rotation and the + /// function is faster than using the nonspecific rotation function. + pub fn rotated_90_clockwise(mut self) -> Vec2<T> + where + T: One + Neg<Output = T> + MulAssign, + { + mem::swap(&mut self.x, &mut self.y); + self.y *= -T::one(); + self + } + + /// Consumes the vector and returns a vector that is rotated by Pi/2 in + /// counterclockwise direction. This is a special case of rotation and + /// the function is faster than using the nonspecific rotation function. + pub fn rotated_90_counterclockwise(mut self) -> Vec2<T> + where + T: One + Neg<Output = T> + MulAssign, + { + mem::swap(&mut self.x, &mut self.y); + self.x *= -T::one(); + self + } +} + +// Begin mathematical operators ----------------------------------------------- + +// Addition +impl<T: Scalar + Add<Output = T> + Copy> Add for Vec2<T> +{ + type Output = Self; + + fn add(self, rhs: Self) -> Self { Vec2::new(self.x + rhs.x, self.y + rhs.y) } +} + +impl<T: Scalar + Add<Output = T> + Copy> Add<(T, T)> for Vec2<T> +{ + type Output = Self; + + fn add(self, (x, y): (T, T)) -> Self { Vec2::new(self.x + x, self.y + y) } +} + +impl<T: Scalar + Add<Output = T> + Copy> Add<T> for Vec2<T> +{ + type Output = Self; + + fn add(self, rhs: T) -> Self { Vec2::new(self.x + rhs, self.y + rhs) } +} + +impl<T: Scalar + AddAssign + Copy> AddAssign for Vec2<T> +{ + fn add_assign(&mut self, rhs: Self) + { + self.x += rhs.x; + self.y += rhs.y; + } +} + +impl<T: Scalar + AddAssign + Copy> AddAssign<(T, T)> for Vec2<T> +{ + fn add_assign(&mut self, (x, y): (T, T)) + { + self.x += x; + self.y += y; + } +} + +// Subtraction +impl<T: Scalar + Sub<Output = T> + Copy> Sub for Vec2<T> +{ + type Output = Self; + + fn sub(self, rhs: Self) -> Self { Vec2::new(self.x - rhs.x, self.y - rhs.y) } +} + +impl<T: Scalar + Sub<Output = T> + Copy> Sub<(T, T)> for Vec2<T> +{ + type Output = Self; + + fn sub(self, (x, y): (T, T)) -> Self { Vec2::new(self.x - x, self.y - y) } +} + +impl<T: Scalar + Sub<Output = T> + Copy> Sub<T> for Vec2<T> +{ + type Output = Self; + + fn sub(self, rhs: T) -> Self { Vec2::new(self.x - rhs, self.y - rhs) } +} + +impl<T: Scalar + SubAssign + Copy> SubAssign for Vec2<T> +{ + fn sub_assign(&mut self, rhs: Self) + { + self.x -= rhs.x; + self.y -= rhs.y; + } +} + +impl<T: Scalar + SubAssign + Copy> SubAssign<(T, T)> for Vec2<T> +{ + fn sub_assign(&mut self, (x, y): (T, T)) + { + self.x -= x; + self.y -= y; + } +} + +// Scalar multiplication +impl<T: Scalar + Add<Output = T> + Mul<Output = T> + Copy> Mul for Vec2<T> +{ + type Output = T; + + fn mul(self, rhs: Self) -> T { self.x * rhs.x + self.y * rhs.y } +} + +impl<T: Scalar + Mul<Output = T> + Copy> Mul<T> for Vec2<T> +{ + type Output = Self; + + fn mul(self, rhs: T) -> Self { Vec2::new(self.x * rhs, self.y * rhs) } +} + +impl<T: Scalar + Div<Output = T> + Copy> Div<T> for Vec2<T> +{ + type Output = Self; + + fn div(self, rhs: T) -> Self { Vec2::new(self.x / rhs, self.y / rhs) } +} + +// End of mathematical operators ---------------------------------------------- + +// By default, the coordinates are first compared by their y-coordinates, then +// their x-coordinates +impl<T: fmt::Debug> PartialOrd for Vec2<T> +where + T: PartialOrd + Copy + 'static, +{ + fn partial_cmp(&self, other: &Self) -> Option<Ordering> + { + match self.y.partial_cmp(&other.y) { + Some(Ordering::Equal) | None => self.x.partial_cmp(&other.x), + y_order => y_order, + } + } +} + +impl<T: fmt::Debug> Ord for Vec2<T> +where + T: Ord + Copy + 'static, +{ + fn cmp(&self, other: &Self) -> Ordering + { + match self.y.cmp(&other.y) { + Ordering::Equal => self.x.cmp(&other.x), + y_order => y_order, + } + } +} + +// Helper function to determine the absolute positive difference between two +// Values, which don't have to be signed. +fn difference_abs<T>(a: T, b: T) -> T +where + T: Sub<Output = T> + PartialOrd, +{ + if a > b { + a - b + } + else { + b - a + } +} + +// Helper function that removes all points inside the vector that are not +// contained inside the optional limit Rect +fn retain_inside_limits<T: 'static>(items: Vec<Vec2<T>>, limits: Option<Rect<T>>) -> Vec<Vec2<T>> +where + T: PartialOrd + std::fmt::Debug + Copy + Add<Output = T>, +{ + // Fast return in case there are no limits + if limits.is_none() { + return items; + } + let limits = limits.unwrap(); + + // Retain only items that are within the bounds of the limits rect + items + .into_iter() + .filter(|v| { + v.x >= limits.x + && v.x <= limits.x + limits.w + && v.y >= limits.y + && v.y <= limits.y + limits.h + }) + .collect() +} diff --git a/src/systems/draw.rs b/src/systems/draw.rs index 1d5ee6b..fd0185e 100644 --- a/src/systems/draw.rs +++ b/src/systems/draw.rs @@ -1,4 +1,8 @@ +use std::thread; +use std::time::{Duration, Instant}; + use sdl2::pixels::Color; +use sdl2::rect::Rect; use sdl2::render::WindowCanvas; use sdl2::video::{Window, WindowContext}; use specs::prelude::*; @@ -6,8 +10,14 @@ use specs::prelude::*; use crate::components::{Pos, StaticDrawable}; use crate::texture_manager::TextureManager; +/// The minimum time in micro a frame should take to limit the number of +/// frames drawn to the screen. 5000 microseconds for a maximum of 200 frames +/// per second. +pub const FRAME_TIME_MIN_US: u64 = (1_000_000. / 200.) as u64; + pub struct SysDraw { + last_frame_time: Instant, canvas: WindowCanvas, texture_manager: TextureManager<WindowContext>, } @@ -25,10 +35,20 @@ impl SysDraw let texture_manager = TextureManager::new(canvas.texture_creator()); Self { + last_frame_time: Instant::now(), canvas, texture_manager, } } + + pub fn delay_for_min_frametime(&mut self) + { + let frame_duration_us = (Instant::now() - self.last_frame_time).as_micros() as u64; + if frame_duration_us < FRAME_TIME_MIN_US { + thread::sleep(Duration::from_micros(FRAME_TIME_MIN_US - frame_duration_us)); + } + self.last_frame_time = Instant::now(); + } } impl<'a> System<'a> for SysDraw @@ -39,20 +59,30 @@ impl<'a> System<'a> for SysDraw { self.canvas.clear(); - // XXX: This is so slow.. yaaaawn. Replace with ids and texture manager - // lifetime? - for (_pos, drawable) in (&pos, &drawable).join() { + /* XXX: This is so slow.. yaaaawn. Replace with ids and texture manager + * lifetime? */ + for (pos, drawable) in (&pos, &drawable).join() { let texture = self .texture_manager .get(&drawable.texture_name) .expect("Unable to load texture"); - // let texture_info = texture.query(); self.canvas - .copy(&texture, None, None) + .copy( + &texture, + Some(drawable.source_rect), + Rect::new( + pos.0.x as i32, + pos.0.y as i32, + drawable.source_rect.width(), + drawable.source_rect.height(), + ), + ) .expect("Unable to draw texture"); } + self.delay_for_min_frametime(); + self.canvas.present(); } } diff --git a/src/systems/input.rs b/src/systems/input.rs index 96ac3b8..13942e0 100644 --- a/src/systems/input.rs +++ b/src/systems/input.rs @@ -1,10 +1,21 @@ use sdl2::event::{Event, WindowEvent}; +use sdl2::keyboard::Scancode; use sdl2::{EventPump, Sdl}; use specs::prelude::*; +use crate::components::{Player, Velocity}; + +pub const PLAYER_SPEED: f64 = 150.; + +pub const ACTION_KEY_UP: u8 = 0b0001; +pub const ACTION_KEY_LEFT: u8 = 0b0010; +pub const ACTION_KEY_DOWN: u8 = 0b0100; +pub const ACTION_KEY_RIGHT: u8 = 0b1000; + pub struct SysInput { - event_pump: EventPump, + pressed_action_keys: u8, + event_pump: EventPump, } impl SysInput @@ -12,17 +23,19 @@ impl SysInput pub fn new(sdl: &Sdl) -> Self { Self { - event_pump: sdl.event_pump().unwrap(), + pressed_action_keys: 0b0, + event_pump: sdl.event_pump().unwrap(), } } } impl<'a> System<'a> for SysInput { - type SystemData = (); + type SystemData = (WriteStorage<'a, Velocity>, ReadStorage<'a, Player>); - fn run(&mut self, (): Self::SystemData) + fn run(&mut self, (mut vel, player): Self::SystemData) { + let mut player_movement_changed = false; for event in self.event_pump.poll_iter() { match event { Event::Quit { .. } => { @@ -34,8 +47,75 @@ impl<'a> System<'a> for SysInput } => { println!("Window resized to {}x{}", x, y); }, + Event::KeyDown { scancode, .. } => match scancode { + Some(Scancode::W) => { + self.pressed_action_keys |= ACTION_KEY_UP; + player_movement_changed = true; + }, + Some(Scancode::A) => { + self.pressed_action_keys |= ACTION_KEY_LEFT; + player_movement_changed = true; + }, + Some(Scancode::S) => { + self.pressed_action_keys |= ACTION_KEY_DOWN; + player_movement_changed = true; + }, + Some(Scancode::D) => { + self.pressed_action_keys |= ACTION_KEY_RIGHT; + player_movement_changed = true; + }, + key => { + println!("keydown received: {:?}", key) + }, + }, + Event::KeyUp { scancode, .. } => match scancode { + Some(Scancode::W) => { + self.pressed_action_keys &= !ACTION_KEY_UP; + player_movement_changed = true; + }, + Some(Scancode::A) => { + self.pressed_action_keys &= !ACTION_KEY_LEFT; + player_movement_changed = true; + }, + Some(Scancode::S) => { + self.pressed_action_keys &= !ACTION_KEY_DOWN; + player_movement_changed = true; + }, + Some(Scancode::D) => { + self.pressed_action_keys &= !ACTION_KEY_RIGHT; + player_movement_changed = true; + }, + _ => {}, + }, _ => {}, } } + + /* Update player movement */ + if player_movement_changed { + for (vel, _player) in (&mut vel, &player).join() { + /* Vertical movement */ + if (self.pressed_action_keys & ACTION_KEY_UP) != 0 { + vel.0.y = -PLAYER_SPEED; + } + else if (self.pressed_action_keys & ACTION_KEY_DOWN) != 0 { + vel.0.y = PLAYER_SPEED; + } + else { + vel.0.y = 0.; + } + + /* Horizontal movement */ + if (self.pressed_action_keys & ACTION_KEY_LEFT) != 0 { + vel.0.x = -PLAYER_SPEED; + } + else if (self.pressed_action_keys & ACTION_KEY_RIGHT) != 0 { + vel.0.x = PLAYER_SPEED; + } + else { + vel.0.x = 0.; + } + } + } } } diff --git a/src/systems/mod.rs b/src/systems/mod.rs index 2c2af6c..5101a83 100644 --- a/src/systems/mod.rs +++ b/src/systems/mod.rs @@ -3,3 +3,6 @@ pub use self::draw::*; pub mod input; pub use self::input::*; + +pub mod movement; +pub use self::movement::*; diff --git a/src/systems/movement.rs b/src/systems/movement.rs new file mode 100644 index 0000000..61c572a --- /dev/null +++ b/src/systems/movement.rs @@ -0,0 +1,43 @@ +use std::time::{Duration, Instant}; + +use specs::prelude::*; + +use crate::components::{Pos, Velocity}; + +pub struct SysMovement +{ + delta_time: Duration, + last_run: Instant, +} + +impl SysMovement +{ + pub fn new() -> Self + { + Self { + delta_time: Duration::ZERO, + last_run: Instant::now(), + } + } +} + +impl Default for SysMovement +{ + fn default() -> Self { Self::new() } +} + +impl<'a> System<'a> for SysMovement +{ + type SystemData = (WriteStorage<'a, Pos>, ReadStorage<'a, Velocity>); + + fn run(&mut self, (mut pos, vel): Self::SystemData) + { + let now = Instant::now(); + self.delta_time = now - self.last_run; + self.last_run = now; + + for (pos, vel) in (&mut pos, &vel).join() { + pos.0 += vel.0 * self.delta_time.as_secs_f64(); + } + } +} |