Small fixes

Author: tversteeg

src/enemy.rs

@@ -3,18 +3,19 @@ use crate::{
     particle::ParticleEmitter, phase::Phase, physics::*, player::Player, random, ship::Ships,
     sprite::Sprites,
 };
-use specs_blit::{specs::*, Sprite, SpriteRef};
+use derive_deref::{Deref, DerefMut};
+use specs_blit::{specs::*, Sprite};
 
 const ENEMY_VELOCITY_RESOURCES_MIN_FACTOR_X: f64 = 0.1;
 const ENEMY_VELOCITY_RESOURCES_MAX_FACTOR_X: f64 = 0.9;
 const ENEMY_VELOCITY_RESOURCES_MIN_FACTOR_Y: f64 = 0.02;
 const ENEMY_VELOCITY_RESOURCES_MAX_FACTOR_Y: f64 = 0.5;
-const ENEMY_VELOCITY_RESOURCES_SPEED_X: f64 = 0.1;
+const ENEMY_VELOCITY_RESOURCES_SPEED_X: f64 = 0.05;
 const ENEMY_VELOCITY_RESOURCES_SPEED_Y: f64 = 0.05;
-const ENEMY_VELOCITY_MIN_SPEED: f64 = 1.0;
+const ENEMY_VELOCITY_MIN_SPEED: f64 = 2.0;
 const ENEMY_ZIGZAG_RESOURCES_MIN_FACTOR: f64 = 0.1;
 const ENEMY_ZIGZAG_RESOURCES_MAX_FACTOR: f64 = 0.9;
-const ENEMY_ZIGZAG_RESOURCES_SPEED: f64 = 0.01;
+const ENEMY_ZIGZAG_RESOURCES_SPEED: f64 = 0.1;
 
 const ENEMY_ENGINE_PARTICLE_LIFETIME: f64 = 10.0;
 const ENEMY_DEAD_EMITTER_LIFETIME: f64 = 5.0;
@@ -32,19 +33,11 @@ pub enum EnemyType {
 }
 
 impl EnemyType {
-    pub fn sprite(self, ships: &Ships) -> SpriteRef {
-        match self {
-            EnemyType::Small => ships.enemy_small.clone(),
-            EnemyType::Medium => ships.enemy_medium.clone(),
-            EnemyType::Big => ships.enemy_big.clone(),
-        }
-    }
-
     pub fn bb(self) -> BoundingBox {
         match self {
             EnemyType::Small => BoundingBox::new(10.0, 16.0),
             EnemyType::Medium => BoundingBox::new(13.0, 20.0),
-            _ => unimplemented!(),
+            EnemyType::Big => BoundingBox::new(22.0, 24.0),
         }
     }
 }
@@ -86,7 +79,7 @@ impl EnemyEmitter {
             .collect::<Vec<_>>();
 
         // Always spawn the first one immediately
-        spawner[0].0 = 5.0;
+        spawner[0].0 = 30.0;
 
         Self {
             spawner,
@@ -105,18 +98,16 @@ impl EnemyEmitter {
         let enemy = entities.create();
         updater.insert(enemy, Enemy);
 
-        let type_ = if resources < 50.0 {
-            EnemyType::Small
-        } else if resources < 100.0 {
-            resources -= 50.0;
+        let type_ = if resources > 100.0 && random::bool() {
+            resources -= 40.0;
+            EnemyType::Big
+        } else if resources > 50.0 && random::bool() {
+            resources -= 20.0;
             EnemyType::Medium
         } else {
-            resources -= 100.0;
-            EnemyType::Big
+            EnemyType::Small
         };
 
-        updater.insert(enemy, Sprite::new(type_.sprite(ships)));
-
         updater.insert(
             enemy,
             Position::new(
@@ -129,9 +120,10 @@ impl EnemyEmitter {
         updater.insert(
             enemy,
             ParticleEmitter::new(
-                ENEMY_ENGINE_PARTICLE_LIFETIME,
+                ENEMY_ENGINE_PARTICLE_LIFETIME + resources / 100.0,
                 sprites.white_particle.clone(),
             )
+            .with_dispersion(1.0 - resources / 200.0)
             .with_offset(bb.to_aabr(&Position::new(0.0, 0.0)).center()),
         );
 
@@ -143,6 +135,8 @@ impl EnemyEmitter {
         ) * resources;
         resources -= x_velocity_resources;
 
+        updater.insert(enemy, Sprite::new(ships.enemy(type_)));
+
         if random::bool() {
             // Straight pattern
             let y_velocity_resources = random::range(
@@ -185,23 +179,31 @@ impl EnemyEmitter {
             );
         }
     }
+
+    pub fn enemies_left(&self) -> usize {
+        self.spawner.len()
+    }
 }
 
 #[derive(Component, Debug, Default)]
 #[storage(NullStorage)]
 pub struct Enemy;
 
+#[derive(Debug, Default, Deref, DerefMut)]
+pub struct EnemiesLeft(pub usize);
+
 pub struct EnemySystem;
 impl<'a> System<'a> for EnemySystem {
     type SystemData = (
         Entities<'a>,
+        Write<'a, Phase>,
         Option<Write<'a, Lives>>,
         ReadStorage<'a, Enemy>,
         ReadStorage<'a, Position>,
         Read<'a, LazyUpdate>,
     );
 
-    fn run(&mut self, (entities, lives, enemy, pos, updater): Self::SystemData) {
+    fn run(&mut self, (entities, mut phase, lives, enemy, pos, updater): Self::SystemData) {
         if let Some(mut lives) = lives {
             for (entity, pos, _) in (&*entities, &pos, &enemy).join() {
                 if pos.0.x <= 0.0 {
@@ -215,6 +217,10 @@ impl<'a> System<'a> for EnemySystem {
                 }
             }
         }
+
+        if *phase == Phase::WaitingForLastEnemy && enemy.is_empty() {
+            *phase = Phase::SwitchTo(Box::new(Phase::Setup));
+        }
     }
 }
 
@@ -265,19 +271,22 @@ impl<'a> System<'a> for EnemyEmitterSystem {
         ReadExpect<'a, Sprites>,
         Option<Read<'a, Ships>>,
         Write<'a, Phase>,
+        Write<'a, EnemiesLeft>,
         WriteStorage<'a, EnemyEmitter>,
         Read<'a, LazyUpdate>,
     );
 
     fn run(
         &mut self,
-        (entities, sprites, ships, mut phase, mut emitter, updater): Self::SystemData,
+        (entities, sprites, ships, mut phase, mut enemies_left, mut emitter, updater): Self::SystemData,
     ) {
         if let Some(ships) = ships {
-            for emitter in (&mut emitter).join() {
+            for (entity, emitter) in (&*entities, &mut emitter).join() {
+                enemies_left.0 = emitter.enemies_left();
                 if emitter.current_time >= emitter.total_time {
                     // Time ran out, change to another phase
-                    *phase = Phase::SwitchTo(Box::new(Phase::Setup));
+                    *phase = Phase::WaitingForLastEnemy;
+                    let _ = entities.delete(entity);
                     break;
                 }
                 emitter.current_time += 1.0;

src/lives.rs

@@ -45,7 +45,9 @@ impl Lives {
     }
 
     pub fn reduce(&mut self) {
-        self.amount -= 1;
+        if self.amount > 0 {
+            self.amount -= 1;
+        }
     }
 
     pub fn is_dead(&self) -> bool {

src/main.rs

@@ -15,7 +15,9 @@ mod render;
 mod ship;
 mod sprite;
 
-use crate::{gui::Gui, input::Input, lives::Lives, phase::Phase, render::Render};
+use crate::{
+    enemy::EnemiesLeft, gui::Gui, input::Input, lives::Lives, phase::Phase, render::Render,
+};
 use anyhow::Result;
 use miniquad::{
     conf::{Conf, Loading},
@@ -26,6 +28,9 @@ use specs_blit::{specs::prelude::*, PixelBuffer};
 pub const WIDTH: usize = 400;
 pub const HEIGHT: usize = 300;
 
+const LEVEL_TIME_SCALE: f64 = 120.0;
+const LEVEL_RESOURCES_SCALE: f64 = 100.0;
+
 /// Our game state.
 struct Game<'a, 'b> {
     /// The specs world.
@@ -35,7 +40,7 @@ struct Game<'a, 'b> {
     /// Our wrapper around the OpenGL calls.
     render: Render,
 
-    level: u8,
+    level: f64,
 }
 
 impl<'a, 'b> Game<'a, 'b> {
@@ -81,6 +86,9 @@ impl<'a, 'b> Game<'a, 'b> {
         // The current phase
         world.insert(Phase::default());
 
+        // Enemies left
+        world.insert(EnemiesLeft::default());
+
         // Setup the dispatcher with the blit system
         let dispatcher = DispatcherBuilder::new()
             .with(particle::ParticleEmitterSystem, "particle_emitter", &[])
@@ -108,9 +116,9 @@ impl<'a, 'b> Game<'a, 'b> {
             world,
             dispatcher,
             render,
-            level: 1,
+            level: 1.0,
         };
-        game.switch_phase(Phase::Menu);
+        game.switch_phase(Phase::default());
 
         Ok(game)
     }
@@ -125,27 +133,31 @@ impl<'a, 'b> Game<'a, 'b> {
         self.world.delete_all();
 
         match phase {
-            Phase::Menu => {
-                // Flash the screen for a bit
-                self.world
-                    .create_entity()
-                    .with(effect::ScreenFlash::new(color::FOREGROUND))
-                    .with(entity::Lifetime::new(5.0))
-                    .build();
-            }
+            Phase::Menu => {}
             Phase::Initialize => {
                 // Generate the ships
                 self.world.insert(ship::Ships::generate());
 
                 self.switch_phase(Phase::Play);
             }
-            Phase::Setup => {}
+            Phase::Setup => {
+                self.level += 1.0;
+            }
             Phase::Play => {
+                self.world
+                    .create_entity()
+                    .with(effect::ScreenFlash::new(color::FOREGROUND))
+                    .with(entity::Lifetime::new(5.0))
+                    .build();
+
                 self.world.insert(Lives::new(3));
 
                 self.world
                     .create_entity()
-                    .with(enemy::EnemyEmitter::new(200.0, 30.0 * 60.0))
+                    .with(enemy::EnemyEmitter::new(
+                        200.0 + self.level * LEVEL_RESOURCES_SCALE,
+                        20.0 * 60.0 + self.level * LEVEL_TIME_SCALE,
+                    ))
                     .build();
 
                 // Spawn the paddle
@@ -158,25 +170,33 @@ impl<'a, 'b> Game<'a, 'b> {
     pub fn render_phase(&mut self) {
         let phase = self.world.read_resource::<Phase>();
 
+        let mut buffer = self.world.write_resource::<PixelBuffer>();
+        let mut gui = self.world.write_resource::<Gui>();
         match *phase {
             Phase::Menu => {
-                let mut buffer = self.world.write_resource::<PixelBuffer>();
-
                 // Render the GUI
-                let mut gui = self.world.write_resource::<Gui>();
-                gui.draw_label(&mut buffer, "Press SPACE to play!", 20, 20);
+                gui.draw_label(&mut buffer, "Press SPACE to play!", 110, 200);
             }
-            Phase::Play => {
-                let mut buffer = self.world.write_resource::<PixelBuffer>();
+            Phase::Setup => {
+                gui.draw_label(&mut buffer, format!("Level: {}", self.level), 160, 20);
+                gui.draw_label(&mut buffer, "Press SPACE to start!", 105, 200);
+            }
+            Phase::Play | Phase::WaitingForLastEnemy => {
                 let lives = self.world.read_resource::<Lives>();
                 lives.render(&mut buffer, 100, 5);
 
-                let mut gui = self.world.write_resource::<Gui>();
-                gui.draw_label(&mut buffer, format!("Level {}", self.level), 20, 5);
+                gui.draw_label(&mut buffer, format!("Level: {}", self.level), 20, 5);
+
+                if *phase == Phase::Play {
+                    gui.draw_label(
+                        &mut buffer,
+                        format!("Enemies: {}", self.world.read_resource::<EnemiesLeft>().0),
+                        200,
+                        5,
+                    );
+                }
             }
             Phase::GameOver => {
-                let mut buffer = self.world.write_resource::<PixelBuffer>();
-                let mut gui = self.world.write_resource::<Gui>();
                 gui.draw_label(&mut buffer, "GAME OVER!", 20, 20);
             }
             _ => (),
@@ -193,7 +213,9 @@ impl<'a, 'b> EventHandler for Game<'a, 'b> {
         self.world.maintain();
 
         let mut phase = (*self.world.read_resource::<Phase>()).clone();
-        if phase == Phase::Play && self.world.read_resource::<Lives>().is_dead() {
+        if (phase == Phase::Play || phase == Phase::WaitingForLastEnemy)
+            && self.world.read_resource::<Lives>().is_dead()
+        {
             phase = Phase::SwitchTo(Box::new(Phase::GameOver));
         }
 
@@ -231,6 +253,8 @@ impl<'a, 'b> EventHandler for Game<'a, 'b> {
         let phase = (*self.world.read_resource::<Phase>()).clone();
         if phase == Phase::Menu && keycode == KeyCode::Space {
             self.switch_phase(Phase::Initialize);
+        } else if phase == Phase::Setup && keycode == KeyCode::Space {
+            self.switch_phase(Phase::Play);
         }
 
         // Pass the input to the resource

src/movement.rs

@@ -1,4 +1,4 @@
-use crate::physics::*;
+use crate::{physics::*, random};
 use specs_blit::specs::*;
 
 #[derive(Component, Debug)]
@@ -11,7 +11,7 @@ pub struct Zigzag {
 impl Zigzag {
     pub fn new(amount: f64, time_div: f64) -> Self {
         Self {
-            time: 0.0,
+            time: random::range(0.0, 100.0),
             amount,
             time_div,
         }

src/particle.rs

@@ -48,6 +48,12 @@ impl ParticleEmitter {
 
         self
     }
+
+    pub fn with_dispersion(mut self, dispersion: f64) -> Self {
+        self.dispersion = dispersion;
+
+        self
+    }
 }
 
 /// System that will spawn particles.

src/phase.rs

@@ -4,6 +4,7 @@ pub enum Phase {
     Initialize,
     Setup,
     Play,
+    WaitingForLastEnemy,
     GameOver,
     SwitchTo(Box<Phase>),
 }

src/random.rs

@@ -9,3 +9,9 @@ pub fn bool() -> bool {
 
     r > miniquad::RAND_MAX as i32 / 2
 }
+
+pub fn index<T>(v: &Vec<T>) -> &T {
+    let r = unsafe { miniquad::rand() } as usize / (miniquad::RAND_MAX as usize / v.len());
+
+    &v[r]
+}