tinted sprites

1 files changed, 60 insertions, 21 deletions

diff --git a/light-client/src/game.rs b/light-client/src/game.rs
index 231f6bd1..1425a3f8 100644
--- a/light-client/src/game.rs
+++ b/light-client/src/game.rs
@@ -16,7 +16,7 @@
 
 */
 use crate::{
-    render::{sprite::Sprite, MiscTextures, SpriteRenderer},
+    render::{misc::MiscTextures, sprite::Sprite, AtlasLayout, SpriteRenderer},
     tilemap::Tilemap,
 };
 use hurrycurry_protocol::{
@@ -43,25 +43,37 @@ pub struct Game {
     item_sprites: Vec<Sprite>,
     movement_send_cooldown: f32,
     interacting: bool,
+    score: Score,
+}
+
+#[derive(Debug, Default)]
+pub struct Score {
+    points: i64,
+    demands_failed: usize,
+    demands_completed: usize,
+    time_remaining: f32,
 }
 
 pub struct Tile {
-    kind: TileIndex,
+    _kind: TileIndex,
     item: Option<Item>,
 }
+
 pub struct Player {
     movement: MovementBase,
     item: Option<Item>,
-    name: String,
-    character: i32,
+    _name: String,
+    _character: i32,
 }
+
 pub struct Item {
     position: Vec2,
     kind: ItemIndex,
+    progress: Option<(f32, bool)>,
 }
 
 impl Game {
-    pub fn new(renderer: &SpriteRenderer) -> Self {
+    pub fn new(layout: &AtlasLayout) -> Self {
         Self {
             tiles: HashMap::new(),
             players: HashMap::new(),
@@ -70,9 +82,10 @@ impl Game {
             data: ClientGamedata::default(),
             collision_map: HashSet::new(),
             movement_send_cooldown: 0.,
-            misc_textures: MiscTextures::init(renderer),
+            misc_textures: MiscTextures::init(layout),
             item_sprites: Vec::new(),
             interacting: false,
+            score: Score::default(),
         }
     }
 
@@ -80,14 +93,14 @@ impl Game {
         match packet {
             PacketC::Init { id } => self.my_id = id,
             PacketC::Data { data } => {
-                self.tilemap.init(&data.tile_names, renderer.metadata());
+                self.tilemap.init(&data.tile_names, renderer.atlas_layout());
                 self.item_sprites = data
                     .item_names
                     .iter()
                     .map(|name| {
                         Sprite::new(
                             renderer
-                                .metadata()
+                                .atlas_layout()
                                 .get(&format!("{name}+a"))
                                 .copied()
                                 .unwrap_or_else(|| {
@@ -107,7 +120,13 @@ impl Game {
                 neighbors,
             } => {
                 if let Some(kind) = kind {
-                    self.tiles.insert(tile, Tile { kind, item: None });
+                    self.tiles.insert(
+                        tile,
+                        Tile {
+                            _kind: kind,
+                            item: None,
+                        },
+                    );
                     if self.data.tile_collide[kind.0] {
                         self.collision_map.remove(&tile);
                     } else {
@@ -129,8 +148,8 @@ impl Game {
                 self.players.insert(
                     id,
                     Player {
-                        character,
-                        name,
+                        _character: character,
+                        _name: name,
                         item: None,
                         movement: MovementBase {
                             position,
@@ -166,27 +185,40 @@ impl Game {
                 *self.get_item(location) = item.map(|kind| Item {
                     kind,
                     position: Vec2::ZERO,
+                    progress: None,
                 })
             }
             PacketC::SetProgress {
                 item,
                 progress,
                 warn,
+            } => {
+                self.get_item(item).as_mut().unwrap().progress = progress.map(|s| (s, warn));
+            }
+            PacketC::Collide {
+                player: _,
+                force: _,
             } => (),
-            PacketC::Collide { player, force } => (),
-            PacketC::Communicate {
-                player,
-                message,
-                persist,
-            } => (),
-            PacketC::ServerMessage { text } => (),
+            PacketC::Communicate { .. } => {
+                // TODO
+            }
+            PacketC::ServerMessage { text: _ } => {
+                // TODO
+            }
             PacketC::Score {
                 points,
                 demands_failed,
                 demands_completed,
                 time_remaining,
-            } => (),
-            PacketC::SetIngame { state, lobby } => (),
+            } => {
+                self.score.points = points;
+                self.score.demands_completed = demands_completed;
+                self.score.demands_failed = demands_failed;
+                self.score.time_remaining = time_remaining.unwrap_or(-1.);
+            }
+            PacketC::SetIngame { state: _, lobby: _ } => {
+                // TODO
+            }
             PacketC::Error { message } => {
                 warn!("server error: {message:?}")
             }
@@ -202,7 +234,7 @@ impl Game {
     }
 
     pub fn tick(&mut self, dt: f32, keyboard: &KeyboardState, packet_out: &mut VecDeque<PacketS>) {
-        let direction = IVec2::new(
+        let mut direction = IVec2::new(
             keyboard.is_scancode_pressed(Scancode::D) as i32
                 - keyboard.is_scancode_pressed(Scancode::A) as i32,
             keyboard.is_scancode_pressed(Scancode::S) as i32
@@ -213,12 +245,19 @@ impl Game {
         let interact = keyboard.is_scancode_pressed(Scancode::Space)
             | keyboard.is_scancode_pressed(Scancode::J);
 
+        if interact {
+            direction *= 0.;
+        }
+
         self.movement_send_cooldown -= dt;
         let send_movement = self.movement_send_cooldown < 0.;
         if send_movement {
             self.movement_send_cooldown += 0.04
         }
 
+        self.score.time_remaining -= dt;
+        self.score.time_remaining -= self.score.time_remaining.max(0.);
+
         if interact != self.interacting {
             if interact {
                 packet_out.push_back(PacketS::Interact {