feat(canon): add bullet canon

Author: jerthz

.github/workflows/clippy_workflow.yml

@@ -16,8 +16,9 @@ jobs:
         run: sudo apt install libasound2-dev
       - run: rustup component add clippy
       - run: cargo clippy --fix -Z unstable-options --features vulkan
+      - run: git diff
       - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v3
+        uses: peter-evans/create-pull-request@v3.5.0
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
           branch-suffix: timestamp

assets/levels/level_1.json

@@ -0,0 +1,18 @@
+List((
+	texture_width: 12,
+	texture_height: 4,
+	sprites: [
+    		    (
+            			x: 0,
+            			y: 0,
+            			width: 4,
+            			height: 4,
+            		),
+            	(
+                        x: 4,
+                        y: 0,
+            			width: 8,
+            			height: 4,
+                    ),
+                 ]
+               ))

assets/levels/level_1.png

@@ -0,0 +1,25 @@
+use amethyst::core::ecs::{DenseVecStorage, Component};
+use crate::utils::Direction;
+#[derive(Debug)]
+pub enum CanonKind {
+    Bullet, Plasma, Air
+}
+#[derive(Debug)]
+pub struct Canon {
+    pub direction: Direction,
+    pub kind: CanonKind,
+    pub bullet_x_start: f32,
+    pub bullet_y_start: f32
+}
+
+impl Component for Canon {
+    type Storage = DenseVecStorage<Self>;
+}
+#[derive(Debug)]
+pub struct Bullet {
+    pub direction: Direction,
+}
+
+impl Component for Bullet {
+    type Storage = DenseVecStorage<Self>;
+}

assets/sprites/bullets.png

@@ -15,6 +15,7 @@ impl Component for Transparent {
     type Storage = DenseVecStorage<Self>;
 }
 
+#[derive(Debug)]
 pub struct Colliders {
     colliders: Vec<Collider>,
     polygons: Vec<Polygon<f32>>

assets/sprites/bullets.ron

@@ -1,3 +1,4 @@
 pub mod ship;
 pub mod collision;
-pub mod explosion;
+pub mod explosion;
+pub mod canons;

assets/sprites/main.png

@@ -27,6 +27,8 @@ use crate::systems::explosion_systems::ExplosionSystem;
 use crate::utils::starlight_tile::StartLightTile;
 use amethyst_tiles::MortonEncoder;
 use amethyst_tiles::RenderTiles2D;
+use crate::systems::canon_system::CanonSystem;
+use crate::systems::bullet_system::BulletSystem;
 
 fn main() -> amethyst::Result<()> {
     amethyst::start_logger(Default::default());
@@ -55,7 +57,6 @@ fn main() -> amethyst::Result<()> {
                 )
                 .with_plugin(RenderUi::default())
                 .with_plugin(RenderFlat2D::default())
-                .with_plugin(RenderTiles2D::<StartLightTile, MortonEncoder>::default()),
         )?
         .with(
             ShipSystem,
@@ -82,6 +83,16 @@ fn main() -> amethyst::Result<()> {
             "explosion_system",
             &[],
         )
+        .with(
+            CanonSystem::default(),
+            "canon_system",
+            &[],
+        )
+        .with(
+            BulletSystem,
+            "bullet_system",
+            &[],
+        )
         ;
 
     let mut game = Application::new(resources, LevelState, game_data)?;

src/entities/canons.rs

@@ -18,12 +18,14 @@ pub struct MainResource {
     pub should_be_reset: bool,
     _gravity: f32,
     current_level_config: Option<LevelConfig>,
-    pub sprites: Option<ShipSprites>
+    pub sprites: Option<MainSprites>,
 
+    pub ship_life: usize,
 }
 
-pub struct ShipSprites {
-    pub explosion_sprite_render: Handle<SpriteSheet>
+pub struct MainSprites {
+    pub explosion_sprite_render: Handle<SpriteSheet>,
+    pub bullet_sprite_render: Handle<SpriteSheet>
 }
 
 impl MainResource {
@@ -38,7 +40,8 @@ impl MainResource {
             is_exploding: false,
             should_be_reset: false,
             current_level_config,
-            sprites: None
+            sprites: None,
+            ship_life: 3
         }
     }
 
@@ -58,6 +61,7 @@ impl MainResource {
         self.current_rotation_angle = 0.;
         self.is_exploding = false;
         self.should_be_reset = false;
+        self.ship_life = 3;
     }
 
     pub fn power(&mut self, delta_time: f32,  rotation: &UnitQuaternion<f32>) {

src/entities/collision.rs

@@ -10,8 +10,8 @@ use serde_json::from_reader;
 use serde::Deserialize;
 use std::collections::HashMap;
 use crate::entities::ship::{Ship, ShipParent, Thrusters};
-use crate::resources::main_resource::{MainResource, ShipSprites};
-use crate::utils::sprite_to_colliders::{sprite_to_colliders, is_landing_platform_start};
+use crate::resources::main_resource::{MainResource, MainSprites};
+use crate::utils::sprite_to_entities::{sprite_to_colliders, is_landing_platform_start, sprite_to_canon};
 use crate::entities::collision::{Transparent, LandingPlatform};
 use amethyst::utils::application_root_dir;
 use amethyst::core::math::{Point3, Vector3};
@@ -31,6 +31,9 @@ const CONFIG_MISC: &str = "sprites/main.ron";
 const IMAGE_SHIP: &str = "sprites/space_ship.png";
 const CONFIG_SHIP: &str = "sprites/space_ship.ron";
 
+const IMAGE_BULLETS: &str = "sprites/bullets.png";
+const CONFIG_BULLETS: &str = "sprites/bullets.ron";
+
 const IMAGE_EXPLOSION: &str = "sprites/explosion.png";
 const CONFIG_EXPLOSION: &str = "sprites/explosion.ron";
 
@@ -43,14 +46,15 @@ impl SimpleState for LevelState {
         //let misc_spritesheet_handle = load_misc_spritesheet(world);
         let level_spritesheet_handle = load_level_spritesheet(world, 1);
         let ship_spritesheet_handle = load_ship_spritesheet(world);
+        let bullet_spritesheet_handle = load_bullets_spritesheet(world);
         let ship_explosion_handle = load_explosion_spritesheet(world);
 
         initialize_level_tileset(world, level_spritesheet_handle, &level);
-        initialize_colliders(world, &level);
+        initialize_colliders_with_entitites(world, &level);
         let ship = initialize_ship(world, &level, ship_spritesheet_handle);
         initialize_camera(world, &level, ship);
         let mut ship_resource = MainResource::new_from_level(Some(level));
-        ship_resource.sprites = Some(ShipSprites { explosion_sprite_render: ship_explosion_handle });
+        ship_resource.sprites = Some(MainSprites { explosion_sprite_render: ship_explosion_handle, bullet_sprite_render: bullet_spritesheet_handle });
         world.insert(ship_resource);
     }
 }
@@ -63,6 +67,10 @@ pub fn load_ship_spritesheet(world: &mut World) -> Handle<SpriteSheet> {
     load_texture(world, IMAGE_SHIP, CONFIG_SHIP)
 }
 
+pub fn load_bullets_spritesheet(world: &mut World) -> Handle<SpriteSheet> {
+    load_texture(world, IMAGE_BULLETS, CONFIG_BULLETS)
+}
+
 pub fn load_explosion_spritesheet(world: &mut World) -> Handle<SpriteSheet> {
     load_texture(world, IMAGE_EXPLOSION, CONFIG_EXPLOSION)
 }
@@ -98,7 +106,7 @@ fn load_texture(world: &mut World, image: &str, config: &str) -> Handle<SpriteSh
     )
 }
 
-fn initialize_colliders(world: &mut World, level: &LevelConfig) {
+fn initialize_colliders_with_entitites(world: &mut World, level: &LevelConfig) {
     for (point, sprite) in level.tiles.borrow() {
         let collider = sprite_to_colliders(*sprite, point.x as f32 * TILE_SIZE, point.y as f32 * TILE_SIZE);
         if collider.is_some() {
@@ -107,6 +115,7 @@ fn initialize_colliders(world: &mut World, level: &LevelConfig) {
                 .with(collider.unwrap());
 
             if is_landing_platform_start(*sprite) { builder = builder.with(LandingPlatform); }
+            if let Some(canon) = sprite_to_canon(*sprite, point.x as usize, point.y as usize) {builder = builder.with(canon); }
             builder.build();
         }
     }
@@ -122,7 +131,7 @@ fn initialize_level_tileset(
         sprite_number: 0,
     };
     let mut t = Transform::default();
-    t.set_translation_xyz(32. * level.width as f32 / 2. - 16.0, 32. * level.height as f32 / 2. - 16., 0.);
+    t.set_translation_xyz( (TILE_SIZE * level.width as f32) / 2. - TILE_SIZE / 2., (TILE_SIZE * level.height as f32) / 2. - TILE_SIZE / 2., 0.);
     world
         .create_entity()
         .with(sprite_render)
@@ -148,7 +157,7 @@ fn initialize_ship(
     let mut transform = Transform::default();
     transform.set_translation_xyz(
         level.start_x as f32 * TILE_SIZE - 16.,
-        ((level.height - level.start_y) as f32 * TILE_SIZE) -32.,
+        ((level.height - level.start_y) as f32 * TILE_SIZE),
         0.04,
     );
 

src/entities/mod.rs

@@ -0,0 +1,54 @@
+use amethyst::core::ecs::{System, ReadStorage, WriteStorage, Join, Read, Entities, Write};
+use crate::entities::canons::{Bullet, Canon, CanonKind};
+use amethyst::core::{Transform, Time};
+use crate::utils::Direction;
+use crate::entities::collision::{Colliders, are_colliding};
+use geo::Polygon;
+use crate::utils::sprite_to_entities::init_bullet_collider;
+use std::ops::Deref;
+use crate::resources::main_resource::MainResource;
+use crate::entities::ship::ShipParent;
+
+pub struct BulletSystem;
+
+impl<'s> System<'s> for BulletSystem {
+    type SystemData = (
+        ReadStorage<'s, Bullet>,
+        ReadStorage<'s, Canon>,
+        WriteStorage<'s, Transform>,
+        ReadStorage<'s, Colliders>,
+        ReadStorage<'s, ShipParent>,
+        Write<'s, MainResource>,
+        Read<'s, Time>,
+        Entities<'s>,);
+
+    fn run(&mut self, (bullets, canons, mut transforms, colliders, ships,mut main_resource, time, entities): Self::SystemData) {
+        let mut ship_polygon = Vec::new();
+        for (_ship, transform) in (&ships, &transforms).join() {
+            ship_polygon = main_resource.get_colliders_polygons(transform.translation().x, transform.translation().y);
+        }
+        let mut bullet_vec: Vec<(u32, Vec<Polygon<f32>>)> = Vec::new();
+        for (bullet, transform, entity) in (&bullets, &mut transforms, &entities).join() {
+            let colliders = init_bullet_collider(CanonKind::Bullet, transform.translation().x, transform.translation().y);
+            if are_colliding(colliders.polygons(), &ship_polygon) {
+                main_resource.ship_life -= 1;
+                entities.delete(entity);
+            }else{
+                bullet_vec.push((entity.id(), colliders.polygons().clone()));
+            }
+            match bullet.direction {
+                Direction::Left => transform.append_translation_xyz(-200.0 * time.delta_seconds(), 0., 0.),
+                Direction::Right => transform.append_translation_xyz(200.0 * time.delta_seconds(), 0., 0.),
+                _ => {transform.append_translation_xyz(0.,0.,0.)}
+            };
+        }
+        for (platform_collider, _, _) in (&colliders, !&bullets, !&canons).join() {
+            for (id, polygons) in bullet_vec.iter(){
+                if are_colliding(&polygons, platform_collider.polygons()) {
+                    let e = entities.entity(*id);
+                    entities.delete(e);
+                }
+            }
+        }
+    }
+}

src/main.rs

@@ -0,0 +1,59 @@
+use amethyst::core::ecs::{System, WriteStorage, ReadStorage, Entities, Join, Read};
+use crate::entities::collision::Colliders;
+use amethyst::core::{Transform, Time};
+use crate::entities::canons::{Canon, Bullet, CanonKind};
+use amethyst::renderer::SpriteRender;
+use std::collections::HashMap;
+use amethyst::core::ecs::world::Index;
+use rand::{random, Rng};
+use crate::utils::Direction;
+use crate::resources::main_resource::MainResource;
+use crate::utils::sprite_to_entities::init_bullet_collider;
+
+pub struct CanonSystem {
+    shooting_timers: HashMap<u32, f32>
+}
+
+impl Default for CanonSystem {
+    fn default() -> Self {
+        CanonSystem {
+            shooting_timers: HashMap::new()
+        }
+    }
+}
+
+impl<'s> System<'s> for CanonSystem {
+    type SystemData = (
+        ReadStorage<'s, Canon>,
+        WriteStorage<'s, Bullet>,
+        WriteStorage<'s, Transform>,
+        WriteStorage<'s, SpriteRender>,
+        Read<'s, Time>,
+        Read<'s, MainResource>,
+        Entities<'s>,
+    );
+
+    fn run(&mut self, (canons, mut bullets, mut transforms, mut sprite_renders, time,resource, entities): Self::SystemData) {
+        for (canon, entity) in (&canons, &entities).join() {
+            *self.shooting_timers.entry(entity.id())
+                .or_insert(rand::thread_rng().gen_range(0.1, 2.5)) -= time.delta_seconds();
+            let mut val = self.shooting_timers.get(&entity.id()).unwrap();
+            if val <= &0. {
+                let mut bullet_transform = Transform::default();
+                bullet_transform.set_translation_xyz(canon.bullet_x_start, canon.bullet_y_start, 0.9);
+                entities
+                    .build_entity()
+                    .with(Bullet{ direction: canon.direction.clone() }, &mut bullets)
+                    .with(SpriteRender {
+                        sprite_sheet: resource.sprites.as_ref().unwrap().bullet_sprite_render.clone(),
+                        sprite_number: 0,
+                    }, &mut sprite_renders)
+                    .with(bullet_transform, &mut transforms)
+                    .build();
+
+                self.shooting_timers.remove(&entity.id());
+                self.shooting_timers.insert(entity.id(), 1.5);
+            }
+        }
+    }
+}

src/resources/main_resource.rs

@@ -11,6 +11,7 @@ use amethyst::assets::Handle;
 use amethyst::core::ecs::storage::MaskedStorage;
 use amethyst_tiles::{TileMap, MortonEncoder2D};
 use crate::utils::starlight_tile::StartLightTile;
+use crate::entities::canons::Bullet;
 
 pub struct CollisionSystem;
 
@@ -23,15 +24,15 @@ impl<'s> System<'s> for CollisionSystem {
         Write<'s, MainResource>,
         WriteStorage<'s, Explosion>,
         WriteStorage<'s, SpriteRender>,
-        Entities<'s>,
-        ReadStorage<'s, TileMap<StartLightTile, MortonEncoder2D>>
+        ReadStorage<'s, Bullet>,
+        Entities<'s>
     );
 
-    fn run(&mut self, (colliders, landing_plateforms, ships, mut transforms, mut ship_resource, mut explosions, mut sprite_renders, entities, tilemap): Self::SystemData) {
+    fn run(&mut self, (colliders, landing_plateforms, ships, mut transforms, mut ship_resource, mut explosions, mut sprite_renders, bullets, entities): Self::SystemData) {
         let mut explosion_information = (false, 0., 0.);
         for (_ship, transform) in (&ships, &transforms).join() {
             let ship_polygon = ship_resource.get_colliders_polygons(transform.translation().x, transform.translation().y);
-            for (collider, _) in (&colliders, !&landing_plateforms).join() {
+            for (collider, _, _) in (&colliders, !&landing_plateforms, !&bullets).join() {
                 let struct_polygons = collider.polygons();
                 if !ship_resource.is_exploding && are_colliding(&ship_polygon, struct_polygons) {
                     ship_resource.is_exploding = true;

src/states/level.rs

@@ -2,4 +2,6 @@ pub mod ship_systems;
 pub mod collision_system;
 pub mod thruster_system;
 pub mod explosion_systems;
-pub mod landing_system;
+pub mod landing_system;
+pub mod canon_system;
+pub mod bullet_system;