sfja.skp/pvp-game-dilapidation
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

collision so hawd >~<

Browse Source
This commit is contained in:
SimonFJ20 2024-04-10 15:15:59 +02:00
parent ccec00fcc0
commit 7609eb3e4b
3 changed files with 292 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
src/engine.rs
View File

@ -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<Keycode>,
}
pub struct Quwi<T>(std::marker::PhantomData<T>);
pub struct ComponentQuery<T>(std::marker::PhantomData<T>);
impl<T> Quwi<T> {
impl<T> ComponentQuery<T> {
pub fn new() -> Self {
Self(std::marker::PhantomData)
}
}
pub trait QuwiQuwi {
pub trait QueryRunner {
fn run(&self, context: &Context) -> Vec<u64>;
}
impl<T0> QuwiQuwi for Quwi<T0>
impl<T0> QueryRunner for ComponentQuery<T0>
where
T0: 'static + Component,
{
@ -90,7 +91,7 @@ where
}
}
impl<T0, T1> QuwiQuwi for Quwi<(T0, T1)>
impl<T0, T1> QueryRunner for ComponentQuery<(T0, T1)>
where
T0: 'static + Component,
T1: 'static + Component,
@ -104,7 +105,7 @@ where
}
}
impl<T0, T1, T2> QuwiQuwi for Quwi<(T0, T1, T2)>
impl<T0, T1, T2> 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<T: 'static + Component>(&self) -> Vec<u64> {
let entity_type_id = TypeId::of::<T>();
@ -203,9 +231,9 @@ impl<'context, 'game> Context<'context, 'game> {
.collect();
}
pub fn add_system(&mut self, system: Rc<dyn System>) {
pub fn add_system<S: 'static + 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<S: 'static + System>(&mut self, system: S) {
system.on_add(&mut self.context());
self.systems.push(Rc::new(system))
}
}

323
src/main.rs
View File

@ -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::<Velocity>(id).clone();
let Position(x, y) = ctx.entity_component::<Position>(id);
*x += vel.0 * delta;
*y += vel.1 * delta;
for id in query!(ctx, RigidBody) {
let body = ctx.entity_component::<RigidBody>(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::<Collider>(id).clone();
if !collider.resolve {
continue;
}
let body = ctx.entity_component::<RigidBody>(id).clone();
let rect = ctx.entity_component::<Rect>(id).clone();
for other_id in query!(ctx, RigidBody, Rect, Collider) {
if id == other_id {
continue;
}
let other_rect = ctx.entity_component::<Rect>(id).clone();
let other_body = ctx.entity_component::<RigidBody>(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::<RigidBody>(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::<Velocity>(id);
*y = if *y < 800.0 { *y + 400.0 * delta } else { *y };
for id in query!(ctx, RigidBody) {
let body = ctx.entity_component::<RigidBody>(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::<Cloud>().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::<Velocity>(id);
*x = if *x < 200.0 { *x + 200.0 * delta } else { *x };
for id in query!(ctx, Cloud, RigidBody) {
let body = ctx.entity_component::<RigidBody>(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::<Position>(id);
if *x > 1400.0 {
for id in query!(ctx, Cloud, RigidBody) {
let body = ctx.entity_component::<RigidBody>(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::<Position>(id);
for id in query!(ctx, Sprite, RigidBody) {
let body = ctx.entity_component::<RigidBody>(id).clone();
let sprite = ctx.entity_component::<Sprite>(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::<Velocity>(id);
*x = if d_down && !a_down {
let body = ctx.entity_component::<RigidBody>(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();
}

BIN
textures/literally_dprk.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 21 KiB