Skip to content

Stop using secs resources #5

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
wick3dr0se merged 1 commit into from
Apr 7, 2025
Merged

Stop using secs resources #5

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
235 changes: 125 additions & 110 deletions dyrah_client/src/game.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,4 +1,7 @@
use std::process::exit;
use std::{
process::exit,
sync::{Arc, RwLock},
};

use bincode::{deserialize, serialize};
use macroquad::{
Expand All @@ -21,153 +24,165 @@ use crate::{
map::TiledMap,
};

fn render_system(world: &World) {
let map = world.get_resource::<TiledMap>().unwrap();
let player_tex = world.get_resource::<PlayerTexture>().unwrap();
let crea_tex = world.get_resource::<CreatureTexture>().unwrap();

map.draw_tiles();
fn render_system(
map: TiledMap,
player_tex: PlayerTexture,
crea_tex: CreatureTexture,
damages: Arc<RwLock<Damages>>,
) -> impl Fn(&World) {
move |world| {
map.draw_tiles();

world.query::<(&Creature, &Sprite, &Position, &TargetPosition, &Health)>(
|_, (_, spr, pos, target_pos, health)| {
draw_rectangle_lines(
target_pos.vec.x,
target_pos.vec.y,
TILE_SIZE,
TILE_SIZE,
2.,
GRAY,
);
draw_texture_ex(
&crea_tex.0,
pos.vec.x,
pos.vec.y,
WHITE,
DrawTextureParams {
source: Some(Rect::new(spr.frame.0, spr.frame.1, TILE_SIZE, TILE_SIZE)),
..Default::default()
},
);

draw_rectangle(
pos.vec.x,
pos.vec.y,
health.points / 100. * TILE_SIZE,
4.,
RED,
);
},
);

world.query::<(&Creature, &Sprite, &Position, &TargetPosition, &Health)>(
|_, (_, spr, pos, target_pos, health)| {
world.query::<(
&mut Player,
&mut Sprite,
&Position,
&TargetPosition,
&Health,
)>(|_, (_, spr, pos, target_pos, health)| {
draw_rectangle_lines(
target_pos.vec.x,
target_pos.vec.y,
TILE_SIZE,
TILE_SIZE,
2.,
GRAY,
WHITE,
);

draw_texture_ex(
&crea_tex.0,
pos.vec.x,
pos.vec.y,
&player_tex.0,
pos.vec.x - spr.is_flipped.x as i8 as f32 * TILE_SIZE,
pos.vec.y - TILE_SIZE,
WHITE,
DrawTextureParams {
source: Some(Rect::new(spr.frame.0, spr.frame.1, TILE_SIZE, TILE_SIZE)),
source: Some(spr.animation.frame().source_rect),
dest_size: Some(spr.animation.frame().dest_size),
flip_x: spr.is_flipped.x,
flip_y: spr.is_flipped.y,
..Default::default()
},
);

draw_rectangle(
pos.vec.x,
pos.vec.y,
pos.vec.y - TILE_SIZE,
health.points / 100. * TILE_SIZE,
4.,
RED,
);
},
);

world.query::<(
&mut Player,
&mut Sprite,
&Position,
&TargetPosition,
&Health,
)>(|_, (_, spr, pos, target_pos, health)| {
draw_rectangle_lines(
target_pos.vec.x,
target_pos.vec.y,
TILE_SIZE,
TILE_SIZE,
2.,
WHITE,
);

draw_texture_ex(
&player_tex.0,
pos.vec.x - spr.is_flipped.x as i8 as f32 * TILE_SIZE,
pos.vec.y - TILE_SIZE,
WHITE,
DrawTextureParams {
source: Some(spr.animation.frame().source_rect),
dest_size: Some(spr.animation.frame().dest_size),
flip_x: spr.is_flipped.x,
flip_y: spr.is_flipped.y,
..Default::default()
},
);

draw_rectangle(
pos.vec.x,
pos.vec.y - TILE_SIZE,
health.points / 100. * TILE_SIZE,
4.,
GREEN,
);
});

let damages = world.get_resource::<Damages>().unwrap();
for num in &damages.numbers {
if let Some(pos) = world.get::<Position>(num.origin.into()) {
draw_rectangle_lines(pos.vec.x, pos.vec.y, TILE_SIZE, TILE_SIZE, 2., BLACK);

draw_text(
&num.value.to_string(),
num.position.x,
num.position.y,
16.,
RED,
GREEN,
);
});

for num in &damages.read().unwrap().numbers {
if let Some(pos) = world.get::<Position>(num.origin.into()) {
draw_rectangle_lines(pos.vec.x, pos.vec.y, TILE_SIZE, TILE_SIZE, 2., BLACK);

draw_text(
&num.value.to_string(),
num.position.x,
num.position.y,
16.,
RED,
);
}
}
}
}

fn movement_system(world: &World) {
let mut cam = world.get_resource_mut::<Camera>().unwrap();
let frame_time = get_frame_time();

world.query::<(&Player, &mut Sprite, &mut Position, &TargetPosition)>(
|_, (_, spr, pos, target_pos)| {
pos.vec = pos.vec.lerp(target_pos.vec, 5. * frame_time);
fn movement_system(cam: Arc<RwLock<Camera>>) -> impl Fn(&World) {
move |world| {
let frame_time = get_frame_time();

if target_pos.vec.x < pos.vec.x {
spr.is_flipped.x = true;
} else if target_pos.vec.x > pos.vec.x {
spr.is_flipped.x = false;
}
world.query::<(&Player, &mut Sprite, &mut Position, &TargetPosition)>(
|_, (_, spr, pos, target_pos)| {
pos.vec = pos.vec.lerp(target_pos.vec, 5. * frame_time);

spr.animation.update();
if target_pos.vec.x < pos.vec.x {
spr.is_flipped.x = true;
} else if target_pos.vec.x > pos.vec.x {
spr.is_flipped.x = false;
}

cam.attach_sized(pos.vec.x, pos.vec.y, screen_width(), screen_height());
cam.set();
},
);
spr.animation.update();
let mut cam = cam.write().unwrap();
cam.attach_sized(pos.vec.x, pos.vec.y, screen_width(), screen_height());
cam.set();
},
);

world.query::<(&Creature, &mut Position, &TargetPosition)>(|_, (_, pos, target_pos)| {
pos.vec = pos.vec.lerp(target_pos.vec, 3. * frame_time);
});
world.query::<(&Creature, &mut Position, &TargetPosition)>(|_, (_, pos, target_pos)| {
pos.vec = pos.vec.lerp(target_pos.vec, 3. * frame_time);
});
}
}

pub struct Game {
client: Client<Transport>,
world: World,
player: Option<Entity>,
last_input_time: f64,
damages: Arc<RwLock<Damages>>,
camera: Arc<RwLock<Camera>>,
}

impl Game {
pub async fn new() -> Self {
let transport = Transport::new("127.0.0.1:0");
let mut world = World::default();
let world = World::default();

set_default_filter_mode(FilterMode::Nearest);
let player_tex = load_texture("assets/wizard.png").await.unwrap();
let monsters_tex = load_texture("assets/32rogues/monsters.png").await.unwrap();

world.add_resource(TiledMap::new("assets/map.json").await);
world.add_resource(Camera::default());
world.add_resource(PlayerTexture(player_tex));
world.add_resource(CreatureTexture(monsters_tex));
world.add_resource(Damages::default());
let tilemap = TiledMap::new("assets/map.json").await;
let camera = Arc::new(RwLock::new(Camera::default()));
let player_texture = PlayerTexture(player_tex);
let creature_texture = CreatureTexture(monsters_tex);
let damages = Arc::new(RwLock::new(Damages::default()));

world.add_system(render_system);
world.add_system(movement_system);
world.add_system(render_system(
tilemap,
player_texture,
creature_texture,
damages.clone(),
));
world.add_system(movement_system(camera.clone()));

Self {
client: Client::new(transport, "127.0.0.1:8080"),
world,
damages,
camera,
player: None,
last_input_time: 0.,
}
Expand Down Expand Up @@ -253,7 +268,7 @@ impl Game {
});

if let Some(mut health) = self.world.get_mut::<Health>(defender.into()) {
let mut damages = self.world.get_resource_mut::<Damages>().unwrap();
let mut damages = self.damages.write().unwrap();
let pos = self.world.get::<Position>(defender.into()).unwrap();

damages.numbers.push(Damage {
Expand Down Expand Up @@ -290,8 +305,12 @@ impl Game {

root_ui().label(None, &format!("FPS: {}", get_fps()));

let cam = self.world.get_resource::<Camera>().unwrap();
let mouse_world_pos = cam.inner.screen_to_world(mouse_position().into());
let mouse_world_pos = self
.camera
.read()
.unwrap()
.inner
.screen_to_world(mouse_position().into());
let current_time = get_time();

let left = is_key_down(KeyCode::A) || is_key_down(KeyCode::Left);
Expand Down Expand Up @@ -339,15 +358,11 @@ impl Game {
}
}

self.world
.get_resource_mut::<Damages>()
.unwrap()
.numbers
.retain_mut(|num| {
num.position.y -= get_frame_time() * 20.;
num.lifetime -= get_frame_time();
num.lifetime > 0.
});
self.damages.write().unwrap().numbers.retain_mut(|num| {
num.position.y -= get_frame_time() * 20.;
num.lifetime -= get_frame_time();
num.lifetime > 0.
});
}

pub async fn run(&mut self) {
Expand Down
15 changes: 6 additions & 9 deletions dyrah_server/src/game.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -21,19 +21,18 @@ pub struct Game {
server: Server<Transport>,
lobby: HashMap<String, Entity>,
world: World,
player_view: PlayerView,
map: TiledMap,
dead_entities: Vec<(u64, u64)>,
}

impl Game {
pub fn new() -> Self {
let transport = Transport::new("127.0.0.1:8080");
let mut world = World::default();
let world = World::default();
let map = TiledMap::new("assets/map.json");
let mut rng = rng();

world.add_resource(PlayerView::default());

for _ in 0..300 {
let pos = Vec2::new(
rng.random_range(0..map.width) as f32 * TILE_SIZE,
Expand All @@ -60,6 +59,7 @@ impl Game {
server: Server::new(transport, ServerConfig::default()),
lobby: HashMap::new(),
world,
player_view: Default::default(),
map,
dead_entities: Vec::new(),
}
Expand Down Expand Up @@ -185,8 +185,6 @@ impl Game {
self.server.poll();
self.handle_events();

let mut player_view = self.world.get_resource_mut::<PlayerView>().unwrap();

self.world
.query::<(&mut Player, &mut Position, &TargetPosition)>(
|entity, (_, pos, target_pos)| {
Expand All @@ -196,7 +194,7 @@ impl Game {
return;
}

player_view.position = pos.vec;
self.player_view.position = pos.vec;

let msg = ServerMessage::PlayerMoved {
id: entity.id(),
Expand Down Expand Up @@ -232,7 +230,8 @@ impl Game {
dir * TILE_SIZE
};

if self.is_position_blocked(target_pos.vec) || !player_view.contains(target_pos.vec)
if self.is_position_blocked(target_pos.vec)
|| !self.player_view.contains(target_pos.vec)
{
return;
}
Expand All @@ -250,8 +249,6 @@ impl Game {
},
);

drop(player_view);

if !crea_moves.is_empty() {
let msg = ServerMessage::CreatureBatchMoved(crea_moves);
self.server.broadcast(&serialize(&msg).unwrap());
Expand Down