Add collisions (#20)

The game now ends when two airplanes collide. When the game ends, it
transitions back to the `ready` state so that a new game can be
started.

Collision detection is implemented using simple rectangular bounding
boxes. For this game, this method is reliable enough since airplanes
cannot move faster than their own size in a frame. Meaning airplanes
cannot glitch through other objects.

protobufs/atc/v1/event.proto

@@ -6,6 +6,11 @@ import "atc/v1/airplane.proto";
 import "atc/v1/location.proto";
 import "atc/v1/node.proto";
 
+message AirplaneCollided {
+  string id1 = 1;
+  string id2 = 2;
+}
+
 message AirplaneDetected {
   Airplane airplane = 1;
 }
@@ -32,12 +37,13 @@ message StreamRequest {}
 
 message StreamResponse {
   oneof event {
-    AirplaneDetected airplane_detected = 1;
-    AirplaneLanded airplane_landed = 2;
-    AirplaneMoved airplane_moved = 3;
-    FlightPlanUpdated flight_plan_updated = 4;
-    GameStarted game_started = 5;
-    GameStopped game_stopped = 6;
+    AirplaneCollided airplane_collided = 1;
+    AirplaneDetected airplane_detected = 2;
+    AirplaneLanded airplane_landed = 3;
+    AirplaneMoved airplane_moved = 4;
+    FlightPlanUpdated flight_plan_updated = 5;
+    GameStarted game_started = 6;
+    GameStopped game_stopped = 7;
   }
 }
 

src/atc-game/src/components/airplane.rs

@@ -1,5 +1,7 @@
 use bevy::prelude::*;
 
+pub const AIRPLANE_SIZE: f32 = 24.0;
+
 #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug, Default, Component)]
 pub struct Airplane;
 

src/atc-game/src/components/collider.rs

@@ -0,0 +1,21 @@
+use bevy::prelude::*;
+
+#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug, Default, Component)]
+pub struct Collider;
+
+#[cfg(test)]
+mod tests {
+    use super::Collider;
+
+    #[test]
+    fn trait_send() {
+        fn assert_send<T: Send>() {}
+        assert_send::<Collider>();
+    }
+
+    #[test]
+    fn trait_sync() {
+        fn assert_sync<T: Sync>() {}
+        assert_sync::<Collider>();
+    }
+}

src/atc-game/src/components/mod.rs

@@ -1,11 +1,13 @@
 pub use self::airplane::*;
 pub use self::airplane_id::*;
+pub use self::collider::*;
 pub use self::flight_plan::*;
 pub use self::location::*;
 pub use self::speed::*;
 
 mod airplane;
 mod airplane_id;
+mod collider;
 mod flight_plan;
 mod location;
 mod speed;

src/atc-game/src/event/mod.rs

@@ -1,7 +1,7 @@
 use atc::v1::stream_response::Event as ApiEvent;
 use atc::v1::{
-    Airplane, AirplaneDetected, AirplaneLanded, AirplaneMoved, FlightPlanUpdated, GameStarted,
-    GameStopped,
+    Airplane, AirplaneCollided, AirplaneDetected, AirplaneLanded, AirplaneMoved, FlightPlanUpdated,
+    GameStarted, GameStopped,
 };
 
 use crate::api::IntoApi;
@@ -13,6 +13,7 @@ mod bus;
 
 #[derive(Clone, Eq, PartialEq, Hash, Debug)]
 pub enum Event {
+    AirplaneCollided(AirplaneId, AirplaneId),
     AirplaneDetected(AirplaneId, Location, FlightPlan),
     AirplaneLanded(AirplaneId),
     AirplaneMoved(AirplaneId, Location),
@@ -26,6 +27,12 @@ impl IntoApi for Event {
 
     fn into_api(self) -> Self::ApiType {
         match self {
+            Event::AirplaneCollided(airplane_id1, airplane_id2) => {
+                ApiEvent::AirplaneCollided(AirplaneCollided {
+                    id1: airplane_id1.into_api(),
+                    id2: airplane_id2.into_api(),
+                })
+            }
             Event::AirplaneDetected(id, location, flight_plan) => {
                 ApiEvent::AirplaneDetected(AirplaneDetected {
                     airplane: Some(Airplane {

src/atc-game/src/state/running.rs

@@ -4,8 +4,8 @@ use atc::v1::get_game_state_response::GameState;
 
 use crate::event::{Event, EventBus};
 use crate::systems::{
-    despawn_airplane, follow_flight_plan, setup_airport, setup_grid, spawn_airplane,
-    update_flight_plan, SpawnTimer,
+    despawn_airplane, detect_collision, follow_flight_plan, setup_airport, setup_grid,
+    spawn_airplane, update_flight_plan, SpawnTimer,
 };
 
 pub struct GameStateRunningPlugin;
@@ -22,11 +22,12 @@ impl Plugin for GameStateRunningPlugin {
             .add_system_set(
                 SystemSet::on_update(GameState::Running)
                     .with_system(despawn_airplane)
-                    .with_system(follow_flight_plan)
+                    .with_system(follow_flight_plan.label("movement"))
                     .with_system(spawn_airplane)
-                    .with_system(update_flight_plan),
+                    .with_system(update_flight_plan)
+                    .with_system(detect_collision.after("movement")),
             )
-            .add_system_set(SystemSet::on_exit(GameState::Running));
+            .add_system_set(SystemSet::on_exit(GameState::Running).with_system(despawn_entities));
     }
 }
 
@@ -36,3 +37,9 @@ fn send_event(event_bus: Local<EventBus>) {
         .send(Event::GameStarted)
         .expect("failed to send event"); // TODO: Handle error
 }
+
+fn despawn_entities(mut commands: Commands, query: Query<Entity, Without<Camera>>) {
+    for entity in query.iter() {
+        commands.entity(entity).despawn_recursive();
+    }
+}

src/atc-game/src/store/watcher.rs

@@ -29,6 +29,7 @@ impl StoreWatcher {
                 Event::FlightPlanUpdated(id, flight_plan) => {
                     self.update_flight_plan(id, flight_plan);
                 }
+                Event::GameStopped => self.reset(),
                 _ => {}
             }
         }
@@ -60,4 +61,8 @@ impl StoreWatcher {
             airplane.flight_plan = flight_plan.into_api();
         }
     }
+
+    fn reset(&self) {
+        self.store.clear();
+    }
 }

src/atc-game/src/systems/detect_collisions.rs

@@ -0,0 +1,55 @@
+use bevy::prelude::*;
+use bevy::sprite::collide_aabb::collide;
+
+use atc::v1::get_game_state_response::GameState;
+
+use crate::components::{AirplaneId, Collider, AIRPLANE_SIZE};
+use crate::event::{Event, EventBus};
+
+pub struct Size {
+    airplane: Vec2,
+}
+
+impl Default for Size {
+    fn default() -> Self {
+        Self {
+            airplane: Vec2::new(AIRPLANE_SIZE, AIRPLANE_SIZE),
+        }
+    }
+}
+
+pub fn detect_collision(
+    mut app_state: ResMut<State<GameState>>,
+    query: Query<(Entity, &AirplaneId, &Collider, &Transform)>,
+    event_bus: Local<EventBus>,
+    size: Local<Size>,
+) {
+    'outer: for (entity1, airplane_id1, _, transform1) in query.iter() {
+        for (entity2, airplane_id2, _, transform2) in query.iter() {
+            if entity1 == entity2 {
+                continue;
+            }
+
+            if collide(
+                transform1.translation,
+                size.airplane,
+                transform2.translation,
+                size.airplane,
+            )
+            .is_some()
+            {
+                event_bus
+                    .sender()
+                    .send(Event::AirplaneCollided(
+                        airplane_id1.clone(),
+                        airplane_id2.clone(),
+                    ))
+                    .expect("failed to send event"); // TODO: Handle error
+
+                app_state.set(GameState::Ready).unwrap();
+
+                break 'outer;
+            }
+        }
+    }
+}

src/atc-game/src/systems/mod.rs

@@ -1,5 +1,6 @@
 pub use self::change_app_state::*;
 pub use self::despawn_airplane::*;
+pub use self::detect_collisions::*;
 pub use self::follow_flight_plan::*;
 pub use self::setup_airport::*;
 pub use self::setup_cameras::*;
@@ -9,6 +10,7 @@ pub use self::update_flight_plan::*;
 
 mod change_app_state;
 mod despawn_airplane;
+mod detect_collisions;
 mod follow_flight_plan;
 mod setup_airport;
 mod setup_cameras;

src/atc-game/src/systems/spawn_airplane.rs

@@ -1,7 +1,9 @@
 use bevy::prelude::*;
 use rand::Rng;
 
-use crate::components::{Airplane, AirplaneIdGenerator, FlightPlan, Location, Speed};
+use crate::components::{
+    Airplane, AirplaneIdGenerator, Collider, FlightPlan, Location, Speed, AIRPLANE_SIZE,
+};
 use crate::map::{route_between, Tile, MAP_HEIGHT_RANGE, MAP_WIDTH_RANGE};
 use crate::{Event, EventBus};
 
@@ -32,7 +34,7 @@ pub fn spawn_airplane(
             .spawn_bundle(SpriteBundle {
                 transform: Transform {
                     translation: Vec3::new(spawn_point.x(), spawn_point.y(), 2.0),
-                    scale: Vec3::new(8.0, 8.0, 0.0),
+                    scale: Vec3::new(AIRPLANE_SIZE, AIRPLANE_SIZE, 0.0),
                     ..Default::default()
                 },
                 sprite: Sprite {
@@ -43,6 +45,7 @@ pub fn spawn_airplane(
             })
             .insert(Airplane)
             .insert(airplane_id.clone())
+            .insert(Collider)
             .insert(flight_plan.clone())
             .insert(Speed::new(32.0));
 

src/print-client/src/main.rs

@@ -6,6 +6,7 @@ use atc::v1::StreamRequest;
 
 fn should_print(event: &Event) -> bool {
     match event {
+        Event::AirplaneCollided(_) => true,
         Event::AirplaneDetected(_) => true,
         Event::AirplaneLanded(_) => true,
         Event::AirplaneMoved(_) => false,
@@ -29,6 +30,12 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         }
 
         match event {
+            Event::AirplaneCollided(collision) => {
+                println!(
+                    "Airplane {} collided with airplane {}",
+                    collision.id1, collision.id2
+                );
+            }
             Event::AirplaneDetected(airplane_detected) => {
                 let airplane = airplane_detected.airplane.unwrap();
                 let location = airplane.location.unwrap();