feat(perfs): Pre compute collision to improve performance, fixed wrong sound effect for the air

Author: jerthz

.github/workflows/on_release.yml

@@ -10,7 +10,7 @@ jobs:
     strategy:
       matrix:
         config:
-        - { os: ubuntu-18.04, name: starlight-1961-linux, archive: starlight-1961_linux.zip, bin: starlight-1961, ui: vulkan }
+        - { os: ubuntu-18.04, name: starlight-1961-linux, archive: starlight-1961_linux.tar.gz, bin: starlight-1961, ui: vulkan }
         - { os: macos-latest, name: starlight-1961-macos, archive: starlight-1961_macOs.zip,bin: starlight-1961, ui: metal }
         - { os: windows-latest, name: starlight-1961-windows, archive: starlight-1961_windows.zip,bin: starlight-1961.exe, ui: vulkan }
     steps:
@@ -33,9 +33,12 @@ jobs:
         run: |
           move target/release/${{matrix.config.bin}} ${{matrix.config.name}}/${{matrix.config.bin}}
           move assets ${{matrix.config.name}}/assets
-      - name: Zip files (Linux & Mac)
-        if: matrix.config.os != 'windows-latest'
+      - name: Zip files Mac
+        if: matrix.config.os == 'macos-latest'
         run: 7z a -t7z ${{matrix.config.archive}} ${{matrix.config.name}}
+      - name: Zip files Linux
+        if: matrix.config.os == 'ubuntu-18.04'
+        run: tar -zcvf ${{matrix.config.archive}} ${{matrix.config.name}}
       - name: Zip files (Windows)
         if: matrix.config.os == 'windows-latest'
         run: 7z a -t7z ${{matrix.config.archive}} ${{matrix.config.name}}

assets/sprites/main.png

@@ -1,7 +1,8 @@
-use crate::utils::Point2D;
+use crate::utils::{Point2D, min_of_f32_vec, max_of_f32_vec};
 use amethyst::core::ecs::{Component, DenseVecStorage};
 use geo::{Polygon, LineString};
 use geo::intersects::Intersects;
+use std::cmp::Ordering;
 
 pub struct ButtonPlatform;
 
@@ -29,23 +30,42 @@ impl Component for Transparent {
 
 #[derive(Debug)]
 pub struct Colliders {
+    pub min_x: f32,
+    pub min_y: f32,
+    pub max_x: f32,
+    pub max_y: f32,
     colliders: Vec<Collider>,
-    polygons: Vec<Polygon<f32>>
+    polygons: Vec<Polygon<f32>>,
 }
 
 impl Colliders {
     pub fn from_vec(colliders: Vec<Collider>) -> Colliders {
-        Colliders { polygons: colliders.iter().map(|collider| collider.to_polygon()).collect(), colliders }
-    }
-    pub fn from_points(a: Point2D, b: Point2D, c: Point2D ,d: Point2D ) -> Colliders {
-        Colliders { polygons: vec![
-            Polygon::new(
-                LineString::from(
-                    vec![(a.x, a.y), (b.x, b.y), (c.x, c.y), (d.x, d.y), (a.x, a.y)]
-                ),
-                vec![],
+        let (min_x, min_y, max_x, max_y) = {
+            (
+                colliders.iter().map(|col| min_of_f32_vec([col.a.x, col.b.x, col.c.x, col.d.x])).min_by(|a, b| a.partial_cmp(b).unwrap_or(Ordering::Equal)).unwrap(),
+                colliders.iter().map(|col| min_of_f32_vec([col.a.y, col.b.y, col.c.y, col.d.y])).min_by(|a, b| a.partial_cmp(b).unwrap_or(Ordering::Equal)).unwrap(),
+                colliders.iter().map(|col| max_of_f32_vec([col.a.x, col.b.x, col.c.x, col.d.x])).max_by(|a, b| a.partial_cmp(b).unwrap_or(Ordering::Equal)).unwrap(),
+                colliders.iter().map(|col| max_of_f32_vec([col.a.y, col.b.y, col.c.y, col.d.y])).max_by(|a, b| a.partial_cmp(b).unwrap_or(Ordering::Equal)).unwrap()
             )
-        ], colliders: Vec::new() }
+        };
+        Colliders { polygons: colliders.iter().map(|collider| collider.to_polygon()).collect(), colliders, min_x, min_y, max_x, max_y }
+    }
+    pub fn from_points(a: Point2D, b: Point2D, c: Point2D, d: Point2D) -> Colliders {
+        Colliders {
+            polygons: vec![
+                Polygon::new(
+                    LineString::from(
+                        vec![(a.x, a.y), (b.x, b.y), (c.x, c.y), (d.x, d.y), (a.x, a.y)]
+                    ),
+                    vec![],
+                )
+            ],
+            colliders: Vec::new(),
+            min_x: min_of_f32_vec([a.x, b.x, c.x, d.x]),
+            min_y: min_of_f32_vec([a.y, b.y, c.y, d.y]),
+            max_x: max_of_f32_vec([a.x, b.x, c.x, d.x]),
+            max_y: max_of_f32_vec([a.y, b.y, c.y, d.y]),
+        }
     }
 
     pub fn polygons(&self) -> &Vec<Polygon<f32>> {
@@ -63,10 +83,10 @@ impl Component for Colliders {
 
 #[derive(Debug)]
 pub struct Collider {
-    a: Point2D,
-    b: Point2D,
-    c: Point2D,
-    d: Point2D,
+    pub a: Point2D,
+    pub b: Point2D,
+    pub c: Point2D,
+    pub d: Point2D,
 }
 
 impl Collider {
@@ -97,7 +117,6 @@ impl Collider {
 }
 
 pub fn are_colliding(ship_polygon: &Vec<Polygon<f32>>, struct_polygons: &Vec<Polygon<f32>>) -> bool {
-
     for polygon in ship_polygon.iter() {
         for struct_polygon in struct_polygons.iter() {
             if polygon.intersects(struct_polygon) {
@@ -106,4 +125,11 @@ pub fn are_colliding(ship_polygon: &Vec<Polygon<f32>>, struct_polygons: &Vec<Pol
         }
     }
     false
+}
+
+pub fn compute_is_eligible_for_collision(col1: &Colliders, col2: &Colliders) -> bool {
+    !(col1.min_x < col2.min_x && col1.max_x < col2.min_x && col1.min_x < col2.max_x && col1.max_x < col2.max_x)
+        && !(col1.min_x > col2.min_x && col1.max_x > col2.min_x && col1.min_x > col2.max_x && col1.max_x > col2.max_x)
+        && !(col1.min_y < col2.min_y && col1.max_y < col2.min_y && col1.min_y < col2.max_y && col1.max_y < col2.max_y)
+        && !(col1.min_y > col2.min_y && col1.max_y > col2.min_y && col1.min_y > col2.max_y && col1.max_y > col2.max_y)
 }

src/entities/collision.rs

@@ -127,9 +127,13 @@ impl MainResource {
     }
 
     pub fn get_colliders_polygons_for_collision(&self, x: f32, y:f32) -> Vec<Polygon<f32>> {
+        self.get_colliders_for_collision(x, y).to_owned_polygons()
+    }
+
+    pub fn get_colliders_for_collision(&self, x: f32, y:f32) -> Colliders {
         let main_collider = Collider::new(Point2D{x: x+2., y: y-2.}, 28., -28.);
         let colliders = Colliders::from_vec(vec![main_collider]);
-        colliders.to_owned_polygons()
+        colliders
     }
 
     pub fn get_colliders_polygons_for_landing(&self, x: f32, y:f32) -> Vec<Polygon<f32>> {

src/resources/main_resource.rs

@@ -2,7 +2,7 @@ use amethyst::core::ecs::{System, ReadStorage, WriteStorage, Join, Read, Entitie
 use crate::entities::canons::{Bullet, Canon, CanonKind, canon_kind_to_bullet_speed, canon_kind_to_bullet_life_duration};
 use amethyst::core::{Transform, Time};
 use crate::utils::Direction;
-use crate::entities::collision::{Colliders, are_colliding};
+use crate::entities::collision::{Colliders, are_colliding, compute_is_eligible_for_collision};
 use geo::Polygon;
 use crate::utils::sprites::sprite_to_entities::init_bullet_collider;
 use crate::resources::main_resource::MainResource;
@@ -48,7 +48,7 @@ impl<'s> System<'s> for BulletSystem {
         for (_ship, transform) in (&ships, &transforms).join() {
             ship_polygon = main_resource.get_colliders_polygons_for_collision(transform.translation().x, transform.translation().y);
         }
-        let mut bullet_vec: Vec<(u32, Vec<Polygon<f32>>)> = Vec::new();
+        let mut bullet_vec: Vec<(u32, Colliders)> = Vec::new();
         for (bullet, transform, entity) in (&mut bullets, &mut transforms, &entities).join() {
             let colliders = init_bullet_collider(&bullet.kind, transform.translation().x, transform.translation().y);
             match bullet.kind {
@@ -77,7 +77,7 @@ impl<'s> System<'s> for BulletSystem {
                     }
                 }
             }else{
-                bullet_vec.push((entity.id(), colliders.polygons().clone()));
+                bullet_vec.push((entity.id(), colliders));
             }
             let bullet_speed = canon_kind_to_bullet_speed(&bullet.kind);
             match bullet.direction {
@@ -91,9 +91,13 @@ impl<'s> System<'s> for BulletSystem {
             if bullet.life_duration <= 0. { let _res = entities.delete(entity); }
         }
 
-        let joined: Vec<_> = (&colliders, !&bullets, !&canons).join().flat_map(|(a,b,c)| a.to_owned_polygons()).collect();
-        for (id, polygons) in bullet_vec.iter(){
-            if are_colliding(&polygons, &joined) {
+        let joined: Vec<_> = (&colliders, !&bullets, !&canons)
+            .join()
+            .filter(|(a, b, c)| {
+                return bullet_vec.iter().any(|(id, collider)| compute_is_eligible_for_collision(*a, &collider));
+            }).flat_map(|(a,b,c)| a.to_owned_polygons()).collect();
+        for (id, col) in bullet_vec.iter(){
+            if  are_colliding(&col.to_owned_polygons(), &joined) {
                 let e = entities.entity(*id);
                 let _res = entities.delete(e);
             }

src/systems/bullet_system.rs

@@ -1,5 +1,5 @@
 use amethyst::core::ecs::{System, ReadStorage, Write, Join};
-use crate::entities::collision::{Colliders, LandingPlatform, are_colliding};
+use crate::entities::collision::{Colliders, LandingPlatform, are_colliding, compute_is_eligible_for_collision};
 use crate::entities::ship::ShipParent;
 use amethyst::core::Transform;
 use crate::resources::main_resource::MainResource;
@@ -23,10 +23,11 @@ impl<'s> System<'s> for CollisionSystem {
 
     fn run(&mut self, (colliders, landing_plateforms,plasma_doors, bonus,  ships, transforms, mut ship_resource, bullets): Self::SystemData) {
         for (_ship, transform) in (&ships, &transforms).join() {
-            let ship_polygon = ship_resource.get_colliders_polygons_for_collision(transform.translation().x, transform.translation().y);
+            let ship_collider = ship_resource.get_colliders_for_collision(transform.translation().x, transform.translation().y);
+            let ship_polygon = ship_collider.to_owned_polygons();
             for (collider, _, _, _, _) in (&colliders, !&landing_plateforms, !&bullets, !&plasma_doors, !&bonus).join() {
                 let struct_polygons = collider.polygons();
-                if !ship_resource.is_exploding && are_colliding(&ship_polygon, struct_polygons) {
+                if !ship_resource.is_exploding && compute_is_eligible_for_collision(&collider, &ship_collider) && are_colliding(&ship_polygon, struct_polygons) {
                     ship_resource.ship_life  -= ship_resource.ship_life;
                 }
             }

src/systems/collision_system.rs

@@ -15,4 +15,14 @@ pub enum Direction {
 
 pub fn distance_between_two_points(xa: f32, ya:f32, xb:f32, yb:f32) -> f32 {
     ((xa - xb) * (xa - xb) + (ya - yb) * (ya - yb)).sqrt()
+}
+
+pub fn min_of_f32_vec(mut list: [f32; 4]) -> f32 {
+    list.sort_by(|a, b| a.partial_cmp(b).unwrap());
+    list[0]
+}
+
+pub fn max_of_f32_vec(mut list: [f32; 4]) -> f32 {
+    list.sort_by(|a, b| b.partial_cmp(a).unwrap());
+    list[0]
 }

src/utils/mod.rs

@@ -98,7 +98,7 @@ pub fn play_bonus(sounds: &Sounds, storage: &AssetStorage<Source>, output: Optio
 
 pub fn play_air(sounds: &Sounds, storage: &AssetStorage<Source>, output: Option<&Output>) {
     if let Some(ref output) = output.as_ref() {
-        if let Some(sound) = storage.get(&sounds.bonus) {
+        if let Some(sound) = storage.get(&sounds.air) {
             output.play_once(sound, 1.0);
         }
     }