exercises

Author: mockersf

src/game.rs

@@ -1,4 +1,4 @@
-use std::f32::consts::TAU;
+use std::{f32::consts::TAU, time::Duration};
 
 use avian2d::prelude::*;
 use bevy::prelude::*;
@@ -12,7 +12,7 @@ pub fn game_plugin(app: &mut App) {
         .add_systems(OnEnter(GameState::Game), display_level)
         .add_systems(
             Update,
-            (collision, tick_explosion).run_if(in_state(GameState::Game)),
+            (tick_explosion, laser_range, has_won).run_if(in_state(GameState::Game)),
         );
 }
 
@@ -69,29 +69,6 @@ fn display_level(
     }
 }
 
-fn collision(
-    collisions: Collisions,
-    player: Query<(&Transform, Entity), With<Player>>,
-    mut commands: Commands,
-    game_assets: Res<GameAssets>,
-) -> Result {
-    let Ok((transform, entity)) = player.single() else {
-        return Ok(());
-    };
-
-    if collisions.collisions_with(entity).next().is_some() {
-        commands.spawn((
-            Sprite::from_image(game_assets.explosion.clone()),
-            (*transform).with_scale(Vec3::splat(0.2)),
-            Explosion(Timer::from_seconds(1.0, TimerMode::Once)),
-            StateScoped(GameState::Game),
-        ));
-        commands.entity(entity).despawn();
-    }
-
-    Ok(())
-}
-
 fn tick_explosion(
     mut commands: Commands,
     mut explosions: Query<(Entity, &mut Explosion, &Transform)>,
@@ -125,6 +102,7 @@ fn spawn_player(commands: &mut Commands, game_assets: &GameAssets, position: Vec
         negative: KeyCode::KeyD,
     });
     actions.bind::<Thrust>().to(KeyCode::KeyW);
+    actions.bind::<FireLaser>().to(KeyCode::Space);
 
     commands
         .spawn((
@@ -145,7 +123,9 @@ fn spawn_player(commands: &mut Commands, game_assets: &GameAssets, position: Vec
         ))
         .observe(rotate)
         .observe(thrust)
-        .observe(thrust_stop);
+        .observe(thrust_stop)
+        .observe(fire_laser)
+        .observe(asteroid_collision);
 }
 
 #[derive(InputContext)]
@@ -159,6 +139,10 @@ struct Rotate;
 #[input_action(output = bool)]
 struct Thrust;
 
+#[derive(Debug, InputAction)]
+#[input_action(output = bool)]
+struct FireLaser;
+
 fn rotate(
     trigger: Trigger<Fired<Rotate>>,
     mut player: Query<&mut AngularVelocity>,
@@ -192,11 +176,97 @@ fn thrust_stop(
     player: Query<&Children>,
     mut visibility: Query<&mut Visibility>,
 ) -> Result {
-    let children = player.get(trigger.target())?;
+    let Ok(children) = player.get(trigger.target()) else {
+        return Ok(());
+    };
 
     visibility
         .get_mut(children[0])?
         .set_if_neq(Visibility::Hidden);
 
     Ok(())
 }
+
+fn asteroid_collision(
+    collision: Trigger<OnCollisionStart>,
+    is_asteroid: Query<(), With<Asteroid>>,
+    player: Query<&Transform>,
+    mut commands: Commands,
+    game_assets: Res<GameAssets>,
+) -> Result {
+    if is_asteroid.get(collision.collider).is_ok() {
+        let transform = player.get(collision.target())?;
+        commands.spawn((
+            Sprite::from_image(game_assets.explosion.clone()),
+            (*transform).with_scale(Vec3::splat(0.2)),
+            Explosion(Timer::from_seconds(1.0, TimerMode::Once)),
+            StateScoped(GameState::Game),
+        ));
+        commands.entity(collision.target()).despawn();
+        commands.entity(collision.collider).despawn();
+    }
+    Ok(())
+}
+
+#[derive(Component)]
+struct Laser(Timer);
+
+fn fire_laser(
+    trigger: Trigger<Fired<FireLaser>>,
+    player: Query<&Transform>,
+    mut commands: Commands,
+    time: Res<Time>,
+    mut last_fired: Local<Duration>,
+    game_assets: Res<GameAssets>,
+) -> Result {
+    let mut transform = *player.get(trigger.target())?;
+    transform.translation += transform.local_y() * 40.0;
+    transform.scale = Vec3::ONE / 2.0;
+
+    if time.elapsed() > *last_fired + Duration::from_secs_f32(0.5) {
+        commands
+            .spawn((
+                // Sprite::from_image(game_assets.laser.clone()),
+                Sprite {
+                    image: game_assets.laser.clone(),
+                    color: Color::srgb(5.0, 1.0, 1.0),
+                    ..default()
+                },
+                transform,
+                RigidBody::Dynamic,
+                Collider::rectangle(4.0, 15.0),
+                LinearVelocity(transform.local_y().xy() * 1000.0),
+                Laser(Timer::from_seconds(1.0, TimerMode::Once)),
+                CollisionEventsEnabled,
+                StateScoped(GameState::Game),
+            ))
+            .observe(laser_attack);
+        *last_fired = time.elapsed();
+    }
+    Ok(())
+}
+
+fn laser_range(mut commands: Commands, mut lasers: Query<(Entity, &mut Laser)>, time: Res<Time>) {
+    for (entity, mut laser) in &mut lasers {
+        if laser.0.tick(time.delta()).just_finished() {
+            commands.entity(entity).despawn();
+        }
+    }
+}
+
+fn laser_attack(
+    collision: Trigger<OnCollisionStart>,
+    is_asteroid: Query<(), With<Asteroid>>,
+    mut commands: Commands,
+) {
+    if is_asteroid.get(collision.collider).is_ok() {
+        commands.entity(collision.collider).despawn();
+        commands.entity(collision.target()).despawn();
+    }
+}
+
+fn has_won(asteroids: Query<(), With<Asteroid>>, mut next_state: ResMut<NextState<GameState>>) {
+    if asteroids.is_empty() {
+        next_state.set(GameState::Won);
+    }
+}

src/main.rs

@@ -8,6 +8,7 @@ mod hud;
 mod level;
 mod splash;
 mod start_menu;
+mod won;
 
 fn main() {
     App::new()
@@ -28,6 +29,7 @@ fn main() {
             game::game_plugin,
             level::level_loader_plugin,
             hud::hud_plugin,
+            won::won_plugin,
         ))
         .run();
 }
@@ -38,6 +40,7 @@ enum GameState {
     Splash,
     StartMenu,
     Game,
+    Won,
 }
 
 #[derive(Resource)]
@@ -46,6 +49,7 @@ struct GameAssets {
     asteroid: Handle<Image>,
     jets: Handle<Image>,
     explosion: Handle<Image>,
+    laser: Handle<Image>,
 }
 
 #[derive(Resource)]

src/splash.rs

@@ -60,6 +60,7 @@ fn load_assets(mut commands: Commands, asset_server: Res<AssetServer>) {
         asteroid: asset_server.load("meteorBrown_big1.png"),
         jets: asset_server.load("fire07.png"),
         explosion: asset_server.load("explosion00.png"),
+        laser: asset_server.load("laserRed07.png"),
     });
     commands.insert_resource(LoadedLevel {
         level: asset_server.load("level.bw"),

src/won.rs

@@ -0,0 +1,46 @@
+use bevy::{color::palettes, prelude::*};
+
+use crate::GameState;
+
+pub fn won_plugin(app: &mut App) {
+    app.add_systems(OnEnter(GameState::Won), display_text)
+        .add_systems(Update, back_to_menu.run_if(in_state(GameState::Won)));
+}
+
+fn display_text(mut commands: Commands) {
+    commands.spawn((
+        Node {
+            width: Val::Percent(100.0),
+            height: Val::Percent(100.0),
+            align_items: AlignItems::Center,
+            justify_content: JustifyContent::Center,
+            flex_direction: FlexDirection::Column,
+            ..default()
+        },
+        children![
+            (
+                Text::new("You Won!"),
+                TextFont {
+                    font_size: 200.0,
+                    ..default()
+                },
+                TextColor::from(palettes::tailwind::RED_600),
+            ),
+            (
+                Text::new("Press any key to go back to the menu"),
+                TextFont {
+                    font_size: 50.0,
+                    ..default()
+                },
+                TextColor::from(palettes::tailwind::RED_800),
+            )
+        ],
+        StateScoped(GameState::Won),
+    ));
+}
+
+fn back_to_menu(keyboard: Res<ButtonInput<KeyCode>>, mut next: ResMut<NextState<GameState>>) {
+    if keyboard.get_just_pressed().next().is_some() {
+        next.set(GameState::StartMenu);
+    }
+}