more

Cargo.lock

 version = "0.1.0"
 dependencies = [
  "ggez",
+ "glam",
 ]
 
 [[package]]
 ]
 
 [[package]]
+name = "glam"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "333928d5eb103c5d4050533cec0384302db6be8ef7d3cebd30ec6a35350353da"
+
+[[package]]
 name = "gleam"
 version = "0.6.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"

Cargo.toml

 
 [dependencies]
 ggez = "0.5.1"
+glam = "0.14.0"

src/main.rs

 use ggez::nalgebra as na;
 use ggez::timer::check_update_time;
 use ggez::{Context, GameResult};
+use glam::Vec2;
 use std::env;
 use std::path;
 
-const TARGET_ANIMATION_FPS: u32 = 10;
+type Vector2 = Vec2;
+
+const TARGET_FPS: u32 = 60; // execute update code 60x per seconds
+const META_EACH: u32 = 20; // execute meta code each 20 frames
+const PHYSICS_EACH: u32 = 10; // execute physics code each 10 frames
+const ANIMATE_EACH: u32 = 60; // execute animate code each 30 frames
+const SPRITE_EACH: u32 = 10; // change sprite animation tile 30 frames
+const MAX_FRAME_I: u32 = 4294967295; // max of frame_i used to calculate ticks
+
+const SPRITE_SHEET_WIDTH: f32 = 168.0;
+const SPRITE_SHEET_HEIGHT: f32 = 72.0;
+
+fn vec_from_angle(angle: f32) -> Vector2 {
+    let vx = angle.sin();
+    let vy = angle.cos();
+    Vector2::new(vx, vy)
+}
 
 struct SpriteInfo {
     relative_start_y: f32,
     relative_tile_width: f32,
     relative_tile_height: f32,
     tile_count: u16,
-    current_frame: u16,
 }
 
 impl SpriteInfo {
             relative_tile_width,
             relative_tile_height,
             tile_count,
-            current_frame: 0,
         }
     }
 
-    pub fn from_type(
-        type_: &SpriteType,
-        sprite_sheet_width: f32,
-        sprite_sheet_height: f32,
-    ) -> Self {
+    // TODO: ask on rust community if this is performant, or how to make it static
+    pub fn from_type(type_: &SpriteType) -> Self {
         let (start_y, tile_width, tile_height, tile_count) = match type_ {
             SpriteType::WalkingSoldier => (0.0, 24.0, 24.0, 7),
             SpriteType::JumpingSoldier => (24.0, 24.0, 24.0, 2),
+            SpriteType::StandingSoldier => (48.0, 24.0, 24.0, 1),
         };
 
         Self {
-            relative_start_y: start_y / sprite_sheet_height,
-            relative_tile_width: tile_width / sprite_sheet_width,
-            relative_tile_height: tile_height / sprite_sheet_height,
+            relative_start_y: start_y / SPRITE_SHEET_HEIGHT,
+            relative_tile_width: tile_width / SPRITE_SHEET_WIDTH,
+            relative_tile_height: tile_height / SPRITE_SHEET_HEIGHT,
             tile_count,
-            current_frame: 0,
         }
     }
+
+    pub fn as_draw_param(&self, current_frame: f32) -> graphics::DrawParam {
+        graphics::DrawParam::new().src(graphics::Rect::new(
+            current_frame as f32 * self.relative_tile_width,
+            self.relative_start_y,
+            self.relative_tile_width,
+            self.relative_tile_height,
+        ))
+    }
 }
 
 enum SpriteType {
     WalkingSoldier,
     JumpingSoldier,
+    StandingSoldier,
+}
+
+enum ItemBehavior {
+    Standing(u32), // since
+    Jumping,
+    Running(Vector2),
 }
 
-fn sprite_batch_part_from_sprite_info(sprite_info: &SpriteInfo) -> graphics::DrawParam {
-    let src = graphics::Rect::new(
-        sprite_info.current_frame as f32 * sprite_info.relative_tile_width,
-        sprite_info.relative_start_y,
-        sprite_info.relative_tile_width,
-        sprite_info.relative_tile_height,
-    );
-    graphics::DrawParam::new().src(src)
+struct ItemState {
+    current_behavior: ItemBehavior,
+}
+
+impl ItemState {
+    pub fn new(current_behavior: ItemBehavior) -> Self {
+        Self { current_behavior }
+    }
+
+    pub fn sprite_type(&self) -> SpriteType {
+        // Here some logical about state and current behavior to determine sprite type
+        match self.current_behavior {
+            ItemBehavior::Jumping => SpriteType::JumpingSoldier,
+            ItemBehavior::Running(_) => SpriteType::WalkingSoldier,
+            ItemBehavior::Standing(_) => SpriteType::StandingSoldier,
+        }
+    }
 }
 
 struct SceneItem {
-    sprite_info: SpriteInfo,
     position: na::Point2<f32>,
+    state: ItemState,
+    meta_events: Vec<MetaEvent>,
+    current_frame: u16,
 }
 
 impl SceneItem {
-    pub fn new(
-        sprite_type: SpriteType,
-        position: na::Point2<f32>,
-        sprite_sheet_width: f32,
-        sprite_sheet_height: f32,
-    ) -> Self {
+    pub fn new(position: na::Point2<f32>, state: ItemState) -> Self {
+        let sprite_type = state.sprite_type();
         Self {
-            sprite_info: SpriteInfo::from_type(
-                &sprite_type,
-                sprite_sheet_width,
-                sprite_sheet_height,
-            ),
             position,
+            state,
+            meta_events: vec![],
+            current_frame: 0,
         }
     }
 
-    pub fn tick_frame(&mut self) {
-        self.sprite_info.current_frame += 1;
-        if self.sprite_info.current_frame >= self.sprite_info.tile_count {
-            self.sprite_info.current_frame = 0;
+    pub fn sprite_info(&self) -> SpriteInfo {
+        SpriteInfo::from_type(&self.state.sprite_type())
+    }
+
+    pub fn tick_sprite(&mut self) {
+        self.current_frame += 1;
+        // TODO: good way to have sprite info ? performant ?
+        if self.current_frame >= self.sprite_info().tile_count {
+            self.current_frame = 0;
         }
     }
 }
 
-enum Message {}
+enum PhysicEvent {
+    Explosion,
+}
+
+enum MetaEvent {
+    FearAboutExplosion,
+}
 
 struct MainState {
+    frame_i: u32,
     scene_items_sprite_batch: graphics::spritebatch::SpriteBatch,
     scene_items: Vec<SceneItem>,
+    physics_events: Vec<PhysicEvent>,
 }
 
 impl MainState {
         let mut scene_items = vec![];
         for x in 0..1 {
             for y in 0..4 {
-                let sprite_type = if y % 2 == 0 {
-                    SpriteType::WalkingSoldier
+                let current_behavior = if y % 2 == 0 {
+                    ItemBehavior::Running(vec_from_angle(90.0))
                 } else {
-                    SpriteType::JumpingSoldier
+                    ItemBehavior::Jumping
                 };
 
                 scene_items.push(SceneItem::new(
-                    sprite_type,
                     na::Point2::new(x as f32 * 24.0, y as f32 * 24.0),
-                    168.0,
-                    48.0,
+                    ItemState::new(current_behavior),
                 ));
             }
         }
 
         let s = MainState {
+            frame_i: 0,
             scene_items_sprite_batch: batch,
             scene_items,
+            physics_events: vec![],
         };
         Ok(s)
     }
+
+    // TODO: manage errors
+    fn physics(&mut self) {
+        // Scene items movements
+        for scene_item in self.scene_items.iter_mut() {
+            match scene_item.state.current_behavior {
+                ItemBehavior::Running(vector) => {
+                    // TODO ici il faut calculer le déplacement réél (en fonction des ticks, etc ...)
+                    scene_item.position.x += 1.0;
+                }
+                _ => {}
+            }
+        }
+
+        // (FAKE) Drop a bomb to motivate stop move
+        if self.frame_i % 300 == 0 && self.frame_i != 0 {
+            self.physics_events.push(PhysicEvent::Explosion);
+        }
+    }
+
+    fn metas(&mut self) {
+        for physic_event in &self.physics_events {
+            match physic_event {
+                PhysicEvent::Explosion => {
+                    for scene_item in self.scene_items.iter_mut() {
+                        scene_item.meta_events.push(MetaEvent::FearAboutExplosion);
+                    }
+                }
+            }
+        }
+    }
+
+    fn animate(&mut self) {
+        // TODO: ici il faut reflechir a comment organiser les comportements
+
+        for scene_item in self.scene_items.iter_mut() {
+            for meta_event in &scene_item.meta_events {
+                match meta_event {
+                    MetaEvent::FearAboutExplosion => {
+                        scene_item.state = ItemState::new(ItemBehavior::Standing(self.frame_i));
+                    }
+                }
+            }
+
+            match scene_item.state.current_behavior {
+                ItemBehavior::Jumping => {
+                    scene_item.state = ItemState::new(ItemBehavior::Running(vec_from_angle(90.0)));
+                }
+                ItemBehavior::Running(_) => {
+                    scene_item.state = ItemState::new(ItemBehavior::Jumping);
+                }
+                ItemBehavior::Standing(since) => {
+                    if self.frame_i - since >= 120 {
+                        scene_item.state =
+                            ItemState::new(ItemBehavior::Running(vec_from_angle(90.0)));
+                    }
+                }
+            }
+
+            scene_item.meta_events.drain(..);
+        }
+    }
+
+    fn tick_sprites(&mut self) {
+        for scene_item in self.scene_items.iter_mut() {
+            scene_item.tick_sprite();
+        }
+    }
 }
 
 impl event::EventHandler for MainState {
     fn update(&mut self, ctx: &mut Context) -> GameResult {
-        while check_update_time(ctx, TARGET_ANIMATION_FPS) {
-            for scene_item in self.scene_items.iter_mut() {
-                scene_item.tick_frame();
+        while check_update_time(ctx, TARGET_FPS) {
+            // FIXME: gérer ici la maj des physics, animate, meta etc
+            // meta: calculer par ex qui voit qui (soldat voit un ennemi: ajouter l'event a vu
+            // ennemi, dans animate il se mettra a tirer)
+            let tick_sprite = self.frame_i % SPRITE_EACH == 0;
+            let tick_animate = self.frame_i % ANIMATE_EACH == 0;
+            let tick_physics = self.frame_i % PHYSICS_EACH == 0;
+            let tick_meta = self.frame_i % META_EACH == 0;
+
+            // Apply moves, explosions, etc
+            if tick_physics {
+                self.physics();
+            }
+
+            // Generate meta events according to physics events and current physic state
+            if tick_meta {
+                self.metas();
             }
+
+            // Animate scene items according to meta events
+            if tick_animate {
+                self.animate();
+            };
+
+            // Change scene items tiles
+            if tick_sprite {
+                self.tick_sprites();
+            }
+
+            // Increment frame counter
+            self.frame_i += 1;
+            if self.frame_i >= MAX_FRAME_I {
+                self.frame_i = 0;
+            }
+
+            // Empty physics event
+            self.physics_events.drain(..);
         }
 
         Ok(())
         graphics::clear(ctx, graphics::BLACK);
 
         for scene_item in self.scene_items.iter() {
-            let sprite_batch_part = sprite_batch_part_from_sprite_info(&scene_item.sprite_info)
-                .dest(scene_item.position.clone());
-            self.scene_items_sprite_batch.add(sprite_batch_part);
+            self.scene_items_sprite_batch.add(
+                scene_item
+                    .sprite_info()
+                    .as_draw_param(scene_item.current_frame as f32)
+                    .dest(scene_item.position.clone()),
+            );
         }
         graphics::draw(
             ctx,
         Ok(())
     }
 }
-// TODO: spite i par objet, fabrication des sprite_info qu'une fois; channel pour modifs des objets ds update
+
 pub fn main() -> GameResult {
     let resource_dir = if let Ok(manifest_dir) = env::var("CARGO_MANIFEST_DIR") {
         let mut path = path::PathBuf::from(manifest_dir);