diff --git a/src/engine.rs b/src/engine.rs index dd6da21..dd82e9c 100644 --- a/src/engine.rs +++ b/src/engine.rs @@ -3,6 +3,7 @@ use std::collections::HashSet; use std::rc::Rc; use std::time::{Duration, Instant}; +pub use component_macro::Component; pub use sdl2::keyboard::Keycode; use sdl2::{ @@ -69,19 +70,19 @@ where currently_pressed_keys: &'context HashSet, } -pub struct Quwi(std::marker::PhantomData); +pub struct ComponentQuery(std::marker::PhantomData); -impl Quwi { +impl ComponentQuery { pub fn new() -> Self { Self(std::marker::PhantomData) } } -pub trait QuwiQuwi { +pub trait QueryRunner { fn run(&self, context: &Context) -> Vec; } -impl QuwiQuwi for Quwi +impl QueryRunner for ComponentQuery where T0: 'static + Component, { @@ -90,7 +91,7 @@ where } } -impl QuwiQuwi for Quwi<(T0, T1)> +impl QueryRunner for ComponentQuery<(T0, T1)> where T0: 'static + Component, T1: 'static + Component, @@ -104,7 +105,7 @@ where } } -impl QuwiQuwi for Quwi<(T0, T1, T2)> +impl QueryRunner for ComponentQuery<(T0, T1, T2)> where T0: 'static + Component, T1: 'static + Component, @@ -123,6 +124,33 @@ where } } +#[macro_export] +macro_rules! query { + ($ctx:expr, $t:ty) => { + { + use engine::QueryRunner; + engine::ComponentQuery::<$t>::new().run($ctx) + } + }; + ($ctx:expr, $($ts:ty),+) => { + { + #[allow(unused_imports)] + use engine::QueryRunner; + engine::ComponentQuery::<($($ts),+)>::new().run($ctx) + } + }; +} + +#[macro_export] +macro_rules! spawn { + ($ctx:expr, [$($ts:expr),+ $(,)?]) => { + engine::Context::spawn($ctx, vec![$(Box::new($ts)),+]) + }; + ($ctx:expr, $($ts:expr),+ $(,)?) => { + engine::Context::spawn($ctx, vec![$(Box::new($ts)),+]) + }; +} + impl<'context, 'game> Context<'context, 'game> { pub fn entities_with_component(&self) -> Vec { let entity_type_id = TypeId::of::(); @@ -203,9 +231,9 @@ impl<'context, 'game> Context<'context, 'game> { .collect(); } - pub fn add_system(&mut self, system: Rc) { + pub fn add_system(&mut self, system: S) { system.on_add(self); - self.systems.push(system) + self.systems.push(Rc::new(system)) } pub fn key_pressed(&self, keycode: Keycode) -> bool { @@ -248,7 +276,7 @@ impl<'game> Game<'game> { let mut canvas = window.into_canvas().build()?; let texture_creator = canvas.texture_creator(); - canvas.set_draw_color(Color::RGB(60, 180, 180)); + canvas.set_draw_color(Color::BLACK); canvas.clear(); canvas.present(); let event_pump = sdl_context.event_pump()?; @@ -317,4 +345,9 @@ impl<'game> Game<'game> { currently_pressed_keys: &mut self.currently_pressed_keys, } } + + pub fn add_system(&mut self, system: S) { + system.on_add(&mut self.context()); + self.systems.push(Rc::new(system)) + } } diff --git a/src/main.rs b/src/main.rs index 71cfdb6..4f421d3 100644 --- a/src/main.rs +++ b/src/main.rs @@ -2,63 +2,210 @@ mod engine; -use component_macro::Component; -use engine::Component; -use engine::QuwiQuwi; -use engine::System; -use std::rc::Rc; +use engine::{Component, System}; #[derive(Component)] struct Sprite { sprite: engine::Sprite, } -macro_rules! tuplify { - ($t:ty) => { - $t - }; - ($t:ty, $($ts:ty),+) => { - $t, tuplify!($($ts),+) - }; +#[derive(Component, Default, Clone)] +struct RigidBody { + pos: (f64, f64), + vel: (f64, f64), + gravity: bool, + cowision: bool, } -macro_rules! run_quwi { - ($ctx:expr, $t:ty) => { - engine::Quwi::<$t>::new().run($ctx) - }; - ($ctx:expr, $t:ty, $($ts:ty),+) => { - engine::Quwi::<($t, tuplify!($($ts),+))>::new().run($ctx) - }; -} - -#[derive(Component)] -struct Position(f64, f64); - -#[derive(Clone, Component)] -struct Velocity(f64, f64); - struct VelocitySystem; impl System for VelocitySystem { fn on_update(&self, ctx: &mut engine::Context, delta: f64) -> Result<(), engine::Error> { - for id in run_quwi!(ctx, Velocity, Position) { - let vel = ctx.entity_component::(id).clone(); - let Position(x, y) = ctx.entity_component::(id); - *x += vel.0 * delta; - *y += vel.1 * delta; + for id in query!(ctx, RigidBody) { + let body = ctx.entity_component::(id); + body.pos.0 += body.vel.0 * delta; + body.pos.1 += body.vel.1 * delta; } Ok(()) } } -#[derive(Component)] -struct Gravity; +#[derive(Component, Clone)] +struct Rect { + width: f64, + height: f64, +} +impl Rect { + pub fn rect_collides(&self, pos: (f64, f64), other: &Rect, other_pos: (f64, f64)) -> bool { + pos.0 + self.width > other_pos.0 + && pos.0 <= other_pos.0 + other.width + && pos.1 + self.height > other_pos.1 + && pos.1 <= other_pos.1 + other.height + } + + pub fn point_collides(&self, pos: (f64, f64), point: (f64, f64)) -> bool { + pos.0 + self.width > point.0 + && pos.0 <= point.0 + && pos.1 + self.height > point.1 + && pos.1 <= point.1 + } +} +// +// enum CollisionGroup { +// Player, +// World, +// } +// +// impl CollisionGroup { +// pub fn should_collide(&self, other: &Self) -> bool { +// match (self, other) { +// (CollisionGroup::Player, CollisionGroup::Player) => todo!(), +// (CollisionGroup::Player, CollisionGroup::World) => todo!(), +// (CollisionGroup::World, CollisionGroup::Player) => todo!(), +// (CollisionGroup::World, CollisionGroup::World) => todo!(), +// } +// } +// } +// + +#[derive(Component, Clone, Default)] +struct Collider { + resolve: bool, +} + +fn horizontal_line_intersect(p0: (f64, f64), vel: (f64, f64), line_y: f64) -> (f64, f64) { + // y = ax + b + let a = vel.1 / vel.0; + let b = p0.1 - p0.0 * a; + + let x = (line_y - b) / a; + (x, line_y) +} + +fn vertical_line_intersect(p0: (f64, f64), vel: (f64, f64), line_x: f64) -> (f64, f64) { + // y = ax + b + let a = vel.1 / vel.0; + let b = p0.1 - p0.0 * a; + + let y = a * line_x + b; + (line_x, y) +} + +enum Surface { + Top, + Bottom, + Left, + Right, +} + +fn point_distance(a: (f64, f64), b: (f64, f64)) -> f64 { + ((a.0 - b.0).abs().powi(2) + (a.1 - b.1).abs().powi(2)).sqrt() +} + +fn closest_surface_for_point_and_rectangle_and_your_mom( + p0: (f64, f64), + vel: (f64, f64), + rect_pos: (f64, f64), + rect: &Rect, +) -> Option<(f64, Surface)> { + [ + (horizontal_line_intersect(p0, vel, rect_pos.1), Surface::Top), + ( + horizontal_line_intersect(p0, vel, rect_pos.1 + rect.height), + Surface::Bottom, + ), + (vertical_line_intersect(p0, vel, rect_pos.0), Surface::Left), + ( + horizontal_line_intersect(p0, vel, rect_pos.0 + rect.width), + Surface::Right, + ), + ] + .into_iter() + .filter(|(point, _)| rect.point_collides(rect_pos, *point)) + .map(|(point, surface)| (point_distance(p0, point), surface)) + .min_by(|(dist_a, _), (dist_b, _)| dist_a.total_cmp(&dist_b)) +} + +struct CollisionSystem; +impl System for CollisionSystem { + fn on_update(&self, ctx: &mut engine::Context, delta: f64) -> Result<(), engine::Error> { + for id in query!(ctx, RigidBody, Rect, Collider) { + let collider = ctx.entity_component::(id).clone(); + if !collider.resolve { + continue; + } + let body = ctx.entity_component::(id).clone(); + let rect = ctx.entity_component::(id).clone(); + for other_id in query!(ctx, RigidBody, Rect, Collider) { + if id == other_id { + continue; + } + let other_rect = ctx.entity_component::(id).clone(); + let other_body = ctx.entity_component::(id).clone(); + if rect.rect_collides(body.pos, &other_rect, other_body.pos) { + println!("collider vi?"); + let last_pos = ( + body.pos.0 - body.vel.0 * delta, + body.pos.1 - body.vel.1 * delta, + ); + let closest_surface = [ + (last_pos.0, last_pos.1), + (last_pos.0, last_pos.1 + rect.height), + (last_pos.0 + rect.width, last_pos.1), + (last_pos.0 + rect.width, last_pos.1 + rect.height), + ] + .into_iter() + .map(|p0| { + closest_surface_for_point_and_rectangle_and_your_mom( + p0, + body.vel, + other_body.pos, + &other_rect, + ) + }) + .filter_map(std::convert::identity) + .min_by(|(dist_a, _), (dist_b, _)| dist_a.total_cmp(&dist_b)) + .map(|(_, surface)| surface) + .ok_or_else(|| "we already checked if collision happens")?; + + let body = ctx.entity_component::(id); + match closest_surface { + Surface::Top => { + body.vel.1 = 0.0; + body.pos.1 = other_body.pos.1 - rect.height; + } + Surface::Bottom => { + body.vel.1 = 0.0; + body.pos.1 = other_body.pos.1 + other_rect.height; + } + Surface::Left => { + body.vel.0 = 0.0; + body.pos.0 = other_body.pos.0 + other_rect.width; + } + Surface::Right => { + body.vel.0 = 0.0; + body.pos.0 = other_body.pos.0 - rect.width; + } + } + } + } + } + Ok(()) + } +} struct GravitySystem; impl System for GravitySystem { fn on_update(&self, ctx: &mut engine::Context, delta: f64) -> Result<(), engine::Error> { - for id in run_quwi!(ctx, Gravity, Velocity) { - let Velocity(_, y) = ctx.entity_component::(id); - *y = if *y < 800.0 { *y + 400.0 * delta } else { *y }; + for id in query!(ctx, RigidBody) { + let body = ctx.entity_component::(id); + if !body.gravity { + continue; + } + body.vel.1 = if body.vel.1 < 800.0 { + body.vel.1 + 400.0 * delta + } else { + body.vel.1 + }; } Ok(()) } @@ -68,28 +215,34 @@ impl System for GravitySystem { struct Cloud; struct CloudSystem; - impl System for CloudSystem { fn on_update(&self, ctx: &mut engine::Context, delta: f64) -> Result<(), engine::Error> { let cloud_amount = ctx.entities_with_component::().len(); if cloud_amount < 1 { let cloud = ctx.load_sprite("textures/clouds.png").unwrap(); - ctx.spawn(vec![ - Box::new(Cloud), - Box::new(Sprite { sprite: cloud }), - Box::new(Position(-100.0, 150.0)), - Box::new(Velocity(0.0, 0.0)), - ]); + spawn!( + ctx, + Cloud, + Sprite { sprite: cloud }, + RigidBody { + pos: (-100.0, 150.0), + ..Default::default() + }, + ); } - for id in run_quwi!(ctx, Cloud, Velocity) { - let Velocity(x, _) = ctx.entity_component::(id); - *x = if *x < 200.0 { *x + 200.0 * delta } else { *x }; + for id in query!(ctx, Cloud, RigidBody) { + let body = ctx.entity_component::(id); + body.vel.0 = if body.vel.0 < 200.0 { + body.vel.0 + 200.0 * delta + } else { + body.vel.0 + }; } - for id in run_quwi!(ctx, Cloud, Velocity) { - let Position(x, _) = ctx.entity_component::(id); - if *x > 1400.0 { + for id in query!(ctx, Cloud, RigidBody) { + let body = ctx.entity_component::(id); + if body.pos.0 > 1400.0 { ctx.despawn(id); } } @@ -100,11 +253,11 @@ impl System for CloudSystem { struct SpriteRenderer; impl System for SpriteRenderer { fn on_update(&self, ctx: &mut engine::Context, _delta: f64) -> Result<(), engine::Error> { - for id in run_quwi!(ctx, Sprite, Position) { - let &mut Position(x, y) = ctx.entity_component::(id); + for id in query!(ctx, Sprite, RigidBody) { + let body = ctx.entity_component::(id).clone(); let sprite = ctx.entity_component::(id).sprite; - ctx.draw_sprite(sprite, x as i32, y as i32)?; + ctx.draw_sprite(sprite, body.pos.0 as i32, body.pos.1 as i32)?; } Ok(()) } @@ -116,11 +269,11 @@ struct PlayerMovement; struct PlayerMovementSystem; impl System for PlayerMovementSystem { fn on_update(&self, ctx: &mut engine::Context, _delta: f64) -> Result<(), engine::Error> { - for id in run_quwi!(ctx, PlayerMovement, Velocity) { + for id in query!(ctx, PlayerMovement, RigidBody) { let d_down = ctx.key_pressed(engine::Keycode::D); let a_down = ctx.key_pressed(engine::Keycode::A); - let Velocity(x, _) = ctx.entity_component::(id); - *x = if d_down && !a_down { + let body = ctx.entity_component::(id); + body.vel.0 = if d_down && !a_down { 400.0 } else if !d_down && a_down { -400.0 @@ -136,25 +289,49 @@ fn main() { let mut game = engine::Game::new().unwrap(); let mut context = game.context(); - context.add_system(Rc::new(VelocitySystem)); - context.add_system(Rc::new(SpriteRenderer)); - context.add_system(Rc::new(GravitySystem)); - context.add_system(Rc::new(PlayerMovementSystem)); - context.add_system(Rc::new(CloudSystem)); + context.add_system(VelocitySystem); + context.add_system(CollisionSystem); + context.add_system(SpriteRenderer); + context.add_system(GravitySystem); + context.add_system(PlayerMovementSystem); + context.add_system(CloudSystem); let player = context.load_sprite("textures/player.png").unwrap(); - let background = context.load_sprite("textures/mountains.png").unwrap(); + let background = context.load_sprite("textures/literally_dprk.png").unwrap(); - context.spawn(vec![ - Box::new(Sprite { sprite: background }), - Box::new(Position(0.0, 0.0)), - ]); + spawn!( + &mut context, + Sprite { sprite: background }, + RigidBody::default(), + ); + + spawn!( + &mut context, + Sprite { sprite: player }, + RigidBody { + pos: (400.0, 400.0), + gravity: true, + ..Default::default() + }, + Rect { + width: 256.0, + height: 256.0 + }, + Collider { resolve: true }, + PlayerMovement, + ); + + spawn!( + &mut context, + RigidBody { + pos: (0.0, 650.0), + ..Default::default() + }, + Rect { + width: 1000.0, + height: 25.0 + }, + Collider { resolve: false }, + ); - context.spawn(vec![ - Box::new(Sprite { sprite: player }), - Box::new(Position(16.0, 500.0)), - Box::new(Velocity(0.0, -600.0)), - Box::new(Gravity), - Box::new(PlayerMovement), - ]); game.run(); } diff --git a/textures/literally_dprk.png b/textures/literally_dprk.png new file mode 100644 index 0000000..47308c9 Binary files /dev/null and b/textures/literally_dprk.png differ