├── .gitignore
├── _rust-toolchain.toml
├── assets
    ├── level.progression.yaml
    ├── xp.png
    ├── arrow.png
    ├── shadow.png
    ├── tileset.png
    ├── health_bar.png
    ├── BitPotionExt.ttf
    ├── health_bar_fill.png
    ├── health_bar_border.png
    ├── monogram-extended.ttf
    ├── entities
    │   ├── enemies
    │   │   ├── Mushroom.png
    │   │   ├── FlyingEye.png
    │   │   ├── demon_slime.png
    │   │   ├── mushroom.yaml
    │   │   ├── flying_eye.yaml
    │   │   ├── enemy.yaml
    │   │   ├── bosses.yaml
    │   │   └── data.yaml
    │   └── player
    │   │   ├── GUMDROP.E64.R.PNG
    │   │   └── player.yaml
    ├── monster_flesh_eye_sheet.png
    ├── monster_flesh_teeth_sheet.png
    ├── floors
    │   ├── start.yaml.floor
    │   └── medium.yaml.floor
    └── domains.yaml
├── src
    ├── map
    │   ├── mod.rs
    │   ├── walkable.rs
    │   ├── generation.rs
    │   └── map.rs
    ├── game_states
    │   ├── mod.rs
    │   ├── menu.rs
    │   ├── loading.rs
    │   └── ingame.rs
    ├── movement
    │   ├── mod.rs
    │   ├── direction.rs
    │   ├── movement.rs
    │   └── easing.rs
    ├── state.rs
    ├── sorting.rs
    ├── effects.rs
    ├── prototype.rs
    ├── statistics.rs
    ├── main.rs
    ├── animation.rs
    ├── ui
    │   ├── boss.rs
    │   └── player.rs
    ├── manifest
    │   ├── floor.rs
    │   ├── player.rs
    │   ├── boss.rs
    │   ├── enemy.rs
    │   └── mod.rs
    ├── boss.rs
    ├── enemy.rs
    ├── helper.rs
    ├── ui.rs
    ├── controller.rs
    ├── collision.rs
    ├── enemy
    │   └── state_machine.rs
    ├── stats.rs
    ├── floor.rs
    ├── player.rs
    └── attack.rs
├── Cargo.toml
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | /target
2 | /.idea
3 | /.fleet
4 | /.vscode


--------------------------------------------------------------------------------
/_rust-toolchain.toml:
--------------------------------------------------------------------------------
1 | [toolchain]
2 | channel = "nightly"
3 | 


--------------------------------------------------------------------------------
/assets/level.progression.yaml:
--------------------------------------------------------------------------------
1 | base_xp: 100
2 | xp_multiplier: 1.5
3 | 


--------------------------------------------------------------------------------
/src/map/mod.rs:
--------------------------------------------------------------------------------
1 | pub mod generation;
2 | pub mod walkable;
3 | pub mod map;
4 | 


--------------------------------------------------------------------------------
/src/game_states/mod.rs:
--------------------------------------------------------------------------------
1 | pub mod ingame;
2 | pub mod loading;
3 | pub mod menu;
4 | 


--------------------------------------------------------------------------------
/src/movement/mod.rs:
--------------------------------------------------------------------------------
1 | pub mod direction;
2 | pub mod easing;
3 | pub mod movement;
4 | 


--------------------------------------------------------------------------------
/assets/xp.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/edgarssilva/relentless-revenge/HEAD/assets/xp.png


--------------------------------------------------------------------------------
/assets/arrow.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/edgarssilva/relentless-revenge/HEAD/assets/arrow.png


--------------------------------------------------------------------------------
/assets/shadow.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/edgarssilva/relentless-revenge/HEAD/assets/shadow.png


--------------------------------------------------------------------------------
/assets/tileset.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/edgarssilva/relentless-revenge/HEAD/assets/tileset.png


--------------------------------------------------------------------------------
/assets/health_bar.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/edgarssilva/relentless-revenge/HEAD/assets/health_bar.png


--------------------------------------------------------------------------------
/assets/BitPotionExt.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/edgarssilva/relentless-revenge/HEAD/assets/BitPotionExt.ttf


--------------------------------------------------------------------------------
/assets/health_bar_fill.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/edgarssilva/relentless-revenge/HEAD/assets/health_bar_fill.png


--------------------------------------------------------------------------------
/assets/health_bar_border.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/edgarssilva/relentless-revenge/HEAD/assets/health_bar_border.png


--------------------------------------------------------------------------------
/assets/monogram-extended.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/edgarssilva/relentless-revenge/HEAD/assets/monogram-extended.ttf


--------------------------------------------------------------------------------
/assets/entities/enemies/Mushroom.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/edgarssilva/relentless-revenge/HEAD/assets/entities/enemies/Mushroom.png


--------------------------------------------------------------------------------
/assets/monster_flesh_eye_sheet.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/edgarssilva/relentless-revenge/HEAD/assets/monster_flesh_eye_sheet.png


--------------------------------------------------------------------------------
/assets/monster_flesh_teeth_sheet.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/edgarssilva/relentless-revenge/HEAD/assets/monster_flesh_teeth_sheet.png


--------------------------------------------------------------------------------
/assets/entities/enemies/FlyingEye.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/edgarssilva/relentless-revenge/HEAD/assets/entities/enemies/FlyingEye.png


--------------------------------------------------------------------------------
/assets/entities/enemies/demon_slime.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/edgarssilva/relentless-revenge/HEAD/assets/entities/enemies/demon_slime.png


--------------------------------------------------------------------------------
/assets/entities/player/GUMDROP.E64.R.PNG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/edgarssilva/relentless-revenge/HEAD/assets/entities/player/GUMDROP.E64.R.PNG


--------------------------------------------------------------------------------
/assets/floors/start.yaml.floor:
--------------------------------------------------------------------------------
 1 | floors: [1, 5]
 2 | 
 3 | rooms: [2, 3]
 4 | room_size: [3, 4]
 5 | enemies_count: [2, 6]
 6 | 
 7 | enemies:
 8 |   - path: "../entities/enemies/yaml.enemy"
 9 |     weight: 4
10 |   - path: "../entities/enemies/flying_eye.yaml.enemy"
11 |     weight: 1
12 | 


--------------------------------------------------------------------------------
/assets/floors/medium.yaml.floor:
--------------------------------------------------------------------------------
 1 | floors: [6, 20]
 2 | 
 3 | rooms: [3, 6]
 4 | room_size: [4, 6]
 5 | enemies_count: [6, 24]
 6 | 
 7 | enemies:
 8 |   - path: "../entities/enemies/yaml.enemy"
 9 |     weight: 2
10 |   - path: "../entities/enemies/flying_eye.yaml.enemy"
11 |     weight: 2
12 |   - path: "../entities/enemies/mushroom.yaml.enemy"
13 |     weight: 1
14 | 


--------------------------------------------------------------------------------
/assets/entities/enemies/mushroom.yaml:
--------------------------------------------------------------------------------
 1 | name: "Mushroom"
 2 | 
 3 | xp: 75
 4 | damage: 5
 5 | health: 200
 6 | speed: 15
 7 | cooldown: 7500
 8 | 
 9 | texture:
10 |   path: "./Mushroom.png"
11 |   tile_size: [150, 150]
12 |   rows: 1
13 |   columns: 8
14 |   frames: [0, 1, 2, 3, 4, 5, 6, 7]
15 |   duration: 100
16 | 
17 | scale: [1, 1]
18 | hitbox: [25, 40]
19 | 
20 | attack:
21 |   type: "Melee"
22 |   size: [40, 40]
23 |   duration: 3.0
24 |   knockback: 5.0
25 | 
26 | feet_offset: 20
27 | 


--------------------------------------------------------------------------------
/src/state.rs:
--------------------------------------------------------------------------------
 1 | use bevy::prelude::Component;
 2 | use serde::{Deserialize, Serialize};
 3 | 
 4 | #[derive(Component, Serialize, Deserialize, PartialEq, Eq, Hash, Clone, Copy, Debug)]
 5 | pub enum State {
 6 |     Idle,
 7 |     Walking,
 8 |     Attacking(u32), //Index of the attack in a combo
 9 |     Dashing,
10 |     _Dying,
11 | }
12 | 
13 | impl State {
14 |     pub fn set(&mut self, state: State) {
15 |         *self = state;
16 |     }
17 | 
18 |     pub fn equals(&self, other: Self) -> bool {
19 |         *self == other
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/assets/entities/enemies/flying_eye.yaml:
--------------------------------------------------------------------------------
 1 | name: "Flying Eye"
 2 | 
 3 | xp: 55
 4 | damage: 15
 5 | health: 60
 6 | speed: 30
 7 | cooldown: 6500
 8 | 
 9 | texture:
10 |   path: "./FlyingEye.png"
11 |   tile_size: [150, 150]
12 |   rows: 1
13 |   columns: 8
14 |   frames: [0, 1, 2, 3, 4, 5, 6, 7]
15 |   duration: 100
16 | 
17 | scale: [1.2, 1.2]
18 | hitbox: [24, 24]
19 | 
20 | attack:
21 |   type: "Ranged"
22 |   size: [100, 20]
23 |   velocity: 70
24 |   duration: 3.0
25 |   texture:
26 |     path: "../../arrow.png"
27 |     tile_size: [100, 100]
28 |     rows: 5
29 |     columns: 6
30 |     duration: 100
31 | 
32 | feet_offset: 20 
33 | 


--------------------------------------------------------------------------------
/assets/entities/enemies/enemy.yaml:
--------------------------------------------------------------------------------
 1 | name: "Cool Enemy"
 2 | 
 3 | xp: 50
 4 | damage: 10
 5 | health: 100
 6 | speed: 20
 7 | cooldown: 7000
 8 | 
 9 | texture:
10 |   path: "../../monster_flesh_eye_sheet.png"
11 |   tile_size: [256, 256]
12 |   rows: 3
13 |   columns: 3
14 |   frames: [0, 1, 2, 3, 4, 5, 6, 7]
15 |   duration: 250
16 | 
17 | scale: [0.25, 0.25]
18 | hitbox: [96, 96]
19 | 
20 | attack:
21 |   type: "Ranged"
22 |   size: [100, 20]
23 |   velocity: 70
24 |   duration: 3.0
25 |   texture:
26 |     path: "../../arrow.png"
27 |     tile_size: [100, 100]
28 |     rows: 5
29 |     columns: 6
30 |     duration: 100
31 | 
32 | feet_offset: 24 
33 | 


--------------------------------------------------------------------------------
/src/sorting.rs:
--------------------------------------------------------------------------------
 1 | use bevy::prelude::{Component, Query, Transform};
 2 | 
 3 | //pub const MAP_LAYER: f32 = 0.0;
 4 | pub const ENTITIES_LAYER: f32 = 100.0;
 5 | 
 6 | const MAX_Y: f32 = 10000.0;
 7 | 
 8 | #[derive(Component)]
 9 | pub struct YSort(pub f32);
10 | 
11 | #[derive(Component)]
12 | pub struct FeetOffset(pub f32);
13 | 
14 | pub fn ysort(mut query: Query<(&YSort, &mut Transform, Option<&FeetOffset>)>) {
15 |     for (ysort, mut transform, offset) in query.iter_mut() {
16 |         let offset = offset.map(|x| x.0).unwrap_or(0.0);
17 |         transform.translation.z = ysort.0 - ((transform.translation.y - offset) / MAX_Y);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/game_states/menu.rs:
--------------------------------------------------------------------------------
 1 | use bevy::{
 2 |     input::ButtonInput,
 3 |     prelude::{App, KeyCode, NextState, OnEnter, Plugin, Res, ResMut},
 4 | };
 5 | 
 6 | use crate::GameState;
 7 | 
 8 | pub struct MainMenuPlugin;
 9 | 
10 | impl Plugin for MainMenuPlugin {
11 |     fn build(&self, app: &mut App) {
12 |         app.add_systems(OnEnter(GameState::MainMenu), (setup_menu, skip_menu));
13 |     }
14 | }
15 | 
16 | fn setup_menu() {}
17 | 
18 | fn skip_menu(keys: Res<ButtonInput<KeyCode>>, mut state: ResMut<NextState<GameState>>) {
19 |     if keys.any_just_pressed([KeyCode::Space, KeyCode::Backslash]) {
20 |         state.set(GameState::InGame);
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/assets/domains.yaml:
--------------------------------------------------------------------------------
 1 | domains:
 2 |   - name: "Entrance"
 3 |     floors: [1, 5]
 4 | 
 5 |     rooms: [2, 3]
 6 |     room_size: [3, 4]
 7 |     enemies_count: [2, 6]
 8 | 
 9 |     boss: "Demon Slime"
10 | 
11 |     enemies:
12 |       - [4, "Cool Enemy"]
13 |       - [1, "Flying Eye"]
14 | 
15 | 
16 |   - name: "Dungeon"
17 |     floors: [6, 20]
18 | 
19 |     rooms: [3, 6]
20 |     room_size: [4, 6]
21 |     enemies_count: [6, 24]
22 | 
23 |     boss: "Demon Slime"
24 | 
25 |     enemies:
26 |       - [2, "Cool Enemy"]
27 |       - [2, "Flying Eye"]
28 |       - [1, "Mushroom"]
29 | #      - name: "Cool Enemy"
30 | #        weight: 2
31 | #      - name: "Flying Eye"
32 | #        weight: 2
33 | #      - name: "Mushroom"
34 | #        weight: 1
35 | 


--------------------------------------------------------------------------------
/src/effects.rs:
--------------------------------------------------------------------------------
 1 | use crate::{game_states::loading::GameAssets, sorting::FeetOffset};
 2 | use bevy::prelude::*;
 3 | 
 4 | #[derive(Component)]
 5 | pub struct Shadow;
 6 | 
 7 | pub fn spawn_shadows(
 8 |     query: Query<(Entity, Option<&FeetOffset>), Added<Shadow>>,
 9 |     game_assets: Res<GameAssets>,
10 |     mut commands: Commands,
11 | ) {
12 |     for (entity, offset) in query.iter() {
13 |         let offset = offset.map(|x| x.0).unwrap_or(0.0);
14 |         commands.entity(entity).with_children(|parent| {
15 |             parent.spawn(SpriteBundle {
16 |                 texture: game_assets.shadow_texture.clone(),
17 |                 transform: Transform::from_xyz(0., -offset, -0.5),
18 |                 ..Default::default()
19 |             });
20 |         });
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/assets/entities/enemies/bosses.yaml:
--------------------------------------------------------------------------------
 1 | bosses:
 2 |   - name: "Demon Slime"
 3 | 
 4 |     xp: 1500
 5 |     damage: 50
 6 |     health: 100
 7 |     speed: 20
 8 | 
 9 |     scale: [1, 1]
10 |     hitbox: [96, 96]
11 | 
12 |     feet_offset: 48
13 | 
14 |     texture:
15 |       path: "entities/enemies/demon_slime.png"
16 |       tile_size: [288, 160]
17 |       rows: 5
18 |       columns: 22
19 | 
20 |     animations:
21 |       - name: "idle"
22 |         #frames: [0, 1, 2, 3, 4, 5]
23 |         frames: [22, 23, 24, 25,26,27,28,29,30,31]
24 |         duration: 250
25 | 
26 |       - name: "jump"
27 |         frames: [22, 33]
28 |         duration: 250
29 | 
30 |       - name: "attack"
31 |         frames: [44, 58]
32 |         duration: 250
33 | 
34 |       - name: "hit"
35 |         frames: [66, 70]
36 |         duration: 250
37 | 
38 |       - name: "death"
39 |         frames: [88, 109]
40 |         duration: 250
41 |       
42 | 


--------------------------------------------------------------------------------
/src/prototype.rs:
--------------------------------------------------------------------------------
 1 | use std::any::Any;
 2 | use crate::player::PlayerBundle;
 3 | use bevy::prelude::{Component, FromReflect, Vec2};
 4 | use bevy::reflect::{Reflect, ReflectMut, ReflectOwned, ReflectRef, Typed, TypeInfo};
 5 | use bevy_proto::prelude::{DependenciesBuilder, Schematic, SchematicContext};
 6 | 
 7 | #[derive(Reflect, FromReflect)]
 8 | pub struct StatsProto {
 9 |     pub health: u32,
10 |     pub damage: u32,
11 |     pub speed: u32,
12 |     pub cooldown: u32,
13 |     pub xp: u32,
14 | }
15 | 
16 | #[derive(Reflect, FromReflect)]
17 | pub struct PlayerProto {
18 |     name: String,
19 |     stats: StatsProto,
20 |     size: Vec2,
21 |     hitbox: Vec2,
22 | }
23 | 
24 | impl Schematic for PlayerBundle {
25 |     type Input = PlayerProto;
26 | 
27 |     fn apply(input: &Self::Input, context: &mut SchematicContext) {}
28 | 
29 |     fn remove(input: &Self::Input, context: &mut SchematicContext) {}
30 | 
31 |     fn preload_dependencies(input: &mut Self::Input, dependencies: &mut DependenciesBuilder) {}
32 | }
33 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | edition = "2021"
 3 | name = "isometric"
 4 | version = "0.1.0"
 5 | 
 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 7 | 
 8 | [dependencies]
 9 | bevy = {version = "0.14", features = ["dynamic_linking"] }
10 | bevy_egui = "0.29.0"
11 | bevy_rapier2d = "0.27"
12 | bevy_ecs_tilemap = "0.14" 
13 | 
14 | #big-brain = "0.16.0"
15 | seldom_state = "0.11"
16 | 
17 | leafwing-input-manager = "0.15"
18 | leafwing_manifest = {version = "0.2.0", features = ["yaml"]}
19 | 
20 | #bevy_asset_loader = { version = "0.20", features = ["2d"] }
21 | bevy_common_assets = { version = "0.11", features = ["yaml"] }
22 | 
23 | turborand = "0.10.0"
24 | dirs = "5.0"
25 | serde = "1.0"
26 | bevy-persistent = { version = "0.6", features = ["all"] }
27 | noisy_bevy = "0.7"
28 | bevy_spritesheet_animation = "0.4.2"
29 | 
30 | # Otimizations to speed up compilation in debug mode
31 | # Enable a small amount of optimization in debug mode
32 | [profile.dev]
33 | opt-level = 1
34 | 
35 | # Enable high optimizations for dependencies (incl. Bevy), but not for our code:
36 | [profile.dev.package."*"]
37 | opt-level = 3
38 | 


--------------------------------------------------------------------------------
/src/statistics.rs:
--------------------------------------------------------------------------------
 1 | use bevy::prelude::*;
 2 | use bevy::time::{Timer, TimerMode};
 3 | use bevy::utils::Duration;
 4 | use bevy_persistent::prelude::*;
 5 | use serde::{Deserialize, Serialize};
 6 | 
 7 | use crate::player::Player;
 8 | 
 9 | #[derive(Resource, Serialize, Deserialize, Debug, Clone, Default)]
10 | pub struct Statistics {
11 |     pub kills: u32,
12 |     pub deaths: u32,
13 |     pub dashes: u32,
14 |     pub damage_dealt: u32,
15 |     pub damage_taken: u32,
16 |     pub max_xp: u32,
17 |     pub max_level: u32,
18 |     pub revenge_time: f32,
19 |     pub play_time: f32,
20 |     pub game_count: u32,
21 |     pub healing: u32,
22 | }
23 | 
24 | pub fn auto_save(
25 |     time: Res<Time>,
26 |     statistics: ResMut<Persistent<Statistics>>,
27 |     mut timer: Local<Timer>,
28 | ) {
29 |     timer.set_duration(Duration::from_secs_f32(25.));
30 |     timer.set_mode(TimerMode::Repeating);
31 |     timer.tick(time.delta());
32 | 
33 |     if timer.just_finished() {
34 |         let _ = statistics.persist();
35 |     }
36 | }
37 | 
38 | pub fn statistics(
39 |     mut statistics: ResMut<Persistent<Statistics>>,
40 |     query: Query<&Player>,
41 |     time: Res<Time>,
42 | ) {
43 |     for _ in query.iter() {
44 |         statistics.play_time += time.delta().as_secs_f32();
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/main.rs:
--------------------------------------------------------------------------------
 1 | use bevy::prelude::*;
 2 | 
 3 | use game_states::{ingame::InGamePlugin, loading::LoadingPlugin, menu::MainMenuPlugin};
 4 | use helper::KeyMaps;
 5 | use stats::*;
 6 | 
 7 | mod animation;
 8 | mod attack;
 9 | mod boss;
10 | mod collision;
11 | mod controller;
12 | mod effects;
13 | mod enemy;
14 | mod floor;
15 | mod game_states;
16 | mod helper;
17 | mod manifest;
18 | mod map;
19 | mod movement;
20 | mod player;
21 | mod sorting;
22 | mod state;
23 | mod statistics;
24 | mod stats;
25 | mod ui;
26 | 
27 | pub const PLAYER_Z: f32 = 39.;
28 | pub const MAP_Z: f32 = 36.;
29 | pub const BACKGROUND_Z: f32 = 1.;
30 | pub const DEBUG_Z: f32 = 100.;
31 | 
32 | #[derive(Debug, Clone, Copy, Default, Eq, PartialEq, Hash, States)]
33 | enum GameState {
34 |     #[default]
35 |     Loading,
36 |     MainMenu,
37 |     InGame,
38 | }
39 | 
40 | fn main() {
41 |     App::new()
42 |         .add_plugins(DefaultPlugins.set(ImagePlugin::default_nearest()))
43 |         .insert_resource(ClearColor(Color::srgb(20. / 255., 0. / 255., 25. / 255.)))
44 |         .insert_resource(KeyMaps::default())
45 |         .init_state::<GameState>()
46 |         .add_plugins(LoadingPlugin)
47 |         .add_plugins(MainMenuPlugin)
48 |         .add_plugins(InGamePlugin)
49 |         .run();
50 | }
51 | 


--------------------------------------------------------------------------------
/src/movement/direction.rs:
--------------------------------------------------------------------------------
 1 | use bevy::{math::Vec2, prelude::Component};
 2 | use serde::{Deserialize, Serialize};
 3 | 
 4 | #[derive(Component, Serialize, Deserialize, PartialEq, Eq, Hash, Clone, Copy, Debug)]
 5 | pub enum Direction {
 6 |     NORTH,
 7 |     SOUTH,
 8 |     WEST,
 9 |     EAST,
10 | }
11 | 
12 | impl Direction {
13 |     pub fn vec(&self) -> Vec2 {
14 |         match *self {
15 |             Self::NORTH => Vec2::Y,
16 |             Self::SOUTH => -Vec2::Y,
17 |             Self::WEST => -Vec2::X,
18 |             Self::EAST => Vec2::X,
19 |         }
20 |     }
21 | 
22 |     pub fn from_vec2(vec: Vec2) -> Option<Self> {
23 |         if vec.x > 0.0 {
24 |             Some(Self::EAST)
25 |         } else if vec.x < 0.0 {
26 |             Some(Self::WEST)
27 |         } else if vec.y > 0.0 {
28 |             Some(Self::NORTH)
29 |         } else if vec.y < 0.0 {
30 |             Some(Self::SOUTH)
31 |         } else {
32 |             None
33 |         }
34 |     }
35 | 
36 |     #[allow(dead_code)]
37 |     pub fn values() -> [Self; 4] {
38 |         [Self::NORTH, Self::SOUTH, Self::WEST, Self::EAST]
39 |     }
40 | 
41 |     pub fn set(&mut self, direction: Direction) {
42 |         *self = direction;
43 |     }
44 | 
45 |     pub fn equals(&self, other: &Self) -> bool {
46 |         self == other
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/game_states/loading.rs:
--------------------------------------------------------------------------------
 1 | use bevy::prelude::*;
 2 | use bevy_egui::EguiPlugin;
 3 | use leafwing_manifest::asset_state::SimpleAssetState;
 4 | 
 5 | use crate::{manifest::DataManifestPlugin, GameState};
 6 | 
 7 | pub struct LoadingPlugin;
 8 | 
 9 | impl Plugin for LoadingPlugin {
10 |     fn build(&self, app: &mut App) {
11 |         app.add_plugins((EguiPlugin, DataManifestPlugin {}))
12 |             .add_systems(OnEnter(GameState::Loading), setup_assets)
13 |             .add_systems(OnEnter(SimpleAssetState::Ready), finish_loading);
14 |     }
15 | }
16 | 
17 | #[derive(Resource)]
18 | pub struct GameAssets {
19 |     pub font: Handle<Font>,
20 |     pub xp_texture: Handle<Image>,
21 |     pub map_texture: Handle<Image>,
22 |     pub shadow_texture: Handle<Image>,
23 | }
24 | 
25 | fn setup_assets(asset_server: Res<AssetServer>, mut commands: Commands) {
26 |     let font = asset_server.load("BitPotionExt.ttf");
27 |     let xp_texture = asset_server.load("xp.png");
28 |     let map_texture = asset_server.load("tileset.png");
29 |     let shadow_texture = asset_server.load("shadow.png");
30 | 
31 |     commands.insert_resource(GameAssets {
32 |         font,
33 |         xp_texture,
34 |         map_texture,
35 |         shadow_texture,
36 |     });
37 | }
38 | 
39 | fn finish_loading(mut next_state: ResMut<NextState<GameState>>) {
40 |     //TODO: Check if our own assets have loaded aswell
41 |     next_state.set(GameState::InGame);
42 | }
43 | 


--------------------------------------------------------------------------------
/src/animation.rs:
--------------------------------------------------------------------------------
 1 | use crate::{movement::direction::Direction, state::State, GameState};
 2 | use bevy_spritesheet_animation::prelude::*;
 3 | 
 4 | use bevy::{
 5 |     prelude::{in_state, App, Component, IntoSystemConfigs, Plugin, Query, Update},
 6 |     utils::HashMap,
 7 | };
 8 | 
 9 | pub struct AnimationPlugin;
10 | 
11 | impl Plugin for AnimationPlugin {
12 |     fn build(&self, app: &mut App) {
13 |         app.add_plugins(SpritesheetAnimationPlugin);
14 |         app.add_systems(
15 |             Update,
16 |             (animation_state).run_if(in_state(GameState::InGame)),
17 |         );
18 |     }
19 | }
20 | 
21 | #[derive(Component, PartialEq, Debug, Clone)]
22 | pub struct Animations(pub HashMap<String, AnimationId>);
23 | 
24 | #[derive(Component, PartialEq, Debug, Clone)] //And statefull
25 | pub struct DirectionalAnimations(pub HashMap<State, HashMap<Direction, AnimationId>>);
26 | 
27 | pub fn animation_state(
28 |     mut query: Query<(
29 |         &DirectionalAnimations,
30 |         &mut SpritesheetAnimation,
31 |         &State,
32 |         &Direction,
33 |     )>,
34 | ) {
35 |     for (animations, mut spritesheet, state, direction) in query.iter_mut() {
36 |         if let Some(state_animations) = animations.0.get(state) {
37 |             if let Some(anim) = state_animations.get(direction) {
38 |                 if spritesheet.animation_id != *anim {
39 |                     spritesheet.switch(*anim);
40 |                 }
41 |             }
42 |         }
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/ui/boss.rs:
--------------------------------------------------------------------------------
 1 | use bevy::{
 2 |     prelude::{Commands, Component, Entity, Query, Res},
 3 |     time::{Time, Timer},
 4 | };
 5 | use bevy_egui::{
 6 |     egui::{self, Color32, Frame, RichText, Stroke},
 7 |     EguiContexts,
 8 | };
 9 | 
10 | #[derive(Component)]
11 | pub struct DomainName(pub String, pub Timer);
12 | 
13 | pub fn draw_domain_name(
14 |     mut commands: Commands,
15 |     mut contexts: EguiContexts,
16 |     mut domain: Query<(&mut DomainName, Entity)>,
17 |     time: Res<Time>,
18 | ) {
19 |     if let Ok((mut domain, entity)) = domain.get_single_mut() {
20 |         let remaining = domain.1.duration().as_secs_f32() - domain.1.elapsed_secs();
21 |         let progress = if remaining > 0.5 { 0.5 } else { remaining };
22 | 
23 |         let alpha = (progress * 255.0) as u8;
24 |         let transparent_white = Color32::from_rgba_unmultiplied(255, 255, 255, alpha);
25 | 
26 |         egui::TopBottomPanel::top("domain_name")
27 |             .frame(
28 |                 Frame::default()
29 |                     .fill(Color32::from_black_alpha(0))
30 |                     .stroke(Stroke::new(0.0, Color32::TRANSPARENT)),
31 |             )
32 |             .show(contexts.ctx_mut(), |ui| {
33 |                 ui.centered_and_justified(|ui| {
34 |                     ui.label(
35 |                         RichText::new(domain.0.clone())
36 |                             .size(40.)
37 |                             .color(transparent_white)
38 |                             .strong(),
39 |                     );
40 |                 });
41 |             });
42 | 
43 |         domain.1.tick(time.delta());
44 | 
45 |         if domain.1.finished() {
46 |             commands.entity(entity).despawn();
47 |         }
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/manifest/floor.rs:
--------------------------------------------------------------------------------
 1 | use std::convert::Infallible;
 2 | 
 3 | use bevy::{asset::Asset, ecs::system::Resource, reflect::TypePath, utils::HashMap};
 4 | use leafwing_manifest::{
 5 |     identifier::Id,
 6 |     manifest::{Manifest, ManifestFormat},
 7 | };
 8 | use serde::{Deserialize, Serialize};
 9 | 
10 | #[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
11 | pub struct DomainData {
12 |     pub name: String,
13 |     pub floors: (u32, u32),
14 |     pub rooms: (u32, u32),
15 |     pub room_size: (u32, u32),
16 |     pub boss: String, //Boss name
17 |     pub enemies_count: (u32, u32),
18 |     pub enemies: Vec<(u32, String)>, // [(Spawn Weight, Enemy Name)]
19 | }
20 | 
21 | #[derive(Debug, Asset, TypePath, Serialize, Deserialize, PartialEq)]
22 | pub struct RawDomainManifest {
23 |     domains: Vec<DomainData>,
24 | }
25 | 
26 | #[derive(Debug, Resource, PartialEq)]
27 | pub struct DomainManifest {
28 |     pub domains: HashMap<Id<DomainData>, DomainData>,
29 | }
30 | 
31 | impl Manifest for DomainManifest {
32 |     type RawManifest = RawDomainManifest;
33 | 
34 |     type RawItem = DomainData;
35 | 
36 |     type Item = DomainData;
37 | 
38 |     type ConversionError = Infallible;
39 | 
40 |     const FORMAT: ManifestFormat = ManifestFormat::Yaml;
41 | 
42 |     fn from_raw_manifest(
43 |         raw_manifest: Self::RawManifest,
44 |         _world: &mut bevy::prelude::World,
45 |     ) -> Result<Self, Self::ConversionError> {
46 |         let domains: bevy::utils::hashbrown::HashMap<Id<DomainData>, DomainData> = raw_manifest
47 |             .domains
48 |             .iter()
49 |             .map(|raw| (Id::from_name(&raw.name.as_str()), raw.clone()))
50 |             .collect();
51 | 
52 |         Ok(DomainManifest { domains })
53 |     }
54 | 
55 |     fn get(&self, id: Id<Self::Item>) -> Option<&Self::Item> {
56 |         self.domains.get(&id)
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/assets/entities/player/player.yaml:
--------------------------------------------------------------------------------
 1 | size: [ 24, 32 ]
 2 | hitbox: [ 18, 28 ]
 3 | 
 4 | xp: 0
 5 | speed: 75
 6 | health: 250
 7 | damage: 55
 8 | cooldown: 400
 9 | 
10 | base_xp: 100
11 | xp_multiplier: 1.5
12 | 
13 | texture:
14 |   path: "entities/player/GUMDROP.E64.R.PNG"
15 |   tile_size: [ 64, 64 ]
16 |   columns: 10
17 |   rows: 48
18 | 
19 | feet_offset: 14
20 | 
21 | animations:
22 |   - state: Idle 
23 |     duration: 69
24 |     directions: 
25 |        SOUTH: [0, 1, 2, 3, 4, 5, 6, 7]
26 |        EAST: [10, 11, 12, 13, 14, 15, 16, 17]
27 |        NORTH: [20, 21, 22, 23, 24, 25, 26, 27]
28 |        WEST: [30, 31, 32, 33, 34, 35, 36, 37]
29 | 
30 |   - state: Walking 
31 |     duration: 69
32 |     directions: 
33 |        SOUTH: [40, 41, 42, 43, 44, 45, 46, 47]
34 |        EAST: [50, 51, 52, 53, 54, 55, 56, 57]
35 |        NORTH: [60, 61, 62, 63, 64, 65, 66, 67]
36 |        WEST: [70, 71, 72, 73, 74, 75, 76, 77]
37 | 
38 |   - state: Dashing 
39 |     duration: 69
40 |     directions: 
41 |       SOUTH: [80, 81, 82, 83, 84, 85, 86, 87]
42 |       EAST: [90, 91, 92, 93, 94, 95, 96, 97]
43 |       NORTH: [100, 101, 102, 103, 104, 105, 106, 107]
44 |       WEST: [110, 111, 112, 113, 114, 115, 116, 117]
45 | 
46 |   - state: !Attacking 0
47 |     duration: 69
48 |     directions:
49 |       SOUTH: [120, 121, 122, 123, 124, 125]
50 |       EAST: [130, 131, 132, 133, 134, 135]
51 |       NORTH: [140, 141, 142, 143, 144, 145]
52 |       WEST: [150, 151, 152, 153, 154, 155]
53 | 
54 |   - state: !Attacking 1
55 |     duration: 69
56 |     directions:
57 |       SOUTH: [160, 161, 162, 163, 164, 165]
58 |       EAST: [170, 171, 172, 173, 174, 175]
59 |       NORTH: [180, 181, 182, 183, 184, 185]
60 |       WEST: [190, 191, 192, 193, 194, 195]
61 |   - state: !Attacking 2
62 |     duration: 69
63 |     directions:
64 |       SOUTH: [200, 201, 202, 203, 204, 205, 206, 207, 208, 209]
65 |       EAST: [210, 211, 212, 213, 214, 215, 216, 217, 218, 219]
66 |       NORTH: [220, 221, 222, 223, 224, 225, 226, 227, 228, 229]
67 |       WEST: [230, 231, 232, 233, 234, 235, 236, 237, 238, 239]
68 | 


--------------------------------------------------------------------------------
/assets/entities/enemies/data.yaml:
--------------------------------------------------------------------------------
  1 | enemies:
  2 |   - name: "Cool Enemy"
  3 | 
  4 |     xp: 50
  5 |     damage: 10
  6 |     health: 100
  7 |     speed: 20
  8 |     cooldown: 7000
  9 | 
 10 |     texture:
 11 |       path: "monster_flesh_teeth_sheet.png"
 12 |       tile_size: [256, 256]
 13 |       rows: 3
 14 |       columns: 3
 15 | 
 16 |     scale: [0.25, 0.25]
 17 |     hitbox: [94, 94]
 18 |     feet_offset: 24 
 19 | 
 20 |     attack:
 21 |       type: "Ranged"
 22 |       size: [80, 16]
 23 |       velocity: 70
 24 |       duration: 3.0
 25 |       texture:
 26 |         path: "arrow.png"
 27 |         tile_size: [100, 100]
 28 |         rows: 5
 29 |         columns: 6
 30 |         animation_duration: 100
 31 |     
 32 |     animations:
 33 |       - name: "idle"
 34 |         frames: [0, 1, 2, 3, 4, 5, 6]
 35 |         duration: 250
 36 |         
 37 | 
 38 | 
 39 |   - name: "Mushroom"
 40 | 
 41 |     xp: 75
 42 |     damage: 5
 43 |     health: 200
 44 |     speed: 15
 45 |     cooldown: 7500
 46 | 
 47 |     texture:
 48 |       path: "entities/enemies/Mushroom.png"
 49 |       tile_size: [150, 150]
 50 |       rows: 1
 51 |       columns: 8
 52 | 
 53 |     scale: [1, 1]
 54 |     hitbox: [20, 30]
 55 |     feet_offset: 20
 56 | 
 57 |     attack:
 58 |       type: "Melee"
 59 |       size: [40, 40]
 60 |       duration: 3.0
 61 |       knockback: 5.0
 62 | 
 63 |     animations:
 64 |       - name: "idle"
 65 |         frames: [0, 1, 2, 3, 4, 5, 6, 7]
 66 |         duration: 100
 67 | 
 68 | 
 69 |   - name: "Flying Eye"
 70 | 
 71 |     xp: 55
 72 |     damage: 15
 73 |     health: 60
 74 |     speed: 30
 75 |     cooldown: 6500
 76 | 
 77 |     texture:
 78 |       path: "entities/enemies/FlyingEye.png"
 79 |       tile_size: [150, 150]
 80 |       rows: 1
 81 |       columns: 8
 82 | 
 83 |     scale: [1.2, 1.2]
 84 |     hitbox: [20, 20]
 85 |     feet_offset: 20 
 86 | 
 87 |     attack:
 88 |       type: "Ranged"
 89 |       size: [100, 20]
 90 |       velocity: 70
 91 |       duration: 3.0
 92 |       texture:
 93 |         path: "arrow.png"
 94 |         tile_size: [100, 100]
 95 |         rows: 5
 96 |         columns: 6
 97 |         animation_duration: 100
 98 | 
 99 |     animations:
100 |       - name: "idle"
101 |         frames: [0, 1, 2, 3, 4, 5, 6]
102 |         duration: 100
103 | 


--------------------------------------------------------------------------------
/src/manifest/player.rs:
--------------------------------------------------------------------------------
  1 | use std::convert::Infallible;
  2 | 
  3 | use bevy::{
  4 |     asset::{Asset, Handle},
  5 |     ecs::system::Resource,
  6 |     math::Vec2,
  7 |     reflect::TypePath,
  8 |     render::texture::Image,
  9 |     sprite::TextureAtlasLayout,
 10 | };
 11 | 
 12 | use leafwing_manifest::manifest::{Manifest, ManifestFormat};
 13 | use serde::{Deserialize, Serialize};
 14 | 
 15 | use crate::animation::DirectionalAnimations;
 16 | 
 17 | use super::{
 18 |     load_directional_animations, load_texture_data, RawDirectionalAnimationData, RawTextureData,
 19 | };
 20 | 
 21 | #[derive(Debug, Serialize, Deserialize, PartialEq)]
 22 | pub struct RawPlayerData {
 23 |     size: Vec2,
 24 |     health: u32,
 25 |     damage: u32,
 26 |     speed: u32,
 27 |     cooldown: u32,
 28 |     xp: u32,
 29 |     base_xp: u32,
 30 |     xp_multiplier: f32,
 31 |     hitbox: Vec2,
 32 |     feet_offset: Option<f32>,
 33 |     texture: RawTextureData,
 34 |     animations: Vec<RawDirectionalAnimationData>,
 35 | }
 36 | 
 37 | #[derive(Debug, PartialEq)]
 38 | pub struct PlayerData {
 39 |     pub size: Vec2,
 40 |     pub health: u32,
 41 |     pub damage: u32,
 42 |     pub speed: u32,
 43 |     pub cooldown: u32,
 44 |     pub xp: u32,
 45 |     pub base_xp: u32,
 46 |     pub xp_multiplier: f32,
 47 |     pub hitbox: Vec2,
 48 |     pub feet_offset: Option<f32>,
 49 |     pub texture: Handle<Image>,
 50 |     pub atlas: Handle<TextureAtlasLayout>,
 51 |     pub animations: DirectionalAnimations,
 52 | }
 53 | 
 54 | #[derive(Debug, Asset, TypePath, Serialize, Deserialize, PartialEq)]
 55 | pub struct RawPlayerManifest(RawPlayerData);
 56 | 
 57 | #[derive(Debug, Resource, PartialEq)]
 58 | pub struct PlayerManifest {
 59 |     pub player_data: PlayerData,
 60 | }
 61 | 
 62 | impl Manifest for PlayerManifest {
 63 |     type RawManifest = RawPlayerManifest;
 64 | 
 65 |     type RawItem = RawPlayerData;
 66 | 
 67 |     type Item = PlayerData;
 68 | 
 69 |     type ConversionError = Infallible;
 70 | 
 71 |     const FORMAT: ManifestFormat = ManifestFormat::Yaml;
 72 | 
 73 |     fn from_raw_manifest(
 74 |         raw_manifest: Self::RawManifest,
 75 |         world: &mut bevy::prelude::World,
 76 |     ) -> Result<Self, Self::ConversionError> {
 77 |         let raw_data = raw_manifest.0;
 78 | 
 79 |         let (texture, atlas) = load_texture_data(&raw_data.texture, world);
 80 | 
 81 |         let player_data = PlayerData {
 82 |             size: raw_data.size,
 83 |             health: raw_data.health,
 84 |             damage: raw_data.damage,
 85 |             speed: raw_data.speed,
 86 |             cooldown: raw_data.cooldown,
 87 |             xp: raw_data.xp,
 88 |             base_xp: raw_data.base_xp,
 89 |             xp_multiplier: raw_data.xp_multiplier,
 90 |             hitbox: raw_data.hitbox,
 91 |             feet_offset: raw_data.feet_offset,
 92 |             texture,
 93 |             atlas,
 94 |             animations: load_directional_animations(&raw_data.animations, world),
 95 |         };
 96 | 
 97 |         Ok(PlayerManifest { player_data })
 98 |     }
 99 | 
100 |     fn get(&self, _id: leafwing_manifest::identifier::Id<Self::Item>) -> Option<&Self::Item> {
101 |         Some(&self.player_data)
102 |     }
103 | }
104 | 


--------------------------------------------------------------------------------
/src/manifest/boss.rs:
--------------------------------------------------------------------------------
  1 | use std::convert::Infallible;
  2 | 
  3 | use bevy::{
  4 |     asset::{Asset, Handle},
  5 |     math::Vec2,
  6 |     prelude::{Image, Resource},
  7 |     reflect::TypePath,
  8 |     sprite::TextureAtlasLayout,
  9 |     utils::HashMap,
 10 | };
 11 | use leafwing_manifest::{
 12 |     identifier::Id,
 13 |     manifest::{Manifest, ManifestFormat},
 14 | };
 15 | use serde::{Deserialize, Serialize};
 16 | 
 17 | use crate::animation::Animations;
 18 | 
 19 | use super::{load_animations, load_texture_data, RawAnimationData, RawTextureData};
 20 | 
 21 | #[derive(Debug, Deserialize, Serialize, PartialEq)]
 22 | pub struct RawBossData {
 23 |     name: String,
 24 |     health: u32,
 25 |     damage: u32,
 26 |     speed: u32,
 27 |     xp: u32,
 28 |     hitbox: Vec2,
 29 |     scale: Vec2,
 30 |     feet_offset: Option<f32>,
 31 |     texture: RawTextureData,
 32 |     animations: Vec<RawAnimationData>,
 33 | }
 34 | 
 35 | #[derive(Debug, PartialEq)]
 36 | pub struct BossData {
 37 |     pub name: String,
 38 |     pub health: u32,
 39 |     pub damage: u32,
 40 |     pub speed: u32,
 41 |     pub xp: u32,
 42 |     pub hitbox: Vec2,
 43 |     pub scale: Vec2,
 44 |     pub feet_offset: Option<f32>,
 45 |     pub texture: Handle<Image>,
 46 |     pub atlas: Handle<TextureAtlasLayout>,
 47 |     pub animations: Animations,
 48 | }
 49 | 
 50 | #[derive(Debug, Asset, TypePath, Serialize, Deserialize, PartialEq)]
 51 | pub struct RawBossManifest {
 52 |     bosses: Vec<RawBossData>,
 53 | }
 54 | 
 55 | #[derive(Debug, Resource)]
 56 | pub struct BossManifest {
 57 |     pub bosses: HashMap<Id<BossData>, BossData>,
 58 | }
 59 | 
 60 | impl Manifest for BossManifest {
 61 |     type Item = BossData;
 62 |     type RawItem = RawBossData;
 63 |     type RawManifest = RawBossManifest;
 64 | 
 65 |     type ConversionError = Infallible;
 66 | 
 67 |     const FORMAT: ManifestFormat = ManifestFormat::Yaml;
 68 | 
 69 |     fn from_raw_manifest(
 70 |         raw_manifest: Self::RawManifest,
 71 |         world: &mut bevy::prelude::World,
 72 |     ) -> Result<Self, Self::ConversionError> {
 73 |         let bosses = raw_manifest
 74 |             .bosses
 75 |             .iter()
 76 |             .map(|raw_boss| {
 77 |                 let (texture, atlas) = load_texture_data(&raw_boss.texture, world);
 78 |                 let animations = load_animations(&raw_boss.name, &raw_boss.animations, world);
 79 | 
 80 |                 let enemy_data = BossData {
 81 |                     name: raw_boss.name.clone(),
 82 |                     health: raw_boss.health,
 83 |                     damage: raw_boss.damage,
 84 |                     speed: raw_boss.speed,
 85 |                     xp: raw_boss.xp,
 86 |                     hitbox: raw_boss.hitbox,
 87 |                     scale: raw_boss.scale,
 88 |                     feet_offset: raw_boss.feet_offset,
 89 |                     texture,
 90 |                     atlas,
 91 |                     animations,
 92 |                 };
 93 | 
 94 |                 (Id::from_name(raw_boss.name.as_str()), enemy_data)
 95 |             })
 96 |             .collect();
 97 | 
 98 |         Ok(BossManifest { bosses })
 99 |     }
100 | 
101 |     fn get(&self, id: Id<Self::Item>) -> Option<&Self::Item> {
102 |         self.bosses.get(&id)
103 |     }
104 | }
105 | 


--------------------------------------------------------------------------------
/src/boss.rs:
--------------------------------------------------------------------------------
 1 | use crate::{
 2 |     animation::Animations,
 3 |     attack::Damageable,
 4 |     collision::BodyLayers,
 5 |     effects::Shadow,
 6 |     enemy::state_machine,
 7 |     manifest::boss::BossData,
 8 |     sorting::{self, FeetOffset, YSort},
 9 |     stats::StatsBundle,
10 |     Cooldown, Damage, Health, MovementSpeed, XP,
11 | };
12 | use bevy::{
13 |     math::Vec3,
14 |     prelude::{default, Bundle, Component, Transform},
15 |     sprite::{SpriteBundle, TextureAtlas},
16 | };
17 | use bevy_rapier2d::prelude::{ActiveEvents, Collider, CollisionGroups, RigidBody};
18 | use bevy_spritesheet_animation::prelude::SpritesheetAnimation;
19 | use seldom_state::prelude::StateMachine;
20 | 
21 | #[derive(Component)]
22 | pub struct Boss(pub String);
23 | 
24 | #[derive(Bundle)]
25 | pub struct BossBundle {
26 |     boss: Boss,
27 |     stats: StatsBundle,
28 |     damageable: Damageable,
29 | 
30 |     state_matchine: StateMachine,
31 | 
32 |     //Sprite
33 |     ysort: YSort,
34 |     shadow: Shadow,
35 |     sprite: SpriteBundle,
36 |     atlas: TextureAtlas,
37 |     animation: SpritesheetAnimation,
38 |     animations: Animations,
39 |     feet_offset: FeetOffset,
40 | 
41 |     //Physics
42 |     collider: Collider,
43 |     rigid_body: RigidBody,
44 |     active_events: ActiveEvents,
45 |     collision_groups: CollisionGroups,
46 | }
47 | 
48 | impl BossBundle {
49 |     pub fn new(data: &BossData, translation: Vec3) -> Self {
50 |         Self {
51 |             boss: Boss(data.name.clone()),
52 | 
53 |             //TODO: Extract this
54 |             stats: StatsBundle {
55 |                 health: Health::new(data.health),
56 |                 damage: Damage::new(data.damage),
57 |                 speed: MovementSpeed::new(data.speed),
58 |                 xp: XP::new(data.xp),
59 |                 cooldown: Cooldown::new(0), //Check this
60 |             },
61 |             damageable: Damageable,
62 | 
63 |             ysort: YSort(sorting::ENTITIES_LAYER),
64 |             shadow: Shadow,
65 | 
66 |             //TODO: Extract this
67 |             sprite: SpriteBundle {
68 |                 texture: data.texture.clone(),
69 |                 transform: Transform {
70 |                     translation,
71 |                     scale: data.scale.extend(1.),
72 |                     ..default()
73 |                 },
74 |                 ..default()
75 |             },
76 |             atlas: TextureAtlas {
77 |                 layout: data.atlas.clone(),
78 |                 index: 0,
79 |             },
80 |             animation: SpritesheetAnimation::from_id(
81 |                 *data
82 |                     .animations
83 |                     .0
84 |                     .get("idle")
85 |                     .expect(format!("No idle animation for {}", data.name).as_str()),
86 |             ),
87 |             animations: data.animations.clone(),
88 |             feet_offset: FeetOffset(data.feet_offset.unwrap_or_default()),
89 | 
90 |             rigid_body: RigidBody::KinematicPositionBased,
91 |             collider: Collider::cuboid(data.hitbox.x / 2., data.hitbox.y / 2.),
92 |             collision_groups: CollisionGroups::new(BodyLayers::ENEMY, BodyLayers::PLAYER_ATTACK),
93 |             active_events: ActiveEvents::COLLISION_EVENTS,
94 | 
95 |             state_matchine: state_machine::get_state_machine(),
96 |         }
97 |     }
98 | }
99 | 


--------------------------------------------------------------------------------
/src/map/walkable.rs:
--------------------------------------------------------------------------------
 1 | use bevy::math::Vec3Swizzles;
 2 | use bevy::prelude::{Component, EventWriter, Local, Query, Res, Time, Transform, Vec2, With};
 3 | use bevy_ecs_tilemap::{
 4 |     prelude::{TilemapGridSize, TilemapSize, TilemapType},
 5 |     tiles::{TilePos, TileStorage},
 6 | };
 7 | 
 8 | use crate::floor::TriggerNextFloorEvent;
 9 | use crate::map::generation::LevelPortalTile;
10 | use crate::{controller::Controlled, state::State};
11 | 
12 | #[derive(Component)]
13 | pub struct WalkableTile;
14 | 
15 | pub fn restrict_movement(
16 |     mut controlled_query: Query<(&Controlled, &mut Transform, Option<&State>)>,
17 |     query: Query<(&TileStorage, &TilemapType, &TilemapSize, &TilemapGridSize)>,
18 |     walkable_tiles_query: Query<&WalkableTile>,
19 | ) {
20 |     if let Some((tile_storage, tilemap_type, map_size, grid_size)) = query.iter().next() {
21 |         for (controlled, mut transform, state) in controlled_query.iter_mut() {
22 |             if let Some(move_to) = controlled.move_to {
23 |                 let grid_pos = move_to + Vec2::new(0., -16.); //Account for the tile being 32x32 on a
24 |                                                               //32x16 grid
25 | 
26 |                 if let Some(tile_pos) =
27 |                     TilePos::from_world_pos(&grid_pos, map_size, grid_size, tilemap_type)
28 |                 {
29 |                     //Don't move if the player doesn't want to move
30 |                     if let Some(state) = state {
31 |                         if !state.equals(State::Walking) {
32 |                             continue;
33 |                         }
34 |                     }
35 | 
36 |                     if let Some(tile_entity) = tile_storage.get(&tile_pos) {
37 |                         if walkable_tiles_query.get(tile_entity).is_ok() {
38 |                             transform.translation = move_to.extend(transform.translation.z);
39 |                         }
40 |                     }
41 |                 }
42 |             }
43 |         }
44 |     }
45 | }
46 | 
47 | pub fn travel_through_portal(
48 |     controlled_query: Query<&Transform, With<Controlled>>,
49 |     query: Query<(&TileStorage, &TilemapType, &TilemapSize, &TilemapGridSize)>,
50 |     portal_query: Query<&LevelPortalTile>,
51 |     mut timer: Local<f32>,
52 |     delta: Res<Time>,
53 |     mut level_writer: EventWriter<TriggerNextFloorEvent>,
54 | ) {
55 |     if let Some((tile_storage, tilemap_type, map_size, grid_size)) = query.iter().next() {
56 |         for transform in controlled_query.iter() {
57 |             let pos = transform.translation.xy() + Vec2::new(0., -16.); //Account for the tile being 32x32 on a
58 |                                                                         //32x16 grid
59 |             if let Some(tile_pos) = TilePos::from_world_pos(&pos, map_size, grid_size, tilemap_type)
60 |             {
61 |                 if let Some(tile_entity) = tile_storage.get(&tile_pos) {
62 |                     if portal_query.get(tile_entity).is_ok() {
63 |                         *timer += delta.delta_seconds();
64 | 
65 |                         if *timer > 3. {
66 |                             *timer = 0.0;
67 |                             level_writer.send(TriggerNextFloorEvent);
68 |                         }
69 |                     }
70 |                 }
71 |             }
72 |         }
73 |     }
74 | }
75 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Relentless Revenge
 2 | 
 3 | This is a modified Markdown file of my notion notes.
 4 | 
 5 | # Theme notes
 6 | 
 7 | Player is an agile {BLANK CHARACTER} that leaps around using daggers and emits lightning
 8 | 
 9 | He evolves taking bosses skills and becomes strong with each kill (should be represented with color)
10 | 
11 | - Maybe he should suck the boss into him becoming stronger and darker
12 | 
13 | {BIG FINAL BOSS} drags us into {DEFINE PLACE} where he throws at different platforms full of enemies.
14 | We have to fight our way through them to reach him by defeating the bosses of each platform.
15 | After killing the boss the ground gets magicly destroyed and we fall into the next platform.
16 | 
17 | {BIG FINAL BOSS} is scared of the player potential and tries to kill him before he becomes too strong, but in doing so it only feeds his power and he becomes stronger and stronger and now is coming for revenge.
18 | 
19 | x MISSING THEME STYLE AND WHAT MONSTERS ARE AND WHY THE PLAYER IS FIGHTING THEM
20 | 
21 | # Name ideas
22 | 
23 | - *Something* Revenge
24 |     - ✅ Relentless
25 |     - Unstoppable
26 |     - Inescapable
27 | 
28 | # Mechanics notes
29 | 
30 | - Combat should be smooth and quick with increasing speed through level
31 | - We have to fight our way through the platforms to reach the boss
32 | - Levels should be procedurally generated with open spaces
33 | - There should be a dash effects that maybe locks on targets (prevent unwanted ones)
34 | - Later on the ability to attack mid dash should be obtained
35 |   ? Figure out wheter to use JKL keys or the mouse (maybe both)
36 |   ? How should health be displayed (healthbars and/or damage counters) or even show at all
37 | - There should be leveling of different stats like hp, speed, dash-speed, etc.
38 | - A skill where you can reflect an incoming projectile (not by attacking it)
39 | 
40 | # Art Notes
41 | 
42 | - Assets should be isometric style if possible
43 | - Sprites should be around 16x16
44 | - Enemies should be larger than the player (especially bosses)
45 | - Color scheme should be a bit more to dark and colder colors
46 | - Dash and attack animations should be smooth with trailing effects
47 |   ? Hit effects should be a white overlay (or red)
48 | - There should be parallax particles all around and some always moving
49 | - Main character should have different versions with different lightnigh color and entinsity
50 | - Idle animation should be a tired slow breathing up-and-down, with head and daggers lowered
51 | - The screen should flash when the player is low hp
52 | - Transition each level through a slide up dithering effect
53 | 
54 | # Sound Notes
55 | 
56 | - Attack should be swift and faded (should use wind as a base)
57 | - Try to go for a pixel arty style but without sounding 8 bitty
58 | 
59 | # References
60 | 
61 | - Player mechanis and feel (Solo leveling)
62 | - Map and enemies (Quadropus Rampage)
63 | 
64 | # Similar Games Found
65 | 
66 | ## Children of Morta
67 | 
68 | - Attacks only move the player when pressing a movement key and at the same time as the slash comes out
69 | - Has a skill tree
70 | 
71 | ## Wizard of Legend
72 | 
73 | - Spells lock the player in space but slashes move the player slightly to follow up combos
74 | - Speed effects could have a trailing after-image of the player
75 | - A lot of impact frames and interesting combos
76 | - Player attack direction is based on mouse (mixed feelings)


--------------------------------------------------------------------------------
/src/manifest/enemy.rs:
--------------------------------------------------------------------------------
  1 | use std::convert::Infallible;
  2 | 
  3 | use bevy::{
  4 |     asset::{Asset, Handle},
  5 |     ecs::system::Resource,
  6 |     math::Vec2,
  7 |     reflect::TypePath,
  8 |     render::texture::Image,
  9 |     sprite::TextureAtlasLayout,
 10 |     utils::HashMap,
 11 | };
 12 | use bevy_spritesheet_animation::prelude::AnimationId;
 13 | use leafwing_manifest::{
 14 |     identifier::Id,
 15 |     manifest::{Manifest, ManifestFormat},
 16 | };
 17 | use serde::{Deserialize, Serialize};
 18 | 
 19 | use crate::animation::Animations;
 20 | 
 21 | use super::{
 22 |     load_animations, load_attack_data, load_texture_data, AttackData, RawAnimationData,
 23 |     RawAttackData, RawTextureData,
 24 | };
 25 | 
 26 | #[derive(Debug, Deserialize, Serialize, PartialEq)]
 27 | pub struct RawEnemyData {
 28 |     name: String,
 29 |     health: u32,
 30 |     damage: u32,
 31 |     speed: u32,
 32 |     cooldown: u32,
 33 |     xp: u32,
 34 |     hitbox: Vec2,
 35 |     scale: Vec2,
 36 |     feet_offset: Option<f32>,
 37 |     attack: RawAttackData,
 38 |     texture: RawTextureData,
 39 |     animations: Vec<RawAnimationData>,
 40 | }
 41 | 
 42 | #[derive(Debug, PartialEq)]
 43 | pub struct EnemyData {
 44 |     pub name: String,
 45 |     pub health: u32,
 46 |     pub damage: u32,
 47 |     pub speed: u32,
 48 |     pub cooldown: u32,
 49 |     pub xp: u32,
 50 |     pub hitbox: Vec2,
 51 |     pub scale: Vec2,
 52 |     pub attack: AttackData,
 53 |     pub feet_offset: Option<f32>,
 54 |     pub texture: Handle<Image>,
 55 |     pub atlas: Handle<TextureAtlasLayout>,
 56 |     pub animations: Animations,
 57 | }
 58 | 
 59 | #[derive(Debug, Asset, TypePath, Serialize, Deserialize, PartialEq)]
 60 | pub struct RawEnemyManifest {
 61 |     enemies: Vec<RawEnemyData>,
 62 | }
 63 | 
 64 | #[derive(Debug, Resource, PartialEq)]
 65 | pub struct EnemyManifest {
 66 |     pub enemies: HashMap<Id<EnemyData>, EnemyData>,
 67 | }
 68 | 
 69 | impl Manifest for EnemyManifest {
 70 |     type Item = EnemyData;
 71 |     type RawItem = RawEnemyData;
 72 |     type RawManifest = RawEnemyManifest;
 73 | 
 74 |     type ConversionError = Infallible;
 75 | 
 76 |     const FORMAT: ManifestFormat = ManifestFormat::Yaml;
 77 | 
 78 |     fn from_raw_manifest(
 79 |         raw_manifest: Self::RawManifest,
 80 |         world: &mut bevy::prelude::World,
 81 |     ) -> Result<Self, Self::ConversionError> {
 82 |         let enemies = raw_manifest
 83 |             .enemies
 84 |             .iter()
 85 |             .map(|raw_enemy| {
 86 |                 let (texture, atlas) = load_texture_data(&raw_enemy.texture, world);
 87 | 
 88 |                 let enemy_data = EnemyData {
 89 |                     name: raw_enemy.name.clone(),
 90 |                     health: raw_enemy.health,
 91 |                     damage: raw_enemy.damage,
 92 |                     speed: raw_enemy.speed,
 93 |                     cooldown: raw_enemy.cooldown,
 94 |                     xp: raw_enemy.xp,
 95 |                     hitbox: raw_enemy.hitbox,
 96 |                     scale: raw_enemy.scale,
 97 |                     feet_offset: raw_enemy.feet_offset,
 98 |                     texture,
 99 |                     atlas,
100 |                     attack: load_attack_data(&raw_enemy.attack, world),
101 |                     animations: load_animations(&raw_enemy.name, &raw_enemy.animations, world),
102 |                 };
103 | 
104 |                 (Id::from_name(raw_enemy.name.as_str()), enemy_data)
105 |             })
106 |             .collect();
107 | 
108 |         Ok(EnemyManifest { enemies })
109 |     }
110 | 
111 |     fn get(&self, id: Id<Self::Item>) -> Option<&Self::Item> {
112 |         self.enemies.get(&id)
113 |     }
114 | }
115 | 


--------------------------------------------------------------------------------
/src/enemy.rs:
--------------------------------------------------------------------------------
  1 | use std::time::Duration;
  2 | 
  3 | use bevy::prelude::*;
  4 | use bevy_rapier2d::prelude::{
  5 |     ActiveCollisionTypes, ActiveEvents, Collider, CollisionGroups, RigidBody,
  6 | };
  7 | use bevy_spritesheet_animation::prelude::SpritesheetAnimation;
  8 | use seldom_state::prelude::StateMachine;
  9 | 
 10 | use crate::animation::Animations;
 11 | use crate::effects::Shadow;
 12 | use crate::manifest::enemy::EnemyData;
 13 | use crate::sorting::{self, FeetOffset, YSort};
 14 | use crate::{
 15 |     attack::Damageable,
 16 |     collision::BodyLayers,
 17 |     stats::{Cooldown, Damage, Health, MovementSpeed, StatsBundle, XP},
 18 | };
 19 | 
 20 | pub mod state_machine;
 21 | 
 22 | pub struct EnemyBehaviourPlugin;
 23 | 
 24 | impl Plugin for EnemyBehaviourPlugin {
 25 |     fn build(&self, app: &mut App) {
 26 |         state_machine::register(app);
 27 |     }
 28 | }
 29 | 
 30 | #[derive(Component)]
 31 | pub struct Enemy(String);
 32 | 
 33 | #[derive(Bundle)]
 34 | pub struct EnemyBundle {
 35 |     enemy: Enemy,
 36 |     pub sprite: SpriteBundle,
 37 |     pub atlas: TextureAtlas,
 38 |     pub stats: StatsBundle,
 39 |     pub damageable: Damageable,
 40 |     pub animations: Animations,
 41 |     pub animation: SpritesheetAnimation,
 42 |     pub rigid_body: RigidBody,
 43 |     pub collider: Collider,
 44 |     pub collision_groups: CollisionGroups,
 45 |     pub active_events: ActiveEvents,
 46 |     pub active_collision_types: ActiveCollisionTypes,
 47 |     pub ysort: YSort,
 48 |     pub shadow: Shadow,
 49 |     pub feet_offset: FeetOffset,
 50 |     // finding_player: FindingPLayer,
 51 |     state_machine: StateMachine,
 52 | }
 53 | 
 54 | impl EnemyBundle {
 55 |     pub fn new(data: &EnemyData, translation: Vec3) -> Self {
 56 |         Self {
 57 |             enemy: Enemy(data.name.clone()),
 58 |             atlas: TextureAtlas {
 59 |                 layout: data.atlas.clone(),
 60 |                 index: 0,
 61 |             },
 62 |             sprite: SpriteBundle {
 63 |                 texture: data.texture.clone(),
 64 |                 transform: Transform {
 65 |                     translation,
 66 |                     scale: data.scale.extend(1.),
 67 |                     ..default()
 68 |                 },
 69 |                 ..default()
 70 |             },
 71 |             stats: StatsBundle {
 72 |                 health: Health::new(data.health),
 73 |                 damage: Damage::new(data.damage),
 74 |                 speed: MovementSpeed::new(data.speed),
 75 |                 xp: XP::new(data.xp),
 76 |                 cooldown: Cooldown::new(data.cooldown),
 77 |             },
 78 |             damageable: Damageable,
 79 |             animation: SpritesheetAnimation::from_id(
 80 |                 *data
 81 |                     .animations
 82 |                     .0
 83 |                     .values()
 84 |                     .next()
 85 |                     .expect(format!("No animations for {}", data.name).as_str()),
 86 |             ),
 87 |             animations: data.animations.clone(),
 88 |             rigid_body: RigidBody::KinematicPositionBased,
 89 |             collider: Collider::cuboid(data.hitbox.x / 2., data.hitbox.y / 2.),
 90 |             collision_groups: CollisionGroups::new(BodyLayers::ENEMY, BodyLayers::PLAYER_ATTACK),
 91 |             active_events: ActiveEvents::COLLISION_EVENTS,
 92 |             active_collision_types: ActiveCollisionTypes::all(),
 93 |             state_machine: state_machine::get_state_machine(),
 94 |             ysort: YSort(sorting::ENTITIES_LAYER),
 95 |             feet_offset: FeetOffset(data.feet_offset.unwrap_or_default()),
 96 |             shadow: Shadow,
 97 |         }
 98 |     }
 99 | }
100 | 


--------------------------------------------------------------------------------
/src/helper.rs:
--------------------------------------------------------------------------------
  1 | use crate::movement::movement::Follow;
  2 | use bevy::input::ButtonInput;
  3 | use bevy::math::Vec3Swizzles;
  4 | use bevy::prelude::{
  5 |     Commands, Component, Entity, KeyCode, Query, Res, Resource, Time, Transform, With,
  6 | };
  7 | use bevy::render::camera::OrthographicProjection;
  8 | use noisy_bevy::fbm_simplex_2d_seeded;
  9 | 
 10 | #[derive(Component)]
 11 | pub struct Parallax;
 12 | 
 13 | #[derive(Component)]
 14 | pub struct Shake {
 15 |     pub strength: f32,
 16 |     pub duration: f32,
 17 | }
 18 | 
 19 | pub fn shake_system(
 20 |     mut commands: Commands,
 21 |     mut query: Query<(&mut Transform, &mut Shake, Entity)>,
 22 |     time: Res<Time>,
 23 | ) {
 24 |     //Move this a good spot
 25 |     const FREQUENCY_SCALE: f32 = 0.55;
 26 |     const OCTAVES: usize = 4;
 27 |     const LACUNARITY: f32 = 2.;
 28 |     const GAIN: f32 = 1.75;
 29 | 
 30 |     for (mut trans, mut shake, entity) in query.iter_mut() {
 31 |         if shake.duration > 0. {
 32 |             //let rand = Rng::new();
 33 | 
 34 |             let pos = trans.translation.xy();
 35 |             let x_offset = fbm_simplex_2d_seeded(
 36 |                 pos * FREQUENCY_SCALE,
 37 |                 OCTAVES,
 38 |                 LACUNARITY,
 39 |                 GAIN,
 40 |                 time.delta_seconds(),
 41 |             ) * shake.strength;
 42 | 
 43 |             let y_offset = fbm_simplex_2d_seeded(
 44 |                 pos * FREQUENCY_SCALE,
 45 |                 OCTAVES,
 46 |                 LACUNARITY,
 47 |                 GAIN,
 48 |                 time.delta_seconds() + 100.0,
 49 |             ) * shake.strength;
 50 | 
 51 |             let angle_offset = fbm_simplex_2d_seeded(
 52 |                 pos * FREQUENCY_SCALE,
 53 |                 OCTAVES,
 54 |                 LACUNARITY,
 55 |                 GAIN / 2.,
 56 |                 time.delta_seconds() + 50.,
 57 |             ) * shake.strength
 58 |                 / 200.;
 59 | 
 60 |             trans.translation.x += x_offset * time.delta_seconds();
 61 |             trans.translation.y += y_offset * time.delta_seconds();
 62 | 
 63 |             trans.rotate_z(angle_offset * time.delta_seconds());
 64 | 
 65 |             shake.duration -= time.delta_seconds();
 66 |         } else {
 67 |             commands.entity(entity).remove::<Shake>();
 68 |         }
 69 |     }
 70 | }
 71 | 
 72 | //Helper camera controller
 73 | pub fn helper_camera_controller(
 74 |     mut query: Query<(&mut OrthographicProjection, &mut Transform), With<Follow>>,
 75 |     keys: Res<ButtonInput<KeyCode>>,
 76 |     time: Res<Time>,
 77 | ) {
 78 |     if let Ok((mut projection, mut transform)) = query.get_single_mut() {
 79 |         if keys.pressed(KeyCode::ArrowUp) {
 80 |             transform.translation.y += 150.0 * time.delta_seconds();
 81 |         }
 82 |         if keys.pressed(KeyCode::ArrowLeft) {
 83 |             transform.translation.x -= 150.0 * time.delta_seconds();
 84 |         }
 85 |         if keys.pressed(KeyCode::ArrowDown) {
 86 |             transform.translation.y -= 150.0 * time.delta_seconds();
 87 |         }
 88 |         if keys.pressed(KeyCode::ArrowRight) {
 89 |             transform.translation.x += 150.0 * time.delta_seconds();
 90 |         }
 91 | 
 92 |         if keys.pressed(KeyCode::KeyZ) {
 93 |             projection.scale -= 1. * time.delta_seconds();
 94 |         }
 95 |         if keys.pressed(KeyCode::KeyX) {
 96 |             projection.scale += 1. * time.delta_seconds();
 97 |         }
 98 |     }
 99 | }
100 | 
101 | #[derive(Resource)]
102 | pub struct KeyMaps {
103 |     pub walk_up: KeyCode,
104 |     pub walk_left: KeyCode,
105 |     pub walk_down: KeyCode,
106 |     pub walk_right: KeyCode,
107 |     pub attack: KeyCode,
108 |     pub dash: KeyCode,
109 | }
110 | 
111 | impl Default for KeyMaps {
112 |     fn default() -> Self {
113 |         KeyMaps {
114 |             walk_up: KeyCode::KeyW,
115 |             walk_left: KeyCode::KeyA,
116 |             walk_down: KeyCode::KeyS,
117 |             walk_right: KeyCode::KeyD,
118 |             attack: KeyCode::KeyJ,
119 |             dash: KeyCode::Space,
120 |         }
121 |     }
122 | }
123 | 


--------------------------------------------------------------------------------
/src/movement/movement.rs:
--------------------------------------------------------------------------------
  1 | use crate::map::walkable::WalkableTile;
  2 | use crate::GameState;
  3 | use bevy::math::{Vec2, Vec3Swizzles};
  4 | use bevy::prelude::{
  5 |     in_state, App, Commands, Component, Entity, IntoSystemConfigs, Plugin, Query, Res, Time,
  6 |     Transform, Update,
  7 | };
  8 | use bevy_ecs_tilemap::map::{TilemapGridSize, TilemapSize, TilemapType};
  9 | use bevy_ecs_tilemap::prelude::{TilePos, TileStorage};
 10 | 
 11 | use super::easing::ease_to_position;
 12 | 
 13 | pub struct MovementPlugin;
 14 | 
 15 | impl Plugin for MovementPlugin {
 16 |     fn build(&self, app: &mut App) {
 17 |         app.add_systems(
 18 |             Update,
 19 |             (follow_entity_system, movement_system, ease_to_position)
 20 |                 .run_if(in_state(GameState::InGame)),
 21 |         );
 22 |     }
 23 | }
 24 | 
 25 | #[derive(Component)]
 26 | pub struct Follow {
 27 |     pub target: Entity,
 28 |     pub speed: f32,
 29 |     pub continuous: bool,
 30 |     pub threshold: f32,
 31 |     pub(crate) on_target: bool,
 32 | }
 33 | 
 34 | impl Follow {
 35 |     pub fn new(target: Entity, speed: f32, continuous: bool, threshold: f32) -> Self {
 36 |         Self {
 37 |             target,
 38 |             speed,
 39 |             continuous,
 40 |             threshold,
 41 |             on_target: false,
 42 |         }
 43 |     }
 44 | 
 45 |     /* pub fn on_target(self: &Self) -> bool {
 46 |         self.on_target
 47 |     } */
 48 | }
 49 | 
 50 | //System for an entity to follow another
 51 | pub fn follow_entity_system(
 52 |     mut commands: Commands,
 53 |     mut query_followers: Query<(&mut Follow, Entity)>,
 54 |     mut transform_query: Query<&mut Transform>,
 55 |     time: Res<Time>,
 56 | ) {
 57 |     for (mut follow, entity) in query_followers.iter_mut() {
 58 |         let pos: Vec2 = if let Ok(transform) = transform_query.get_mut(follow.target) {
 59 |             transform.translation.xy()
 60 |         } else {
 61 |             //Entity was removed or does not exist
 62 |             commands.entity(entity).remove::<Follow>();
 63 |             continue;
 64 |         };
 65 | 
 66 |         if let Ok(mut transform) = transform_query.get_mut(entity) {
 67 |             //TODO: Check distance threshold (This was added because of Changed<>)
 68 |             if transform.translation.xy().distance(pos) > follow.threshold {
 69 |                 transform.translation = transform
 70 |                     .translation
 71 |                     .xy()
 72 |                     .lerp(pos, follow.speed * time.delta_seconds())
 73 |                     .extend(transform.translation.z);
 74 | 
 75 |                 follow.on_target = false;
 76 |             } else {
 77 |                 follow.on_target = true;
 78 | 
 79 |                 if !follow.continuous {
 80 |                     commands.entity(entity).remove::<Follow>();
 81 |                 }
 82 |             }
 83 |         }
 84 |     }
 85 | }
 86 | 
 87 | #[derive(Component)]
 88 | pub struct Velocity(pub Vec2, pub bool);
 89 | 
 90 | pub fn movement_system(
 91 |     mut query_velocity: Query<(&Velocity, &mut Transform)>,
 92 |     tile_query: Query<(&TileStorage, &TilemapType, &TilemapSize, &TilemapGridSize)>,
 93 |     walkable_tiles_query: Query<&WalkableTile>,
 94 |     time: Res<Time>,
 95 | ) {
 96 |     for (velocity, mut transform) in query_velocity.iter_mut() {
 97 |         let new_pos = transform.translation + velocity.0.extend(0.) * time.delta_seconds();
 98 | 
 99 |         if !velocity.1 {
100 |             //If not restricted to walkable tiles
101 |             transform.translation = new_pos;
102 |             continue;
103 |         }
104 | 
105 |         if let Some((tile_storage, tilemap_type, map_size, grid_size)) = tile_query.iter().next() {
106 |             if let Some(tile_pos) =
107 |                 TilePos::from_world_pos(&new_pos.xy(), map_size, grid_size, tilemap_type)
108 |             {
109 |                 if let Some(tile_entity) = tile_storage.get(&tile_pos) {
110 |                     if walkable_tiles_query.get(tile_entity).is_ok() {
111 |                         transform.translation = new_pos;
112 |                     }
113 |                 }
114 |             }
115 |         }
116 |     }
117 | }
118 | 


--------------------------------------------------------------------------------
/src/game_states/ingame.rs:
--------------------------------------------------------------------------------
  1 | use bevy::prelude::*;
  2 | use bevy_ecs_tilemap::TilemapPlugin;
  3 | use bevy_persistent::prelude::*;
  4 | use leafwing_input_manager::prelude::InputManagerPlugin;
  5 | 
  6 | use crate::attack::{
  7 |     attack_phase_system, attack_spawner, charge_phase_system, recover_phase_system,
  8 |     SpawnEnemyAttack,
  9 | };
 10 | use crate::controller::combo_system;
 11 | use crate::effects::spawn_shadows;
 12 | use crate::game_states::ingame::InGameSet::{Normal, Post};
 13 | use crate::manifest::player::PlayerManifest;
 14 | use crate::sorting::ysort;
 15 | use crate::stats::{level_up, revenge_mode};
 16 | use crate::ui::boss::draw_domain_name;
 17 | use crate::ui::player::{draw_hud, draw_revenge_bar, draw_xp_bar};
 18 | use crate::{
 19 |     animation::AnimationPlugin,
 20 |     attack::{lifetimes, projectile_break, tick_cooldown},
 21 |     collision::CollisionPlugin,
 22 |     controller::{attack_ability, dash_ability, finish_dash, move_player},
 23 |     enemy::EnemyBehaviourPlugin,
 24 |     floor::FloorPlugin,
 25 |     helper::{helper_camera_controller, shake_system},
 26 |     map::{
 27 |         generation::{remake_map, setup_map},
 28 |         walkable::restrict_movement,
 29 |     },
 30 |     movement::movement::{Follow, MovementPlugin},
 31 |     player::{PlayerActions, PlayerBundle},
 32 |     statistics::{auto_save, statistics, Statistics},
 33 |     stats::{death_system, drop_xp_system},
 34 |     GameState,
 35 | };
 36 | 
 37 | pub struct InGamePlugin;
 38 | 
 39 | //TODO: Refactor this to something meaningful
 40 | #[derive(Debug, Hash, PartialEq, Eq, Clone, SystemSet)]
 41 | enum InGameSet {
 42 |     Normal,
 43 |     Post,
 44 | }
 45 | 
 46 | impl Plugin for InGamePlugin {
 47 |     fn build(&self, app: &mut App) {
 48 |         app.add_plugins(TilemapPlugin)
 49 |             .add_plugins(InputManagerPlugin::<PlayerActions>::default())
 50 |             .add_plugins(CollisionPlugin)
 51 |             .add_plugins(AnimationPlugin)
 52 |             .add_plugins(EnemyBehaviourPlugin)
 53 |             .add_plugins(FloorPlugin)
 54 |             .add_plugins(MovementPlugin)
 55 |             .add_event::<SpawnEnemyAttack>() //TODO: Add attack plugin
 56 |             .add_systems(
 57 |                 Update,
 58 |                 (auto_save, statistics).run_if(in_state(GameState::InGame)),
 59 |             )
 60 |             .add_systems(OnEnter(GameState::InGame), (setup_game, setup_map))
 61 |             //TODO: Check system ordering and optimize it
 62 |             .add_systems(
 63 |                 Update,
 64 |                 (draw_hud, draw_domain_name, draw_xp_bar, draw_revenge_bar)
 65 |                     .in_set(Normal)
 66 |                     .run_if(in_state(GameState::InGame)),
 67 |             )
 68 |             .add_systems(
 69 |                 Update,
 70 |                 (
 71 |                     helper_camera_controller,
 72 |                     move_player,
 73 |                     dash_ability,
 74 |                     attack_ability,
 75 |                     attack_spawner,
 76 |                     combo_system,
 77 |                     tick_cooldown,
 78 |                     shake_system,
 79 |                     remake_map,
 80 |                     lifetimes,
 81 |                     projectile_break,
 82 |                     drop_xp_system,
 83 |                     level_up,
 84 |                     revenge_mode,
 85 |                     charge_phase_system,
 86 |                     attack_phase_system,
 87 |                     recover_phase_system,
 88 |                 )
 89 |                     .in_set(Normal)
 90 |                     .run_if(in_state(GameState::InGame)),
 91 |             )
 92 |             .add_systems(
 93 |                 Update,
 94 |                 (
 95 |                     spawn_shadows,
 96 |                     restrict_movement,
 97 |                     finish_dash,
 98 |                     death_system,
 99 |                     ysort,
100 |                 )
101 |                     .in_set(Post)
102 |                     .after(Normal)
103 |                     .run_if(in_state(GameState::InGame)),
104 |             );
105 |     }
106 | }
107 | 
108 | fn setup_game(mut commands: Commands, player_manifest: Res<PlayerManifest>) {
109 |     let dir = dirs::data_dir().unwrap().join("relentless_revenge");
110 | 
111 |     commands.insert_resource(
112 |         Persistent::<Statistics>::builder()
113 |             .name("statistics")
114 |             .format(StorageFormat::Bincode)
115 |             .path(dir.join("statistic.bin"))
116 |             .default(Statistics::default())
117 |             .build()
118 |             .expect("Failed to create persistent statistics"),
119 |     );
120 | 
121 |     let player_data = &player_manifest.player_data;
122 |     let player_entity = commands.spawn(PlayerBundle::new(&player_data)).id();
123 | 
124 |     //Add Camera after so we can give it the player entity
125 |     let mut camera_bundle = Camera2dBundle::default();
126 |     camera_bundle.projection.scale = 0.25;
127 | 
128 |     commands.spawn((camera_bundle, Follow::new(player_entity, 2.5, true, 2.)));
129 | }
130 | 


--------------------------------------------------------------------------------
/src/map/generation.rs:
--------------------------------------------------------------------------------
  1 | use bevy::prelude::*;
  2 | use bevy_ecs_tilemap::prelude::*;
  3 | 
  4 | use crate::floor::{FloorClearedEvent, FloorResource, GenerateFloorEvent, SpawnFloorEntitiesEvent};
  5 | 
  6 | use crate::game_states::loading::GameAssets;
  7 | use crate::map::map::generate_map;
  8 | use crate::map::map::Tile;
  9 | use crate::map::map::TileVariant;
 10 | use crate::map::walkable::WalkableTile;
 11 | 
 12 | #[derive(Component)]
 13 | pub struct LevelStartTile;
 14 | 
 15 | #[derive(Component)]
 16 | pub struct LevelPortalTile;
 17 | 
 18 | pub fn setup_map(mut commands: Commands, game_assets: Res<GameAssets>) {
 19 |     let tilemap_size = TilemapSize { x: 160, y: 160 };
 20 |     let mut tile_storage = TileStorage::empty(tilemap_size);
 21 |     let tilemap_entity = commands.spawn_empty().id();
 22 |     let tilemap_id = TilemapId(tilemap_entity);
 23 | 
 24 |     let tile_size = TilemapTileSize { x: 32.0, y: 32.0 };
 25 |     let grid_size = TilemapGridSize { x: 32.0, y: 16.0 };
 26 | 
 27 |     fill_tilemap(
 28 |         TileTextureIndex(8),
 29 |         tilemap_size,
 30 |         tilemap_id,
 31 |         &mut commands,
 32 |         &mut tile_storage,
 33 |     );
 34 | 
 35 |     commands.entity(tilemap_entity).insert(TilemapBundle {
 36 |         grid_size,
 37 |         size: tilemap_size,
 38 |         storage: tile_storage,
 39 |         texture: TilemapTexture::Single(game_assets.map_texture.clone()),
 40 |         tile_size,
 41 |         map_type: TilemapType::Isometric(IsoCoordSystem::Diamond),
 42 |         render_settings: TilemapRenderSettings {
 43 |             render_chunk_size: UVec2::new(32, 1),
 44 |             y_sort: true,
 45 |         },
 46 |         ..Default::default()
 47 |     });
 48 | }
 49 | 
 50 | pub fn remake_map(
 51 |     mut event: EventReader<GenerateFloorEvent>,
 52 |     mut tile_query: Query<(Entity, &mut TileTextureIndex)>,
 53 |     tile_storage_query: Query<&TileStorage>,
 54 |     mut spawn_writer: EventWriter<SpawnFloorEntitiesEvent>,
 55 |     mut commands: Commands,
 56 |     floor: Res<FloorResource>,
 57 | ) {
 58 |     if let Some(domain_data) = &floor.domain {
 59 |         for _ in event.read() {
 60 |             //Change all tiles to clear texture
 61 |             for (entity, mut tile) in tile_query.iter_mut() {
 62 |                 tile.0 = 8;
 63 |                 //TODO: Check if it's better to remove all the tiles and then add them back
 64 |                 commands.entity(entity).remove::<WalkableTile>();
 65 |                 commands.entity(entity).remove::<LevelStartTile>();
 66 |                 commands.entity(entity).remove::<LevelPortalTile>();
 67 |             }
 68 | 
 69 |             if let Ok(tile_storage) = tile_storage_query.get_single() {
 70 |                 let map = generate_map(domain_data);
 71 |                 let tiles: Vec<Tile> = map.into();
 72 |                 let spawn_event = build_map(tiles, &mut tile_query, tile_storage, &mut commands);
 73 | 
 74 |                 spawn_writer.send(spawn_event);
 75 |             }
 76 |         }
 77 |     }
 78 | }
 79 | 
 80 | fn build_map(
 81 |     tiles: Vec<Tile>,
 82 |     tile_query: &mut Query<(Entity, &mut TileTextureIndex)>,
 83 |     tile_storage: &TileStorage,
 84 |     commands: &mut Commands,
 85 | ) -> SpawnFloorEntitiesEvent {
 86 |     let mut player_pos = Vec2::ZERO;
 87 |     let mut spawnable_pos = Vec::new();
 88 |     let mut portal_pos = Vec2::ZERO;
 89 | 
 90 |     for tile in &tiles {
 91 |         let tile_pos = TilePos {
 92 |             x: tile.pos.x as u32,
 93 |             y: tile.pos.y as u32,
 94 |         };
 95 | 
 96 |         //TODO: Get the grid-size and map type from the current map
 97 |         let world_pos = tile_pos.center_in_world(
 98 |             &TilemapGridSize { x: 32., y: 16. },
 99 |             &TilemapType::Isometric(IsoCoordSystem::Diamond),
100 |         );
101 | 
102 |         //TODO: Build room using neighbors
103 |         if let Some(tile_entity) = tile_storage.get(&tile_pos) {
104 |             let mut ec = commands.entity(tile_entity);
105 | 
106 |             if let Ok((_, mut tile_texture)) = tile_query.get_mut(tile_entity) {
107 |                 tile_texture.0 = match tile.variant {
108 |                     TileVariant::Standard => 2,
109 |                     TileVariant::Accented => 0,
110 |                 };
111 |             }
112 | 
113 |             if tile.spawnable {
114 |                 spawnable_pos.push(world_pos);
115 |             }
116 | 
117 |             if tile.walkable {
118 |                 ec.insert(WalkableTile);
119 |             }
120 | 
121 |             if tile.is_center {
122 |                 if tile.firt_room {
123 |                     ec.insert(LevelStartTile);
124 |                     player_pos = world_pos;
125 |                 } else if tile.last_room {
126 |                     ec.insert(LevelPortalTile);
127 |                     portal_pos = world_pos;
128 |                 }
129 |             }
130 |         }
131 |     }
132 | 
133 |     SpawnFloorEntitiesEvent {
134 |         spawnable_pos,
135 |         player_pos,
136 |         portal_pos,
137 |     }
138 | }
139 | 
140 | pub fn open_level_portal(
141 |     mut events: EventReader<FloorClearedEvent>,
142 |     mut tile_query: Query<&mut TileTextureIndex, With<LevelPortalTile>>,
143 | ) {
144 |     if !events.is_empty() {
145 |         for mut tile in tile_query.iter_mut() {
146 |             tile.0 = 4;
147 |         }
148 | 
149 |         events.clear();
150 |     }
151 | }
152 | 


--------------------------------------------------------------------------------
/src/map/map.rs:
--------------------------------------------------------------------------------
  1 | use bevy::prelude::{IVec2, Vec2};
  2 | use turborand::{rng::Rng, TurboRand};
  3 | 
  4 | use crate::{manifest::floor::DomainData, movement::direction::Direction};
  5 | 
  6 | #[derive(Clone, Debug, PartialEq)]
  7 | pub struct Room {
  8 |     pub pos: IVec2,
  9 |     pub radius: i32,
 10 | }
 11 | 
 12 | impl Room {
 13 |     pub fn new(pos: IVec2, radius: i32) -> Self {
 14 |         Room { pos, radius }
 15 |     }
 16 | }
 17 | 
 18 | #[derive(Clone, Debug)]
 19 | pub struct Bridge {
 20 |     pub pos: Vec<IVec2>,
 21 | }
 22 | 
 23 | impl Bridge {
 24 |     pub fn new(pos: Vec<IVec2>) -> Self {
 25 |         Bridge { pos }
 26 |     }
 27 | }
 28 | 
 29 | #[derive(Clone, Debug)]
 30 | pub enum TileVariant {
 31 |     Standard,
 32 |     Accented,
 33 | }
 34 | 
 35 | #[derive(Clone, Debug)]
 36 | pub struct Tile {
 37 |     pub pos: IVec2,
 38 |     pub walkable: bool,
 39 |     pub is_center: bool,
 40 |     pub empty_neighbors: Vec<Direction>,
 41 |     pub variant: TileVariant,
 42 |     pub spawnable: bool,
 43 |     pub firt_room: bool,
 44 |     pub last_room: bool,
 45 | }
 46 | 
 47 | #[derive(Clone, Debug)]
 48 | pub struct Map {
 49 |     pub rooms: Vec<Room>,
 50 |     pub bridges: Vec<Bridge>,
 51 | }
 52 | 
 53 | impl Into<Vec<Tile>> for Map {
 54 |     fn into(self) -> Vec<Tile> {
 55 |         let mut tiles = Vec::<Tile>::new();
 56 | 
 57 |         for (i, room) in self.rooms.iter().enumerate() {
 58 |             for x in -room.radius..=room.radius {
 59 |                 for y in -room.radius..=room.radius {
 60 |                     //Remove corners
 61 |                     if x.abs() == room.radius && y.abs() == room.radius {
 62 |                         continue;
 63 |                     }
 64 | 
 65 |                     let pos = room.pos + IVec2::new(x, y);
 66 |                     //let walkable = x * x + y * y <= room.radius * room.radius;
 67 |                     let is_center = x == 0 && y == 0;
 68 | 
 69 |                     tiles.push(Tile {
 70 |                         pos,
 71 |                         walkable: true,
 72 |                         is_center,
 73 |                         empty_neighbors: Vec::new(),
 74 |                         variant: TileVariant::Standard,
 75 |                         spawnable: true,
 76 |                         firt_room: i == 0,
 77 |                         last_room: i == self.rooms.len() - 1,
 78 |                     });
 79 |                 }
 80 |             }
 81 |         }
 82 | 
 83 |         for bridge in self.bridges {
 84 |             for pos in bridge.pos {
 85 |                 tiles.push(Tile {
 86 |                     pos,
 87 |                     walkable: true,
 88 |                     is_center: false,
 89 |                     empty_neighbors: Vec::new(),
 90 |                     variant: TileVariant::Accented,
 91 |                     spawnable: false, //TODO: Should be fine to make the bridges spawnable
 92 |                     firt_room: false,
 93 |                     last_room: false,
 94 |                 });
 95 |             }
 96 |         }
 97 | 
 98 |         let tiles_copy = tiles.clone(); //TODO: possible optimization
 99 | 
100 |         for tile in &mut tiles {
101 |             let mut empty_neighbors = Vec::<Direction>::new();
102 | 
103 |             for direction in Direction::values() {
104 |                 let neighbor = tiles_copy
105 |                     .iter()
106 |                     .find(|neighbor| neighbor.pos == tile.pos + direction.vec().as_ivec2());
107 | 
108 |                 if neighbor.is_none() {
109 |                     empty_neighbors.push(direction);
110 |                 }
111 |             }
112 | 
113 |             if empty_neighbors.len() != 0 || tile.is_center {
114 |                 tile.spawnable = false;
115 |             }
116 | 
117 |             tile.empty_neighbors = empty_neighbors;
118 |         }
119 | 
120 |         tiles
121 |     }
122 | }
123 | 
124 | pub fn generate_map(domain_data: &DomainData) -> Map {
125 |     let mut rand = Rng::new();
126 |     let mut rooms = Vec::<Room>::new();
127 |     let mut bridges = Vec::<Bridge>::new();
128 | 
129 |     let num_rooms = rand.u32(domain_data.rooms.0..=domain_data.rooms.1);
130 |     let room_min_radius = domain_data.room_size.0;
131 |     let room_max_radius = domain_data.room_size.1;
132 | 
133 |     let mut old_room = Room::new(
134 |         IVec2::new(80, 80),
135 |         rand.u32(room_min_radius..=room_max_radius) as i32,
136 |     );
137 | 
138 |     let angle_range = 180;
139 |     let main_direction = rand.i32(0..360);
140 | 
141 |     while rooms.len() < num_rooms as usize {
142 |         let radius = rand.u32(room_min_radius..=room_max_radius) as i32;
143 |         let direction = main_direction + rand.i32(-angle_range..angle_range);
144 |         let direction = (direction as f32).to_radians();
145 |         let bridge_length = rand.i32(1..=3);
146 |         let distance = old_room.radius + bridge_length + (radius / 2);
147 | 
148 |         let new_room = Room::new(
149 |             (Vec2::new(direction.cos(), direction.sin()) * distance as f32)
150 |                 .round()
151 |                 .as_ivec2()
152 |                 + old_room.pos,
153 |             radius,
154 |         );
155 | 
156 |         if !rooms.is_empty() {
157 |             bridges.push(generate_bridge(old_room.pos, new_room.pos, &mut rand));
158 |         }
159 | 
160 |         rooms.push(new_room.clone());
161 |         old_room = new_room;
162 |     }
163 | 
164 |     Map { rooms, bridges }
165 | }
166 | 
167 | fn generate_bridge(from: IVec2, to: IVec2, rand: &mut Rng) -> Bridge {
168 |     let mut current = from.clone().as_vec2();
169 |     let to = to.as_vec2();
170 | 
171 |     let mut positions = Vec::<IVec2>::new();
172 |     let directions = [-90., 0., 90.];
173 | 
174 |     while current != to {
175 |         let mut dir = (to.y - current.y).atan2(to.x - current.x).to_degrees();
176 |         dir += *rand.sample(&directions).expect("No direction");
177 |         dir = (dir / 90.).round() * 90.; //Increments of 90
178 |         dir = dir.to_radians();
179 | 
180 |         current += Vec2::new(dir.cos(), dir.sin()).round();
181 | 
182 |         positions.push(current.as_ivec2());
183 |     }
184 | 
185 |     Bridge::new(positions)
186 | }
187 | 


--------------------------------------------------------------------------------
/src/ui/player.rs:
--------------------------------------------------------------------------------
  1 | use bevy::prelude::{AssetServer, Res, Window};
  2 | use bevy::prelude::{Query, With};
  3 | use bevy_egui::egui::load::SizedTexture;
  4 | use bevy_egui::egui::{Image, Pos2, Rect, RichText};
  5 | use bevy_egui::{egui, EguiContexts};
  6 | 
  7 | use crate::floor::FloorResource;
  8 | use crate::player::Player;
  9 | use crate::stats::{Damage, Health, Level, MovementSpeed, Revenge, XP};
 10 | use crate::Progression;
 11 | 
 12 | pub fn draw_hud(
 13 |     mut contexts: EguiContexts,
 14 |     asset_server: Res<AssetServer>,
 15 |     query: Query<
 16 |         (
 17 |             &Health,
 18 |             &XP,
 19 |             &Progression,
 20 |             &MovementSpeed,
 21 |             &Damage,
 22 |             &Level,
 23 |             &Revenge,
 24 |         ),
 25 |         With<Player>,
 26 |     >,
 27 |     floor: Res<FloorResource>,
 28 | ) {
 29 |     //TODO: Check if calling asset_server.load multiple times is bad
 30 |     let health_bar_fill = contexts.add_image(asset_server.load("health_bar_fill.png"));
 31 |     let health_bar_border = contexts.add_image(asset_server.load("health_bar_border.png"));
 32 | 
 33 |     let mut size = [63. * 5., 10. * 5.];
 34 | 
 35 |     if let Ok((health, xp, progression, speed, damage, level, revenge)) = query.get_single() {
 36 |         egui::CentralPanel::default()
 37 |             .frame(egui::Frame::none())
 38 |             .show(contexts.ctx_mut(), |ui| {
 39 |                 ui.put(
 40 |                     Rect {
 41 |                         min: egui::pos2(16., 8.),
 42 |                         max: egui::pos2(16. + size[0], 8. + size[1]),
 43 |                     },
 44 |                     Image::new(SizedTexture::new(health_bar_border, size)),
 45 |                 );
 46 | 
 47 |                 let scale = health.current as f32 / health.max as f32;
 48 |                 size[0] *= scale;
 49 | 
 50 |                 ui.put(
 51 |                     Rect {
 52 |                         min: egui::pos2(16., 8.),
 53 |                         max: egui::pos2(16. + size[0], 8. + size[1]),
 54 |                     },
 55 |                     Image::new(SizedTexture::new(health_bar_fill, size)).uv(Rect {
 56 |                         min: egui::pos2(0., 0.),
 57 |                         max: egui::pos2(scale, 1.),
 58 |                     }),
 59 |                 );
 60 | 
 61 |                 ui.add_space(10.);
 62 | 
 63 |                 ui.horizontal(|ui| {
 64 |                     ui.add_space(25.);
 65 | 
 66 |                     ui.vertical(|ui| {
 67 |                         ui.group(|ui| {
 68 |                             ui.label(RichText::new(format!("Level: {}", level.level)).size(20.));
 69 |                             ui.add_space(2.);
 70 |                             ui.label(
 71 |                                 RichText::new(format!("Health: {}/{}", health.current, health.max))
 72 |                                     .size(20.),
 73 |                             );
 74 |                             ui.add_space(2.);
 75 |                             ui.label(
 76 |                                 RichText::new(format!(
 77 |                                     "XP: {}/{}",
 78 |                                     xp.amount,
 79 |                                     progression.xp_to_level_up(level.level)
 80 |                                 ))
 81 |                                 .size(20.),
 82 |                             );
 83 | 
 84 |                             ui.label(
 85 |                                 RichText::new(format!(
 86 |                                     "Revenge: {:.2}/{}",
 87 |                                     revenge.amount, revenge.total
 88 |                                 ))
 89 |                                 .size(20.),
 90 |                             );
 91 |                             ui.add_space(2.);
 92 |                             ui.label(RichText::new(format!("Damage: {}", damage.amount)).size(20.));
 93 |                             ui.add_space(2.);
 94 |                             ui.label(RichText::new(format!("Speed: {}", speed.speed)).size(20.));
 95 |                         });
 96 |                     });
 97 |                 });
 98 |             });
 99 |     }
100 | 
101 |     egui::SidePanel::right("right")
102 |         .frame(egui::Frame::none())
103 |         .resizable(false)
104 |         .show_separator_line(false)
105 |         .exact_width(110.)
106 |         .show(contexts.ctx_mut(), |ui| {
107 |             ui.add_space(10.);
108 |             ui.heading(RichText::new(format!("Floor: {}", floor.floor)).size(26.));
109 |             ui.label(RichText::new(format!("Enemies: {}", floor.enemies.len())).size(16.));
110 |         });
111 | }
112 | 
113 | pub fn draw_xp_bar(
114 |     query: Query<(&XP, &Progression, &Level), With<Player>>,
115 |     mut contexts: EguiContexts,
116 |     windows: Query<&Window>,
117 | ) {
118 |     let painter = contexts.ctx_mut().debug_painter();
119 | 
120 |     let width = windows.single().width();
121 | 
122 |     if let Ok((xp, progression, level)) = query.get_single() {
123 |         let start_xp = match level.level {
124 |             1 => 0,
125 |             _ => progression.xp_to_level_up(level.level - 1),
126 |         };
127 | 
128 |         let scale = (xp.amount - start_xp) as f32 / progression.xp_to_level_up(level.level) as f32;
129 | 
130 |         painter.rect(
131 |             Rect {
132 |                 min: Pos2::new(0., 0.),
133 |                 max: Pos2::new(width * scale, 8.),
134 |             },
135 |             0.,
136 |             egui::Color32::DARK_BLUE,
137 |             egui::Stroke::NONE,
138 |         );
139 |     }
140 | }
141 | 
142 | pub fn draw_revenge_bar(
143 |     query: Query<&Revenge, With<Player>>,
144 |     mut contexts: EguiContexts,
145 |     windows: Query<&Window>,
146 | ) {
147 |     let painter = contexts.ctx_mut().debug_painter();
148 | 
149 |     let width = windows.single().width();
150 | 
151 |     if let Ok(revenge) = query.get_single() {
152 |         let scale = revenge.amount / revenge.total;
153 | 
154 |         painter.rect(
155 |             Rect {
156 |                 min: Pos2::new(0., 8.),
157 |                 max: Pos2::new(width * scale, 16.),
158 |             },
159 |             0.,
160 |             egui::Color32::DARK_RED,
161 |             egui::Stroke::NONE,
162 |         );
163 |     }
164 | }
165 | 


--------------------------------------------------------------------------------
/src/ui.rs:
--------------------------------------------------------------------------------
  1 | pub mod boss;
  2 | pub mod player;
  3 | 
  4 | use bevy::prelude::{AssetServer, Res, Window};
  5 | use bevy::prelude::{Query, With};
  6 | use bevy_egui::egui::load::SizedTexture;
  7 | use bevy_egui::egui::{Image, Pos2, Rect, RichText};
  8 | use bevy_egui::{egui, EguiContexts};
  9 | 
 10 | use crate::floor::FloorResource;
 11 | use crate::player::Player;
 12 | use crate::stats::{Damage, Health, Level, MovementSpeed, Revenge, XP};
 13 | use crate::Progression;
 14 | 
 15 | pub fn draw_hud(
 16 |     mut contexts: EguiContexts,
 17 |     asset_server: Res<AssetServer>,
 18 |     query: Query<
 19 |         (
 20 |             &Health,
 21 |             &XP,
 22 |             &Progression,
 23 |             &MovementSpeed,
 24 |             &Damage,
 25 |             &Level,
 26 |             &Revenge,
 27 |         ),
 28 |         With<Player>,
 29 |     >,
 30 |     floor: Res<FloorResource>,
 31 | ) {
 32 |     //TODO: Check if calling asset_server.load multiple times is bad
 33 |     let health_bar_fill = contexts.add_image(asset_server.load("health_bar_fill.png"));
 34 |     let health_bar_border = contexts.add_image(asset_server.load("health_bar_border.png"));
 35 | 
 36 |     let mut size = [63. * 5., 10. * 5.];
 37 | 
 38 |     if let Ok((health, xp, progression, speed, damage, level, revenge)) = query.get_single() {
 39 |         egui::CentralPanel::default()
 40 |             .frame(egui::Frame::none())
 41 |             .show(contexts.ctx_mut(), |ui| {
 42 |                 ui.put(
 43 |                     Rect {
 44 |                         min: egui::pos2(16., 8.),
 45 |                         max: egui::pos2(16. + size[0], 8. + size[1]),
 46 |                     },
 47 |                     Image::new(SizedTexture::new(health_bar_border, size)),
 48 |                 );
 49 | 
 50 |                 let scale = health.current as f32 / health.max as f32;
 51 |                 size[0] *= scale;
 52 | 
 53 |                 ui.put(
 54 |                     Rect {
 55 |                         min: egui::pos2(16., 8.),
 56 |                         max: egui::pos2(16. + size[0], 8. + size[1]),
 57 |                     },
 58 |                     Image::new(SizedTexture::new(health_bar_fill, size)).uv(Rect {
 59 |                         min: egui::pos2(0., 0.),
 60 |                         max: egui::pos2(scale, 1.),
 61 |                     }),
 62 |                 );
 63 | 
 64 |                 ui.add_space(10.);
 65 | 
 66 |                 ui.horizontal(|ui| {
 67 |                     ui.add_space(25.);
 68 | 
 69 |                     ui.vertical(|ui| {
 70 |                         ui.group(|ui| {
 71 |                             ui.label(RichText::new(format!("Level: {}", level.level)).size(20.));
 72 |                             ui.add_space(2.);
 73 |                             ui.label(
 74 |                                 RichText::new(format!("Health: {}/{}", health.current, health.max))
 75 |                                     .size(20.),
 76 |                             );
 77 |                             ui.add_space(2.);
 78 |                             ui.label(
 79 |                                 RichText::new(format!(
 80 |                                     "XP: {}/{}",
 81 |                                     xp.amount,
 82 |                                     progression.xp_to_level_up(level.level)
 83 |                                 ))
 84 |                                 .size(20.),
 85 |                             );
 86 | 
 87 |                             ui.label(
 88 |                                 RichText::new(format!(
 89 |                                     "Revenge: {:.2}/{}",
 90 |                                     revenge.amount, revenge.total
 91 |                                 ))
 92 |                                 .size(20.),
 93 |                             );
 94 |                             ui.add_space(2.);
 95 |                             ui.label(RichText::new(format!("Damage: {}", damage.amount)).size(20.));
 96 |                             ui.add_space(2.);
 97 |                             ui.label(RichText::new(format!("Speed: {}", speed.speed)).size(20.));
 98 |                         });
 99 |                     });
100 |                 });
101 |             });
102 |     }
103 | 
104 |     egui::SidePanel::right("right")
105 |         .frame(egui::Frame::none())
106 |         .resizable(false)
107 |         .show_separator_line(false)
108 |         .exact_width(110.)
109 |         .show(contexts.ctx_mut(), |ui| {
110 |             ui.add_space(10.);
111 |             ui.heading(RichText::new(format!("Floor: {}", floor.floor)).size(26.));
112 |             ui.label(RichText::new(format!("Enemies: {}", floor.enemies.len())).size(16.));
113 |         });
114 | }
115 | 
116 | pub fn draw_xp_bar(
117 |     query: Query<(&XP, &Progression, &Level), With<Player>>,
118 |     mut contexts: EguiContexts,
119 |     windows: Query<&Window>,
120 | ) {
121 |     let painter = contexts.ctx_mut().debug_painter();
122 | 
123 |     let width = windows.single().width();
124 | 
125 |     if let Ok((xp, progression, level)) = query.get_single() {
126 |         let start_xp = match level.level {
127 |             1 => 0,
128 |             _ => progression.xp_to_level_up(level.level - 1),
129 |         };
130 | 
131 |         let scale = (xp.amount - start_xp) as f32 / progression.xp_to_level_up(level.level) as f32;
132 | 
133 |         painter.rect(
134 |             Rect {
135 |                 min: Pos2::new(0., 0.),
136 |                 max: Pos2::new(width * scale, 8.),
137 |             },
138 |             0.,
139 |             egui::Color32::DARK_BLUE,
140 |             egui::Stroke::NONE,
141 |         );
142 |     }
143 | }
144 | 
145 | pub fn draw_revenge_bar(
146 |     query: Query<&Revenge, With<Player>>,
147 |     mut contexts: EguiContexts,
148 |     windows: Query<&Window>,
149 | ) {
150 |     let painter = contexts.ctx_mut().debug_painter();
151 | 
152 |     let width = windows.single().width();
153 | 
154 |     if let Ok(revenge) = query.get_single() {
155 |         let scale = revenge.amount / revenge.total;
156 | 
157 |         painter.rect(
158 |             Rect {
159 |                 min: Pos2::new(0., 8.),
160 |                 max: Pos2::new(width * scale, 16.),
161 |             },
162 |             0.,
163 |             egui::Color32::DARK_RED,
164 |             egui::Stroke::NONE,
165 |         );
166 |     }
167 | }
168 | 


--------------------------------------------------------------------------------
/src/controller.rs:
--------------------------------------------------------------------------------
  1 | use bevy::{
  2 |     math::Vec2,
  3 |     prelude::{Commands, Component, Entity, Query, Res, Transform, With},
  4 |     time::{Time, Timer, TimerMode},
  5 | };
  6 | use bevy::{math::Vec3Swizzles, prelude::RemovedComponents};
  7 | use leafwing_input_manager::prelude::ActionState;
  8 | 
  9 | use crate::{
 10 |     attack::{attack_phase, ChargePhase},
 11 |     movement::{
 12 |         direction::Direction,
 13 |         easing::{EaseFunction, EaseTo},
 14 |     },
 15 |     player::{Player, PlayerActions},
 16 |     state::State,
 17 |     stats::{Cooldown, MovementSpeed},
 18 | };
 19 | 
 20 | #[derive(Component)]
 21 | pub struct Controlled {
 22 |     pub move_to: Option<Vec2>,
 23 | }
 24 | 
 25 | #[derive(Component)]
 26 | pub struct Combo {
 27 |     pub current: u32,
 28 |     pub max: u32,
 29 |     pub timer: Timer,
 30 | }
 31 | 
 32 | pub fn move_player(
 33 |     mut query: Query<
 34 |         (
 35 |             &mut State,
 36 |             &mut Direction,
 37 |             &mut Controlled,
 38 |             &Transform,
 39 |             &MovementSpeed,
 40 |             &ActionState<PlayerActions>, // Entity,
 41 |         ),
 42 |         With<Player>,
 43 |     >,
 44 |     time: Res<Time>,
 45 | ) {
 46 |     if let Ok((mut state, mut direction, mut controlled, transform, mv_speed, action_state)) =
 47 |         query.get_single_mut()
 48 |     {
 49 |         if !(state.equals(State::Idle) || state.equals(State::Walking)) {
 50 |             return;
 51 |         }
 52 | 
 53 |         let mut dir = Vec2::ZERO;
 54 | 
 55 |         for action in PlayerActions::DIRECTIONS {
 56 |             if action_state.pressed(&action) {
 57 |                 if let Some(action_dir) = action.direction() {
 58 |                     dir += action_dir.vec();
 59 |                     direction.set(action_dir);
 60 |                 }
 61 |             }
 62 |         }
 63 | 
 64 |         let dir = dir.normalize_or_zero() * mv_speed.speed as f32 * time.delta_seconds();
 65 | 
 66 |         if dir.x == 0. && dir.y == 0. {
 67 |             state.set(State::Idle);
 68 |             controlled.move_to = None;
 69 |         } else {
 70 |             state.set(State::Walking);
 71 |             let move_to = transform.translation.xy() + dir;
 72 |             controlled.move_to = Some(move_to);
 73 |         }
 74 |     }
 75 | }
 76 | 
 77 | pub fn dash_ability(
 78 |     mut query: Query<
 79 |         (
 80 |             &mut State,
 81 |             &mut Transform,
 82 |             &Direction,
 83 |             &ActionState<PlayerActions>,
 84 |             &mut Cooldown,
 85 |             Entity,
 86 |         ),
 87 |         With<Player>,
 88 |     >,
 89 |     mut commands: Commands,
 90 | ) {
 91 |     if let Ok((mut state, transform, direction, action_state, mut cooldown, entity)) =
 92 |         query.get_single_mut()
 93 |     {
 94 |         let mut dir = Vec2::ZERO;
 95 | 
 96 |         if matches!(*state, State::Attacking(_)) || state.equals(State::Dashing) {
 97 |             return;
 98 |         }
 99 | 
100 |         for action in PlayerActions::DIRECTIONS {
101 |             if action_state.pressed(&action) {
102 |                 if let Some(action_dir) = action.direction() {
103 |                     dir += action_dir.vec();
104 |                 }
105 |             }
106 |         }
107 | 
108 |         if dir == Vec2::ZERO {
109 |             dir = direction.vec();
110 |         }
111 | 
112 |         if action_state.just_pressed(&PlayerActions::Dash) && cooldown.is_ready() {
113 |             state.set(State::Dashing);
114 |             cooldown.reset();
115 | 
116 |             //TODO: Add dash stats
117 |             let new_pos = transform.translation.xy() + (dir.normalize() * 45.);
118 |             if let Some(mut ec) = commands.get_entity(entity) {
119 |                 ec.insert(EaseTo::new(new_pos, EaseFunction::EaseOutQuad, 0.35));
120 |             }
121 |         }
122 |     }
123 | }
124 | 
125 | pub fn finish_dash(
126 |     mut query: Query<&mut State, With<Player>>,
127 |     mut removals: RemovedComponents<EaseTo>,
128 | ) {
129 |     for entity in removals.read() {
130 |         if let Ok(mut state) = query.get_mut(entity) {
131 |             if state.equals(State::Dashing) {
132 |                 state.set(State::Idle);
133 |             }
134 |         }
135 |     }
136 | }
137 | 
138 | pub fn attack_ability(
139 |     mut query: Query<(
140 |         &mut State,
141 |         &ActionState<PlayerActions>,
142 |         &Transform,
143 |         &Direction,
144 |         &mut Cooldown,
145 |         Option<&mut Combo>,
146 |         Entity,
147 |     )>,
148 |     mut commands: Commands,
149 | ) {
150 |     if let Ok((mut state, action_state, transform, direction, mut cooldown, combo, entity)) =
151 |         query.get_single_mut()
152 |     {
153 |         if state.equals(State::Dashing) || matches!(*state, State::Attacking(_)) {
154 |             return;
155 |         }
156 | 
157 |         if action_state.just_pressed(&PlayerActions::Attack) && cooldown.is_ready() {
158 |             if let Some(mut combo) = combo {
159 |                 combo.current += 1;
160 |                 combo.timer.reset();
161 |                 if combo.current > combo.max {
162 |                     combo.current = 0;
163 |                 }
164 |                 state.set(State::Attacking(combo.current));
165 |             } else {
166 |                 state.set(State::Attacking(0));
167 |                 commands.entity(entity).insert(Combo {
168 |                     current: 0,
169 |                     max: 2,
170 |                     timer: Timer::from_seconds(1., bevy::time::TimerMode::Once),
171 |                 });
172 |             }
173 | 
174 |             cooldown.reset();
175 | 
176 |             //TODO: Add attack dash stats
177 |             let new_pos = transform.translation.xy() + (direction.vec().normalize() * 5.);
178 | 
179 |             if let Some(mut ec) = commands.get_entity(entity) {
180 |                 ec.insert(attack_phase(0.05, 0.2, 0.075))
181 |                     .insert(ChargePhase(Timer::from_seconds(0.05, TimerMode::Once), 0.2))
182 |                     .insert(EaseTo::new(new_pos, EaseFunction::EaseOutQuad, 0.5));
183 |             } else {
184 |                 println!("Failed to get entity");
185 |                 state.set(State::Idle);
186 |             }
187 |         }
188 |     }
189 | }
190 | 
191 | pub fn combo_system(
192 |     mut query: Query<(&mut Combo, Entity)>,
193 |     time: Res<Time>,
194 |     mut commands: Commands,
195 | ) {
196 |     for (mut combo, entity) in query.iter_mut() {
197 |         combo.timer.tick(time.delta());
198 | 
199 |         if combo.timer.finished() {
200 |             commands.entity(entity).remove::<Combo>();
201 |         }
202 |     }
203 | }
204 | 


--------------------------------------------------------------------------------
/src/manifest/mod.rs:
--------------------------------------------------------------------------------
  1 | use std::path::PathBuf;
  2 | 
  3 | use bevy::{
  4 |     app::Plugin,
  5 |     asset::{AssetServer, Assets, Handle},
  6 |     math::{UVec2, Vec2},
  7 |     prelude::AppExtStates,
  8 |     render::texture::Image,
  9 |     sprite::TextureAtlasLayout,
 10 |     utils::HashMap,
 11 | };
 12 | use bevy_spritesheet_animation::{
 13 |     clip::Clip,
 14 |     prelude::{Animation, AnimationDuration, AnimationId, AnimationLibrary},
 15 | };
 16 | use boss::BossManifest;
 17 | use leafwing_manifest::{
 18 |     asset_state::SimpleAssetState,
 19 |     plugin::{ManifestPlugin, RegisterManifest},
 20 | };
 21 | use serde::{Deserialize, Serialize};
 22 | 
 23 | use crate::{
 24 |     animation::{Animations, DirectionalAnimations},
 25 |     movement::direction::Direction,
 26 |     state::State,
 27 | };
 28 | 
 29 | use self::{enemy::EnemyManifest, floor::DomainManifest, player::PlayerManifest};
 30 | 
 31 | pub mod boss;
 32 | pub mod enemy;
 33 | pub mod floor;
 34 | pub mod player;
 35 | 
 36 | pub struct DataManifestPlugin {}
 37 | 
 38 | impl Plugin for DataManifestPlugin {
 39 |     fn build(&self, app: &mut bevy::prelude::App) {
 40 |         app.init_state::<SimpleAssetState>() //TODO: Check how to handle the loading state
 41 |             .add_plugins(ManifestPlugin::<SimpleAssetState>::default())
 42 |             .register_manifest::<EnemyManifest>("entities/enemies/data.yaml")
 43 |             .register_manifest::<PlayerManifest>("entities/player/player.yaml")
 44 |             .register_manifest::<DomainManifest>("domains.yaml")
 45 |             .register_manifest::<BossManifest>("entities/enemies/bosses.yaml");
 46 |     }
 47 | }
 48 | 
 49 | #[derive(Debug, Serialize, Deserialize, PartialEq)]
 50 | pub struct RawTextureData {
 51 |     pub path: PathBuf,
 52 |     pub tile_size: UVec2,
 53 |     pub columns: u32,
 54 |     pub rows: u32,
 55 |     pub padding: Option<UVec2>,
 56 |     pub offset: Option<UVec2>,
 57 | }
 58 | 
 59 | #[derive(Debug, Serialize, Deserialize, PartialEq)]
 60 | #[serde(tag = "type")]
 61 | pub enum RawAttackData {
 62 |     Melee {
 63 |         size: Vec2,
 64 |         duration: f32,
 65 |         knockback: f32,
 66 |     },
 67 |     Ranged {
 68 |         size: Vec2,
 69 |         duration: f32,
 70 |         velocity: f32,
 71 |         texture: RawTextureData,
 72 |     },
 73 | }
 74 | 
 75 | #[derive(Debug, PartialEq, Clone)]
 76 | pub enum AttackData {
 77 |     Melee {
 78 |         size: Vec2,
 79 |         duration: f32,
 80 |         knockback: f32,
 81 |     },
 82 |     Ranged {
 83 |         size: Vec2,
 84 |         duration: f32,
 85 |         velocity: f32,
 86 |         texture: Handle<Image>,
 87 |         atlas: Handle<TextureAtlasLayout>,
 88 |     },
 89 | }
 90 | 
 91 | pub fn load_texture_data(
 92 |     data: &RawTextureData,
 93 |     world: &mut bevy::prelude::World,
 94 | ) -> (Handle<Image>, Handle<TextureAtlasLayout>) {
 95 |     let asset_server = world.resource::<AssetServer>();
 96 |     let texture: Handle<Image> = asset_server.load(data.path.clone());
 97 | 
 98 |     let mut text_atlas_layout = world.resource_mut::<Assets<TextureAtlasLayout>>();
 99 | 
100 |     let layout = TextureAtlasLayout::from_grid(
101 |         data.tile_size,
102 |         data.columns,
103 |         data.rows,
104 |         data.padding,
105 |         data.offset,
106 |     );
107 | 
108 |     (texture, text_atlas_layout.add(layout))
109 | }
110 | 
111 | pub fn load_attack_data(data: &RawAttackData, world: &mut bevy::prelude::World) -> AttackData {
112 |     match data {
113 |         RawAttackData::Ranged {
114 |             size: raw_size,
115 |             duration: raw_duration,
116 |             velocity: raw_velocity,
117 |             texture: raw_texture,
118 |         } => {
119 |             let (texture, atlas) = load_texture_data(&raw_texture, world);
120 |             AttackData::Ranged {
121 |                 size: *raw_size,
122 |                 duration: *raw_duration,
123 |                 velocity: *raw_velocity,
124 |                 texture,
125 |                 atlas,
126 |             }
127 |         }
128 |         RawAttackData::Melee {
129 |             size: raw_size,
130 |             duration: raw_duration,
131 |             knockback: raw_knockback,
132 |         } => AttackData::Melee {
133 |             size: *raw_size,
134 |             duration: *raw_duration,
135 |             knockback: *raw_knockback,
136 |         },
137 |     }
138 | }
139 | 
140 | #[derive(Debug, Serialize, Deserialize, PartialEq)]
141 | pub struct RawAnimationData {
142 |     pub name: String,
143 |     pub frames: Vec<usize>,
144 |     pub duration: u32,
145 | }
146 | 
147 | pub fn load_animations(
148 |     name: &str,
149 |     data: &Vec<RawAnimationData>,
150 |     world: &mut bevy::prelude::World,
151 | ) -> Animations {
152 |     let mut library = world
153 |         .get_resource_mut::<AnimationLibrary>()
154 |         .expect("No AnimationLibrary found!");
155 | 
156 |     Animations(
157 |         data.iter()
158 |             .map(|raw| {
159 |                 let clip_id = library.register_clip(
160 |                     Clip::from_frames(raw.frames.clone())
161 |                         .with_duration(AnimationDuration::PerFrame(raw.duration)),
162 |                 );
163 |                 let animation_id = library.register_animation(Animation::from_clip(clip_id));
164 | 
165 |                 library
166 |                     .name_animation(animation_id, format!("{}_{}", name, raw.name))
167 |                     .expect(format!("Failed to name animation for {}_{}", name, raw.name).as_str());
168 | 
169 |                 (raw.name.clone(), animation_id)
170 |             })
171 |             .collect(),
172 |     )
173 | }
174 | 
175 | #[derive(Debug, Serialize, Deserialize, PartialEq)]
176 | pub struct RawDirectionalAnimationData {
177 |     pub duration: u32,
178 |     pub state: State,
179 |     pub directions: HashMap<Direction, Vec<usize>>,
180 | }
181 | 
182 | pub fn load_directional_animations(
183 |     data: &Vec<RawDirectionalAnimationData>,
184 |     world: &mut bevy::prelude::World,
185 | ) -> DirectionalAnimations {
186 |     let mut library = world
187 |         .get_resource_mut::<AnimationLibrary>()
188 |         .expect("No AnimationLibrary found!");
189 | 
190 |     let mut states: HashMap<State, HashMap<Direction, AnimationId>> = HashMap::new();
191 | 
192 |     for raw in data {
193 |         states.insert(
194 |             raw.state,
195 |             raw.directions
196 |                 .iter()
197 |                 .map(|(dir, frames)| {
198 |                     let clip_id = library.register_clip(
199 |                         Clip::from_frames(frames.clone())
200 |                             .with_duration(AnimationDuration::PerFrame(raw.duration)),
201 |                     );
202 |                     let animation_id = library.register_animation(Animation::from_clip(clip_id));
203 | 
204 |                     (*dir, animation_id)
205 |                 })
206 |                 .collect(),
207 |         );
208 |     }
209 | 
210 |     DirectionalAnimations(states)
211 | }
212 | 


--------------------------------------------------------------------------------
/src/collision.rs:
--------------------------------------------------------------------------------
  1 | use bevy::prelude::{
  2 |     in_state, Color, IntoSystemConfigs, Parent, Res, Text, Text2dBundle, TextStyle, Timer, Update,
  3 |     Vec2,
  4 | };
  5 | use bevy::text::JustifyText;
  6 | use bevy::time::TimerMode;
  7 | use bevy::{
  8 |     math::Vec3Swizzles,
  9 |     prelude::{
 10 |         App, Camera, Commands, DespawnRecursiveExt, Entity, EventReader, Plugin, Query, Transform,
 11 |         With, Without,
 12 |     },
 13 | };
 14 | use bevy_rapier2d::{prelude::*, rapier::prelude::CollisionEventFlags};
 15 | use std::time::Duration;
 16 | 
 17 | use crate::attack::{EntitiesHit, Lifetime};
 18 | use crate::game_states::loading::GameAssets;
 19 | use crate::stats::Revenge;
 20 | use crate::{
 21 |     attack::{Breakable, Damageable, Knockback},
 22 |     helper::Shake,
 23 |     movement::easing::{EaseFunction, EaseTo},
 24 |     player::Player,
 25 |     stats::{Damage, Drop, Health},
 26 |     GameState, XP,
 27 | };
 28 | 
 29 | pub struct CollisionPlugin;
 30 | 
 31 | impl Plugin for CollisionPlugin {
 32 |     fn build(&self, app: &mut App) {
 33 |         app.add_plugins(RapierPhysicsPlugin::<NoUserData>::pixels_per_meter(100.0))
 34 |             .add_plugins(RapierDebugRenderPlugin::default())
 35 |             .add_systems(
 36 |                 Update,
 37 |                 (damageable_collision, xp_system).distributive_run_if(in_state(GameState::InGame)),
 38 |             );
 39 |     }
 40 | }
 41 | 
 42 | #[derive(Copy, Clone)]
 43 | pub struct BodyLayers;
 44 | 
 45 | impl BodyLayers {
 46 |     pub const PLAYER: Group = Group::GROUP_1;
 47 |     pub const ENEMY: Group = Group::GROUP_2;
 48 |     pub const PLAYER_ATTACK: Group = Group::GROUP_3;
 49 |     pub const ENEMY_ATTACK: Group = Group::GROUP_4;
 50 |     pub const XP_LAYER: Group = Group::GROUP_5;
 51 | }
 52 | 
 53 | pub fn xp_system(
 54 |     mut commands: Commands,
 55 |     mut events: EventReader<CollisionEvent>,
 56 |     drop_query: Query<&XP, (With<Drop>, Without<Player>)>,
 57 |     mut player_query: Query<&mut XP, (With<Player>, Without<Drop>)>,
 58 | ) {
 59 |     events.read().for_each(|e| {
 60 |         let (e1, e2, started, flags) = match e {
 61 |             CollisionEvent::Started(e1, e2, flags) => (e1, e2, true, flags),
 62 |             CollisionEvent::Stopped(e1, e2, flags) => (e1, e2, false, flags),
 63 |         };
 64 | 
 65 |         //If entity removed from world, don't handle collision
 66 |         if !started && *flags == CollisionEventFlags::REMOVED {
 67 |             return;
 68 |         }
 69 | 
 70 |         if let Some((drop_entity, player_entity)) = match (
 71 |             drop_query.contains(*e1) && player_query.contains(*e2),
 72 |             (player_query.contains(*e1) && drop_query.contains(*e2)),
 73 |         ) {
 74 |             (true, false) => Some((*e1, *e2)),
 75 |             (false, true) => Some((*e2, *e1)),
 76 |             _ => None,
 77 |         } {
 78 |             let drop_xp = drop_query.get(drop_entity).unwrap();
 79 |             let mut player_xp = player_query.get_mut(player_entity).unwrap();
 80 | 
 81 |             player_xp.add(drop_xp);
 82 |             commands.entity(drop_entity).despawn_recursive();
 83 |         }
 84 |     });
 85 | }
 86 | 
 87 | pub fn damageable_collision(
 88 |     mut events: EventReader<CollisionEvent>,
 89 |     mut damage_query: Query<(
 90 |         &Damage,
 91 |         Option<&mut EntitiesHit>,
 92 |         Option<&Knockback>,
 93 |         Option<&mut Breakable>,
 94 |         Option<&Parent>,
 95 |     )>,
 96 |     mut damageable_query: Query<(&mut Health, &Transform), With<Damageable>>,
 97 |     mut player_query: Query<&mut Revenge, With<Player>>,
 98 |     camera_query: Query<Entity, With<Camera>>,
 99 |     mut commands: Commands,
100 |     game_assets: Res<GameAssets>,
101 | ) {
102 |     events.read().for_each(|e| {
103 |         let (e1, e2, started, flags) = match e {
104 |             CollisionEvent::Started(e1, e2, flags) => (e1, e2, true, flags),
105 |             CollisionEvent::Stopped(e1, e2, flags) => (e1, e2, false, flags),
106 |         };
107 | 
108 |         //If entity removed from world, don't handle collision
109 |         if !started || *flags == CollisionEventFlags::REMOVED {
110 |             return;
111 |         }
112 | 
113 |         //TODO: Check what to do when both entities have damage and damageable
114 |         if let Some((damage_entity, damaged_entity)) = match (
115 |             damage_query.contains(*e1) && damageable_query.contains(*e2),
116 |             (damage_query.contains(*e2) && damageable_query.contains(*e1)),
117 |         ) {
118 |             (true, false) => Some((*e1, *e2)),
119 |             (false, true) => Some((*e2, *e1)),
120 |             _ => None,
121 |         } {
122 |             let (damage, entities_hit, knockback, breakable, parent) =
123 |                 damage_query.get_mut(damage_entity).unwrap();
124 | 
125 |             if let Some(mut entities_hit) = entities_hit {
126 |                 if entities_hit.0.contains(&damaged_entity) {
127 |                     return;
128 |                 } else {
129 |                     entities_hit.0.push(damaged_entity);
130 |                 }
131 |             }
132 | 
133 |             let (mut health, transform) = damageable_query.get_mut(damaged_entity).unwrap();
134 | 
135 |             health.damage(damage);
136 | 
137 |             //TODO: Handle on separate system
138 |             if let Some(mut breakable) = breakable {
139 |                 if breakable.0 > 0 {
140 |                     breakable.0 -= 1;
141 |                 }
142 |             }
143 | 
144 |             if let Some(knockback) = knockback {
145 |                 let new_pos =
146 |                     transform.translation.xy() + knockback.force * knockback.direction.vec();
147 |                 if let Some(mut ec) = commands.get_entity(damaged_entity) {
148 |                     if health.current > 0 {
149 |                         ec.insert(EaseTo::new(new_pos, EaseFunction::EaseOutExpo, 0.5));
150 |                     }
151 |                 }
152 |             }
153 | 
154 |             if let Some(parent) = parent {
155 |                 if let Ok(mut revenge) = player_query.get_mut(parent.get()) {
156 |                     revenge.amount += damage.amount as f32 / 10.;
157 |                 }
158 |             }
159 | 
160 |             //Switch this into a shake event
161 |             if let Ok(camera) = camera_query.get_single() {
162 |                 commands.entity(camera).insert(Shake {
163 |                     duration: 0.25,
164 |                     strength: (damage.amount as f32 / 25.).powi(2),
165 |                 });
166 |             }
167 | 
168 |             //TODO: Move this into a separate system using events
169 |             let text_style = TextStyle {
170 |                 font: game_assets.font.clone(),
171 |                 font_size: 12.0,
172 |                 color: Color::WHITE,
173 |             };
174 | 
175 |             //Spawn damage indicator text
176 |             commands.spawn((
177 |                 Text2dBundle {
178 |                     text: Text::from_section(format!("-{}", damage.amount), text_style)
179 |                         .with_justify(JustifyText::Center),
180 |                     transform: Transform::from_translation(transform.translation.xy().extend(500.)),
181 |                     ..Default::default()
182 |                 },
183 |                 EaseTo::new(
184 |                     transform.translation.xy() + Vec2::new(0., 20.),
185 |                     EaseFunction::EaseOutExpo,
186 |                     1.,
187 |                 ),
188 |                 Lifetime(Timer::new(Duration::from_secs_f32(1.), TimerMode::Once)),
189 |             ));
190 |         }
191 |     });
192 | }
193 | 


--------------------------------------------------------------------------------
/src/enemy/state_machine.rs:
--------------------------------------------------------------------------------
  1 | use std::time::Duration;
  2 | 
  3 | use bevy::ecs::query::Without;
  4 | use bevy::ecs::system::In;
  5 | use bevy::math::{Vec2, Vec3Swizzles};
  6 | use bevy::prelude::{
  7 |     in_state, App, Commands, Component, Entity, EventWriter, IntoSystemConfigs, Local, Query,
  8 |     Reflect, Res, Time, Timer, TimerMode, Transform, Update, With,
  9 | };
 10 | use bevy::utils::HashMap;
 11 | use leafwing_manifest::identifier::Id;
 12 | use seldom_state::prelude::*;
 13 | use turborand::rng::Rng;
 14 | use turborand::TurboRand;
 15 | 
 16 | use crate::attack::SpawnEnemyAttack;
 17 | use crate::enemy::Enemy;
 18 | use crate::manifest::enemy::EnemyManifest;
 19 | use crate::manifest::AttackData;
 20 | use crate::movement::movement::{Follow, Velocity};
 21 | use crate::player::Player;
 22 | use crate::stats::{Cooldown, Damage};
 23 | use crate::GameState;
 24 | 
 25 | pub(crate) fn register(app: &mut App) {
 26 |     app.add_plugins(StateMachinePlugin) //TODO: Move somewhere else
 27 |         .add_systems(
 28 |             Update,
 29 |             (idle, wander, follow_player, attack_player).run_if(in_state(GameState::InGame)),
 30 |         );
 31 | }
 32 | 
 33 | pub(crate) fn get_state_machine() -> StateMachine {
 34 |     //   let near_player = NearPlayer { range: 120.0 };
 35 | 
 36 |     let near_player = move |In(entity): In<Entity>,
 37 |                             transform: Query<&Transform, Without<Player>>,
 38 |                             player: Query<&Transform, With<Player>>| {
 39 |         if player.is_empty() {
 40 |             return Err(0.0);
 41 |         }
 42 | 
 43 |         let distance = player
 44 |             .get_single()
 45 |             .expect("Player not found in near_player state")
 46 |             .translation
 47 |             .truncate()
 48 |             .distance(transform.get(entity).unwrap().translation.truncate());
 49 | 
 50 |         if distance <= 120.0 {
 51 |             Ok(distance)
 52 |         } else {
 53 |             Err(distance)
 54 |         }
 55 |     };
 56 | 
 57 |     StateMachine::default()
 58 |         .trans::<Idle, _>(done(Some(Done::Success)), Wander)
 59 |         .trans::<Wander, _>(near_player, FollowPlayer)
 60 |         .trans::<Wander, _>(done(Some(Done::Success)), Idle)
 61 |         .trans::<FollowPlayer, _>(done(Some(Done::Success)), Attack)
 62 |         .trans::<FollowPlayer, _>(near_player.not(), Wander)
 63 |         .trans::<Attack, _>(done(Some(Done::Success)), Idle)
 64 | }
 65 | 
 66 | //States
 67 | #[derive(Component, Clone, Reflect)]
 68 | #[component(storage = "SparseSet")]
 69 | pub struct Idle;
 70 | 
 71 | #[derive(Component, Clone, Reflect)]
 72 | #[component(storage = "SparseSet")]
 73 | struct Wander;
 74 | 
 75 | #[derive(Component, Clone, Reflect)]
 76 | #[component(storage = "SparseSet")]
 77 | struct FollowPlayer;
 78 | 
 79 | #[derive(Component, Clone, Reflect)]
 80 | #[component(storage = "SparseSet")]
 81 | struct Attack;
 82 | 
 83 | #[derive(Component)]
 84 | struct IdleDuration(Timer);
 85 | 
 86 | fn idle(
 87 |     mut commands: Commands,
 88 |     mut enemies: Query<(Entity, Option<&mut IdleDuration>), With<Idle>>,
 89 |     time: Res<Time>,
 90 | ) {
 91 |     let rand = Rng::new();
 92 |     for (entity, timer) in enemies.iter_mut() {
 93 |         if let Some(mut timer) = timer {
 94 |             timer.0.tick(time.delta());
 95 | 
 96 |             if timer.0.finished() {
 97 |                 commands
 98 |                     .entity(entity)
 99 |                     .remove::<IdleDuration>()
100 |                     .insert(Done::Success);
101 |             }
102 |         } else {
103 |             commands.entity(entity).insert(IdleDuration(Timer::new(
104 |                 Duration::from_millis(rand.u64(0..=1500)),
105 |                 TimerMode::Once,
106 |             )));
107 |         }
108 |     }
109 | }
110 | 
111 | fn wander(
112 |     enemies: Query<(Entity, Option<&Velocity>), With<Wander>>,
113 |     mut commands: Commands,
114 |     mut timers: Local<HashMap<Entity, f32>>,
115 |     time: Res<Time>,
116 | ) {
117 |     let rand = Rng::new();
118 |     for (entity, velocity) in enemies.iter() {
119 |         if velocity.is_some() {
120 |             if timers.contains_key(&entity) {
121 |                 let timer = timers.get_mut(&entity).unwrap();
122 |                 *timer += time.delta_seconds();
123 | 
124 |                 if *timer >= rand.i32(1..=3) as f32 {
125 |                     timers.remove(&entity);
126 |                     if let Some(mut ec) = commands.get_entity(entity) {
127 |                         ec.insert(Done::Success).remove::<Velocity>();
128 |                     }
129 |                 }
130 |             }
131 |             continue;
132 |         }
133 | 
134 |         let x = rand.i32(-1..1) as f32;
135 |         let y = rand.i32(-5..5) as f32 / 10.;
136 |         let speed = 15.;
137 |         let direction = Vec2::new(x, y); //.normalize_or_zero();
138 | 
139 |         if let Some(mut ec) = commands.get_entity(entity) {
140 |             ec.insert(Velocity(direction * speed, true));
141 |         }
142 |         timers.insert(entity, 0.);
143 |     }
144 | }
145 | 
146 | fn follow_player(
147 |     enemies: Query<Entity, (With<Enemy>, With<FollowPlayer>)>,
148 |     player: Query<Entity, With<Player>>,
149 |     follows: Query<&Follow, With<Enemy>>,
150 |     mut commands: Commands,
151 | ) {
152 |     for enemy in enemies.iter() {
153 |         if let Ok(player) = player.get_single() {
154 |             if let Ok(follow) = follows.get(enemy) {
155 |                 if follow.on_target {
156 |                     if let Some(mut ec) = commands.get_entity(enemy) {
157 |                         ec.insert(Done::Success).remove::<Follow>();
158 |                     }
159 |                 }
160 |             } else if let Some(mut ec) = commands.get_entity(enemy) {
161 |                 ec.insert(Follow::new(player, 0.10, true, 80.));
162 |             }
163 |         }
164 |     }
165 | }
166 | 
167 | fn attack_player(
168 |     player_query: Query<&Transform, With<Player>>,
169 |     mut event: EventWriter<SpawnEnemyAttack>,
170 |     mut enemies: Query<(Entity, &Enemy, &Transform, &Damage, &mut Cooldown), With<Attack>>,
171 |     mut commands: Commands,
172 |     mut durations: Local<HashMap<Entity, f32>>,
173 |     enemy_manifest: Res<EnemyManifest>,
174 |     time: Res<Time>,
175 | ) {
176 |     for (entity, enemy, transform, damage, mut cooldown) in enemies.iter_mut() {
177 |         if !durations.contains_key(&entity) && cooldown.is_ready() {
178 |             if let Ok(player) = player_query.get_single() {
179 |                 let direction = (player.translation - transform.translation)
180 |                     .xy()
181 |                     .normalize();
182 | 
183 |                 let enemy_data = enemy_manifest
184 |                     .enemies
185 |                     .get(&Id::from_name(enemy.0.as_str()))
186 |                     .unwrap();
187 | 
188 |                 let duration = match enemy_data.attack {
189 |                     AttackData::Melee { duration, .. } => duration,
190 |                     AttackData::Ranged { duration, .. } => duration,
191 |                 };
192 | 
193 |                 durations.insert(entity, duration);
194 | 
195 |                 event.send(SpawnEnemyAttack {
196 |                     data: enemy_data.attack.clone(),
197 |                     damage: *damage,
198 |                     direction,
199 |                     position: transform.translation,
200 |                     enemy_size: enemy_data.hitbox,
201 |                 });
202 |                 cooldown.reset();
203 |             }
204 |             // commands.entity(enemy).insert(Done::Failure);
205 |         }
206 | 
207 |         if let Some(duration) = durations.get_mut(&entity) {
208 |             *duration -= time.delta_seconds();
209 | 
210 |             if *duration <= 0. {
211 |                 durations.remove(&entity);
212 |                 if let Some(mut ec) = commands.get_entity(entity) {
213 |                     ec.insert(Done::Success);
214 |                 }
215 |             }
216 |         }
217 |     }
218 | }
219 | 


--------------------------------------------------------------------------------
/src/stats.rs:
--------------------------------------------------------------------------------
  1 | use std::time::Duration;
  2 | 
  3 | use bevy::prelude::Time;
  4 | use bevy::{
  5 |     math::Vec3Swizzles,
  6 |     prelude::{
  7 |         Bundle, Commands, Component, DespawnRecursiveExt, Entity, EventReader, EventWriter, Handle,
  8 |         Image, Query, Res, Transform, Vec2, Vec3, With,
  9 |     },
 10 |     sprite::SpriteBundle,
 11 |     time::Timer,
 12 | };
 13 | use bevy_rapier2d::prelude::{ActiveCollisionTypes, ActiveEvents, Collider, CollisionGroups};
 14 | 
 15 | use crate::game_states::loading::GameAssets;
 16 | use crate::{
 17 |     collision::BodyLayers, enemy::Enemy, floor::EnemyKilledEvent, movement::movement::Follow,
 18 |     player::Player,
 19 | };
 20 | 
 21 | #[derive(Component)]
 22 | pub struct Health {
 23 |     pub current: u32,
 24 |     pub max: u32,
 25 | }
 26 | 
 27 | impl Health {
 28 |     pub fn new(max: u32) -> Self {
 29 |         Self { current: max, max }
 30 |     }
 31 | 
 32 |     pub fn damage(&mut self, damage: &Damage) {
 33 |         if let Some(health) = self.current.checked_sub(damage.amount) {
 34 |             self.current = health;
 35 |         } else {
 36 |             self.current = 0;
 37 |         }
 38 |     }
 39 | }
 40 | 
 41 | #[derive(Component, Clone, Copy)]
 42 | pub struct Damage {
 43 |     pub amount: u32,
 44 | }
 45 | 
 46 | impl Damage {
 47 |     pub fn new(amount: u32) -> Self {
 48 |         Self { amount }
 49 |     }
 50 | }
 51 | 
 52 | #[derive(Component)]
 53 | pub struct MovementSpeed {
 54 |     pub speed: u32,
 55 | }
 56 | 
 57 | impl MovementSpeed {
 58 |     pub fn new(speed: u32) -> Self {
 59 |         Self { speed }
 60 |     }
 61 | }
 62 | 
 63 | #[derive(Component)]
 64 | pub struct XP {
 65 |     pub amount: u32,
 66 | }
 67 | 
 68 | impl XP {
 69 |     pub fn new(xp: u32) -> Self {
 70 |         Self { amount: xp }
 71 |     }
 72 | 
 73 |     pub fn add(&mut self, other: &Self) {
 74 |         self.amount += other.amount;
 75 |     }
 76 | }
 77 | 
 78 | #[derive(Component)]
 79 | pub struct Progression {
 80 |     pub base_xp: u32,
 81 |     pub multiplier: f32,
 82 | }
 83 | 
 84 | impl Progression {
 85 |     pub fn new(base_xp: u32, multiplier: f32) -> Self {
 86 |         Self {
 87 |             base_xp,
 88 |             multiplier,
 89 |         }
 90 |     }
 91 | 
 92 |     pub fn xp_to_level_up(&self, level: i32) -> u32 {
 93 |         (self.base_xp as f32 * self.multiplier.powi(level)) as u32
 94 |     }
 95 | }
 96 | 
 97 | #[derive(Component)]
 98 | pub struct Level {
 99 |     pub level: i32,
100 | }
101 | 
102 | impl Level {
103 |     pub(crate) fn default() -> Level {
104 |         Self { level: 1 }
105 |     }
106 | }
107 | 
108 | #[derive(Component)]
109 | pub struct Revenge {
110 |     pub amount: f32,
111 |     pub decay: f32,
112 |     pub active_decay: f32,
113 |     pub active: bool,
114 |     pub total: f32,
115 | }
116 | 
117 | impl Revenge {
118 |     pub fn decay(&self) -> f32 {
119 |         match self.active {
120 |             true => self.active_decay,
121 |             false => self.decay,
122 |         }
123 |     }
124 | }
125 | 
126 | #[derive(Component)]
127 | pub struct Cooldown {
128 |     pub timer: Timer,
129 | }
130 | impl Cooldown {
131 |     pub fn new(millis: u32) -> Self {
132 |         Self {
133 |             timer: Timer::from_seconds(millis as f32 / 1000., bevy::time::TimerMode::Once),
134 |         }
135 |     }
136 | 
137 |     pub fn is_ready(&self) -> bool {
138 |         self.timer.finished()
139 |     }
140 | 
141 |     pub fn reset(&mut self) {
142 |         self.timer.reset();
143 |     }
144 | 
145 |     pub fn update(&mut self, time: Duration) {
146 |         self.timer.tick(time);
147 |     }
148 | }
149 | 
150 | //TODO: Check if a new method is needed
151 | #[derive(Bundle)]
152 | pub struct StatsBundle {
153 |     pub health: Health,
154 |     pub damage: Damage,
155 |     pub speed: MovementSpeed,
156 |     pub xp: XP,
157 |     pub cooldown: Cooldown,
158 | }
159 | 
160 | pub fn death_system(
161 |     mut commands: Commands,
162 |     query: Query<(Entity, &Health, Option<&Enemy>)>,
163 |     mut enemy_kill_writer: EventWriter<EnemyKilledEvent>,
164 | ) {
165 |     for (entity, health, enemy) in query.iter() {
166 |         if health.current == 0 {
167 |             if enemy.is_some() {
168 |                 enemy_kill_writer.send(EnemyKilledEvent(entity));
169 |             } else {
170 |                 commands.entity(entity).despawn_recursive();
171 |             }
172 |         }
173 |     }
174 | }
175 | 
176 | //TODO: Move this to a separate file
177 | #[derive(Component)]
178 | pub struct Drop;
179 | 
180 | #[derive(Bundle)]
181 | pub struct XPDropBundle {
182 |     pub drop: Drop,
183 |     pub xp: XP,
184 |     //TODO: Check if this a simple sprite or a sprite sheet animation
185 |     pub sprite_bundle: SpriteBundle,
186 |     pub follow: Follow,
187 |     pub collider: Collider,
188 |     pub collision_events: ActiveEvents,
189 |     pub collision_types: ActiveCollisionTypes,
190 |     pub collision_groups: CollisionGroups,
191 | }
192 | 
193 | impl XPDropBundle {
194 |     pub fn spawn_enemy_drop(
195 |         location: Vec2,
196 |         xp: u32,
197 |         commands: &mut Commands,
198 |         texture: Handle<Image>,
199 |         player: Entity,
200 |     ) -> Entity {
201 |         commands
202 |             .spawn(XPDropBundle {
203 |                 drop: Drop,
204 |                 xp: XP::new(xp),
205 |                 sprite_bundle: SpriteBundle {
206 |                     texture,
207 |                     transform: Transform::from_translation(Vec3::new(location.x, location.y, 3.)),
208 |                     ..Default::default()
209 |                 },
210 |                 follow: Follow::new(player, 2.5, false, 0.1),
211 |                 collider: Collider::ball(4.),
212 |                 collision_events: ActiveEvents::COLLISION_EVENTS,
213 |                 collision_types: ActiveCollisionTypes::all(),
214 |                 collision_groups: CollisionGroups::new(BodyLayers::XP_LAYER, BodyLayers::PLAYER),
215 |             })
216 |             .id()
217 |     }
218 | }
219 | 
220 | pub fn drop_xp_system(
221 |     mut commands: Commands,
222 |     mut enemy_kill_reader: EventReader<EnemyKilledEvent>,
223 |     query: Query<(&Transform, &XP), With<Enemy>>,
224 |     game_assets: Res<GameAssets>,
225 |     player_query: Query<Entity, With<Player>>,
226 | ) {
227 |     if let Ok(player) = player_query.get_single() {
228 |         for event in enemy_kill_reader.read() {
229 |             if let Ok((transform, xp)) = query.get(event.0) {
230 |                 XPDropBundle::spawn_enemy_drop(
231 |                     transform.translation.xy(),
232 |                     xp.amount,
233 |                     &mut commands,
234 |                     game_assets.xp_texture.clone(),
235 |                     player,
236 |                 );
237 |             }
238 |         }
239 |     }
240 | }
241 | 
242 | pub fn level_up(
243 |     mut query: Query<
244 |         (
245 |             &XP,
246 |             &Progression,
247 |             &mut Health,
248 |             &mut Damage,
249 |             &mut MovementSpeed,
250 |             &mut Level,
251 |         ),
252 |         With<Player>,
253 |     >,
254 | ) {
255 |     for (xp, progression, mut health, mut damage, mut speed, mut level) in query.iter_mut() {
256 |         if xp.amount >= progression.xp_to_level_up(level.level as i32) {
257 |             //TODO: Add proper stats progression
258 |             health.max += (health.max as f32 * progression.multiplier / 100.) as u32;
259 |             health.current = health.max;
260 | 
261 |             speed.speed += (speed.speed as f32 * progression.multiplier / 100.) as u32;
262 | 
263 |             damage.amount += (damage.amount as f32 * progression.multiplier / 50.) as u32;
264 | 
265 |             level.level += 1;
266 |         }
267 |     }
268 | }
269 | 
270 | pub fn revenge_mode(
271 |     mut query: Query<(&mut Revenge, &mut Damage, &mut MovementSpeed)>,
272 |     time: Res<Time>,
273 | ) {
274 |     for (mut revenge, mut damage, mut speed) in query.iter_mut() {
275 |         if revenge.active {
276 |             if revenge.amount <= 0. {
277 |                 damage.amount = (damage.amount as f32 / 1.5) as u32;
278 |                 speed.speed = (speed.speed as f32 / 1.5) as u32;
279 |                 revenge.active = false;
280 |             }
281 |         } else if revenge.amount >= revenge.total {
282 |             damage.amount = (damage.amount as f32 * 1.5) as u32;
283 |             speed.speed = (speed.speed as f32 * 1.5) as u32;
284 |             revenge.active = true;
285 |         }
286 | 
287 |         let decay = revenge.decay() * time.delta_seconds();
288 | 
289 |         if revenge.amount > revenge.total {
290 |             revenge.amount = revenge.total;
291 |         }
292 | 
293 |         if revenge.amount > decay {
294 |             revenge.amount -= decay;
295 |         } else {
296 |             revenge.amount = 0.;
297 |         }
298 |     }
299 | }
300 | 


--------------------------------------------------------------------------------
/src/floor.rs:
--------------------------------------------------------------------------------
  1 | use std::collections::BTreeMap;
  2 | use std::time::Duration;
  3 | 
  4 | use bevy::hierarchy::DespawnRecursiveExt;
  5 | use bevy::input::ButtonInput;
  6 | use bevy::prelude::{
  7 |     in_state, Camera, Event, IntoSystemConfigs, Query, Transform, Update, With, Without, World,
  8 | };
  9 | use bevy::time::Timer;
 10 | use bevy::{
 11 |     math::Vec2,
 12 |     prelude::{
 13 |         App, Commands, Entity, EventReader, EventWriter, KeyCode, Plugin, Res, ResMut, Resource,
 14 |     },
 15 | };
 16 | use leafwing_manifest::manifest::Manifest;
 17 | use noisy_bevy::simplex_noise_2d;
 18 | use turborand::rng::Rng;
 19 | use turborand::TurboRand;
 20 | 
 21 | use crate::boss::BossBundle;
 22 | use crate::enemy::state_machine::Idle;
 23 | use crate::manifest::boss::BossManifest;
 24 | use crate::manifest::enemy::EnemyManifest;
 25 | use crate::manifest::floor::{DomainData, DomainManifest};
 26 | use crate::map::generation::open_level_portal;
 27 | use crate::map::walkable::travel_through_portal;
 28 | use crate::player::Player;
 29 | use crate::ui::boss::DomainName;
 30 | use crate::{enemy::EnemyBundle, GameState};
 31 | 
 32 | #[derive(Default, Resource)]
 33 | pub struct FloorResource {
 34 |     pub floor: u32,
 35 |     pub domain: Option<DomainData>,
 36 |     pub enemies: Vec<Entity>,
 37 |     pub boss: Option<Entity>,
 38 | }
 39 | 
 40 | //Floor Generation Events
 41 | #[derive(Event)]
 42 | pub struct GenerateFloorEvent;
 43 | 
 44 | #[derive(Event)]
 45 | pub struct SpawnFloorEntitiesEvent {
 46 |     pub spawnable_pos: Vec<Vec2>,
 47 |     pub player_pos: Vec2,
 48 |     pub portal_pos: Vec2,
 49 | }
 50 | 
 51 | //Floor Clearing Events
 52 | #[derive(Event)]
 53 | pub struct EnemyKilledEvent(pub Entity); // Entity killed
 54 | 
 55 | #[derive(Event)]
 56 | pub struct FloorClearedEvent; // All enemies killed
 57 | 
 58 | #[derive(Event)]
 59 | pub struct TriggerNextFloorEvent; // Player triggered next level
 60 | 
 61 | pub struct FloorPlugin;
 62 | 
 63 | impl Plugin for FloorPlugin {
 64 |     fn build(&self, app: &mut App) {
 65 |         app.insert_resource(FloorResource::default())
 66 |             .add_event::<GenerateFloorEvent>()
 67 |             .add_event::<SpawnFloorEntitiesEvent>()
 68 |             .add_event::<EnemyKilledEvent>()
 69 |             .add_event::<FloorClearedEvent>()
 70 |             .add_event::<TriggerNextFloorEvent>()
 71 |             .add_systems(
 72 |                 Update,
 73 |                 (
 74 |                     new_domain_trigger,
 75 |                     move_player,
 76 |                     enemy_killed,
 77 |                     spawn_enemies,
 78 |                     spawn_boss,
 79 |                     generate_floor,
 80 |                     keymap_generate,
 81 |                     open_level_portal,
 82 |                     travel_through_portal,
 83 |                 )
 84 |                     .run_if(in_state(GameState::InGame)),
 85 |             );
 86 |     }
 87 | }
 88 | 
 89 | fn keymap_generate(
 90 |     keys: Res<ButtonInput<KeyCode>>,
 91 |     mut writer: EventWriter<TriggerNextFloorEvent>,
 92 | ) {
 93 |     if keys.just_pressed(KeyCode::ControlLeft) {
 94 |         writer.send(TriggerNextFloorEvent);
 95 |     }
 96 | }
 97 | 
 98 | fn new_domain_trigger(
 99 |     mut commands: Commands,
100 |     mut event: EventReader<GenerateFloorEvent>,
101 |     floor: Res<FloorResource>,
102 | ) {
103 |     if event.is_empty() {
104 |         return;
105 |     }
106 | 
107 |     if let Some(domain) = &floor.domain {
108 |         if floor.floor == domain.floors.0 {
109 |             commands.spawn(DomainName(
110 |                 domain.name.clone(),
111 |                 Timer::new(Duration::from_secs(3), bevy::time::TimerMode::Once),
112 |             ));
113 |         }
114 |     }
115 | 
116 |     event.clear();
117 | }
118 | 
119 | fn generate_floor(
120 |     mut event: EventReader<TriggerNextFloorEvent>,
121 |     mut writer: EventWriter<GenerateFloorEvent>,
122 |     mut floor_resource: ResMut<FloorResource>,
123 |     domain_manifest: Res<DomainManifest>,
124 | ) {
125 |     for _ in event.read() {
126 |         floor_resource.floor += 1;
127 | 
128 |         //TODO: Optimize this
129 |         let domain = domain_manifest
130 |             .domains
131 |             .values()
132 |             .find_map(|domain| {
133 |                 if floor_resource.floor >= domain.floors.0
134 |                     && floor_resource.floor <= domain.floors.1
135 |                 {
136 |                     Some(domain)
137 |                 } else {
138 |                     None
139 |                 }
140 |             })
141 |             .expect("No floor found");
142 | 
143 |         floor_resource.domain = Some(domain.clone());
144 |         writer.send(GenerateFloorEvent);
145 |     }
146 | }
147 | 
148 | fn move_player(
149 |     mut player_query: Query<&mut Transform, (With<Player>, Without<Camera>)>,
150 |     mut camera_query: Query<&mut Transform, (With<Camera>, Without<Player>)>,
151 |     mut event: EventReader<SpawnFloorEntitiesEvent>,
152 | ) {
153 |     for e in event.read() {
154 |         let pos = e.player_pos;
155 | 
156 |         if let Ok(mut transform) = player_query.get_single_mut() {
157 |             transform.translation.x = pos.x;
158 |             transform.translation.y = pos.y;
159 |         }
160 | 
161 |         if let Ok(mut transform) = camera_query.get_single_mut() {
162 |             transform.translation.x = pos.x;
163 |             transform.translation.y = pos.y;
164 |         }
165 |     }
166 | }
167 | 
168 | fn spawn_boss(
169 |     mut commands: Commands,
170 |     boss_manifest: Res<BossManifest>,
171 |     mut floor: ResMut<FloorResource>,
172 |     mut event: EventReader<SpawnFloorEntitiesEvent>,
173 | ) {
174 |     for e in event.read() {
175 |         if let Some(domain) = &floor.domain {
176 |             if domain.floors.1 != floor.floor {
177 |                 return;
178 |             }
179 | 
180 |             if let Some(boss) = boss_manifest.get_by_name(domain.boss.clone()) {
181 |                 floor.boss = Some(
182 |                     commands
183 |                         .spawn(BossBundle::new(boss, e.portal_pos.extend(38.0)))
184 |                         .insert(Idle)
185 |                         .id(),
186 |                 );
187 |             }
188 |         }
189 |     }
190 | }
191 | 
192 | fn spawn_enemies(
193 |     mut commands: Commands,
194 |     enemy_manifest: Res<EnemyManifest>,
195 |     mut floor: ResMut<FloorResource>,
196 |     mut event: EventReader<SpawnFloorEntitiesEvent>,
197 | ) {
198 |     for e in event.read() {
199 |         if let Some(domain) = &floor.domain {
200 |             if domain.floors.1 == floor.floor {
201 |                 return;
202 |             }
203 | 
204 |             let rand = Rng::new();
205 |             let spawnable_pos = &e.spawnable_pos;
206 | 
207 |             let spawnable_enemies = domain.enemies.clone();
208 |             let enemy_count = rand.u32(domain.enemies_count.0..=domain.enemies_count.1);
209 |             let weight_count = spawnable_enemies.iter().map(|e| e.0).sum::<u32>();
210 | 
211 |             let mut pos_noise = spawnable_pos
212 |                 .iter()
213 |                 .map(|p| ((simplex_noise_2d(*p) * 100.) as i32, p))
214 |                 .collect::<BTreeMap<i32, &Vec2>>();
215 | 
216 |             for _ in 0..enemy_count {
217 |                 if let Some(pos) = pos_noise.pop_last() {
218 |                     let mut weight = rand.u32(0..=weight_count) as i32;
219 | 
220 |                     for enemy in spawnable_enemies.iter() {
221 |                         weight -= enemy.0 as i32;
222 |                         if weight > 0 {
223 |                             continue;
224 |                         }
225 | 
226 |                         if let Some(enemy_data) = enemy_manifest.get_by_name(enemy.1.clone()) {
227 |                             floor.enemies.push(
228 |                                 commands
229 |                                     .spawn(EnemyBundle::new(enemy_data, pos.1.extend(38.0)))
230 |                                     .insert(Idle)
231 |                                     .id(),
232 |                             );
233 |                         }
234 | 
235 |                         break;
236 |                     }
237 |                 }
238 |             }
239 |         }
240 |     }
241 | }
242 | 
243 | fn enemy_killed(
244 |     mut event: EventReader<EnemyKilledEvent>,
245 |     mut level: ResMut<FloorResource>,
246 |     mut portal_writer: EventWriter<FloorClearedEvent>,
247 |     mut commands: Commands,
248 | ) {
249 |     for killed in event.read() {
250 |         level.enemies.retain(|e| *e != killed.0);
251 | 
252 |         //        commands.entity(killed.0).despawn_recursive();
253 |         if let Some(ec) = commands.get_entity(killed.0) {
254 |             ec.despawn_recursive();
255 |         }
256 | 
257 |         if level.enemies.is_empty() {
258 |             portal_writer.send(FloorClearedEvent);
259 |         }
260 |     }
261 | }
262 | 


--------------------------------------------------------------------------------
/src/movement/easing.rs:
--------------------------------------------------------------------------------
  1 | use bevy::{
  2 |     math::Vec3Swizzles,
  3 |     prelude::{Commands, Component, Entity, Query, Res, Transform, Vec2},
  4 |     time::Time,
  5 | };
  6 | 
  7 | #[allow(dead_code)]
  8 | pub enum EaseFunction {
  9 |     EaseInSine,
 10 |     EaseOutSine,
 11 |     EaseInOutSine,
 12 |     EaseInQuad,
 13 |     EaseOutQuad,
 14 |     EaseInOutQuad,
 15 |     EaseInCubic,
 16 |     EaseOutCubic,
 17 |     EaseInOutCubic,
 18 |     EaseInQuart,
 19 |     EaseOutQuart,
 20 |     EaseInOutQuart,
 21 |     EaseInQuint,
 22 |     EaseOutQuint,
 23 |     EaseInOutQuint,
 24 |     EaseInExpo,
 25 |     EaseOutExpo,
 26 |     EaseInOutExpo,
 27 |     EaseInCirc,
 28 |     EaseOutCirc,
 29 |     EaseInOutCirc,
 30 |     EaseInBack,
 31 |     EaseOutBack,
 32 |     EaseInOutBack,
 33 |     EaseInElastic,
 34 |     EaseOutElastic,
 35 |     EaseInOutElastic,
 36 |     EaseInBounce,
 37 |     EaseOutBounce,
 38 |     EaseInOutBounce,
 39 | }
 40 | 
 41 | #[derive(Component)]
 42 | pub struct EaseTo {
 43 |     pub position: Vec2,
 44 |     pub function: EaseFunction,
 45 |     pub duration: f32,
 46 |     pub(crate) elapsed: f32,
 47 |     pub(crate) start: Option<Vec2>,
 48 | }
 49 | 
 50 | impl EaseTo {
 51 |     pub fn new(position: Vec2, function: EaseFunction, duration: f32) -> Self {
 52 |         Self {
 53 |             position,
 54 |             function,
 55 |             duration,
 56 |             elapsed: 0.0,
 57 |             start: None,
 58 |         }
 59 |     }
 60 | }
 61 | 
 62 | pub fn ease_to_position(
 63 |     mut query: Query<(&mut Transform, &mut EaseTo, Entity)>,
 64 |     time: Res<Time>,
 65 |     mut commands: Commands,
 66 | ) {
 67 |     for (mut transform, mut ease, entity) in query.iter_mut() {
 68 |         if ease.start.is_none() {
 69 |             ease.start = Some(transform.translation.xy());
 70 |         }
 71 | 
 72 |         let percentage = ease.elapsed / ease.duration;
 73 | 
 74 |         transform.translation = ease
 75 |             .start
 76 |             .expect("EaseTo start position was not set")
 77 |             .lerp(ease.position, ease_function(percentage, &ease.function))
 78 |             .extend(transform.translation.z);
 79 | 
 80 |         ease.elapsed += time.delta_seconds();
 81 | 
 82 |         //TODO: Make the threshold value configurable
 83 |         if transform.translation.xy().distance(ease.position) < 1.5 {
 84 |             transform.translation = ease.position.extend(transform.translation.z);
 85 |             commands.entity(entity).remove::<EaseTo>();
 86 |         }
 87 |     }
 88 | }
 89 | 
 90 | fn ease_function(x: f32, function: &EaseFunction) -> f32 {
 91 |     match function {
 92 |         EaseFunction::EaseInSine => ease_in_sine(x),
 93 |         EaseFunction::EaseOutSine => ease_out_sine(x),
 94 |         EaseFunction::EaseInOutSine => ease_in_out_sine(x),
 95 |         EaseFunction::EaseInQuad => ease_in_quad(x),
 96 |         EaseFunction::EaseOutQuad => ease_out_quad(x),
 97 |         EaseFunction::EaseInOutQuad => ease_in_out_quad(x),
 98 |         EaseFunction::EaseInCubic => ease_in_cubic(x),
 99 |         EaseFunction::EaseOutCubic => ease_out_cubic(x),
100 |         EaseFunction::EaseInOutCubic => ease_in_out_cubic(x),
101 |         EaseFunction::EaseInQuart => ease_in_quart(x),
102 |         EaseFunction::EaseOutQuart => ease_out_quart(x),
103 |         EaseFunction::EaseInOutQuart => ease_in_out_quart(x),
104 |         EaseFunction::EaseInQuint => ease_in_quint(x),
105 |         EaseFunction::EaseOutQuint => ease_out_quint(x),
106 |         EaseFunction::EaseInOutQuint => ease_in_out_quint(x),
107 |         EaseFunction::EaseInExpo => ease_in_expo(x),
108 |         EaseFunction::EaseOutExpo => ease_out_expo(x),
109 |         EaseFunction::EaseInOutExpo => ease_in_out_expo(x),
110 |         EaseFunction::EaseInCirc => ease_in_circ(x),
111 |         EaseFunction::EaseOutCirc => ease_out_circ(x),
112 |         EaseFunction::EaseInOutCirc => ease_in_out_circ(x),
113 |         EaseFunction::EaseInBack => ease_in_back(x),
114 |         EaseFunction::EaseOutBack => ease_out_back(x),
115 |         EaseFunction::EaseInOutBack => ease_in_out_back(x),
116 |         EaseFunction::EaseInElastic => ease_in_elastic(x),
117 |         EaseFunction::EaseOutElastic => ease_out_elastic(x),
118 |         EaseFunction::EaseInOutElastic => ease_in_out_elastic(x),
119 |         EaseFunction::EaseInBounce => ease_in_bounce(x),
120 |         EaseFunction::EaseOutBounce => ease_out_bounce(x),
121 |         EaseFunction::EaseInOutBounce => ease_in_out_bounce(x),
122 |     }
123 | }
124 | 
125 | fn ease_in_sine(x: f32) -> f32 {
126 |     1. - (1. - x).cos()
127 | }
128 | 
129 | fn ease_out_sine(x: f32) -> f32 {
130 |     x.sin()
131 | }
132 | 
133 | fn ease_in_out_sine(x: f32) -> f32 {
134 |     -(0.5 * (x * std::f32::consts::PI - 0.5).cos())
135 | }
136 | 
137 | fn ease_in_quad(x: f32) -> f32 {
138 |     x * x
139 | }
140 | 
141 | fn ease_out_quad(x: f32) -> f32 {
142 |     1. - (1. - x) * (1. - x)
143 | }
144 | 
145 | fn ease_in_out_quad(x: f32) -> f32 {
146 |     if x < 0.5 {
147 |         2. * x * x
148 |     } else {
149 |         1. - (-2. * x + 2.).powi(2) / 2.
150 |     }
151 | }
152 | 
153 | fn ease_in_cubic(x: f32) -> f32 {
154 |     x * x * x
155 | }
156 | 
157 | fn ease_out_cubic(x: f32) -> f32 {
158 |     1. - (1. - x).powi(3)
159 | }
160 | 
161 | fn ease_in_out_cubic(x: f32) -> f32 {
162 |     if x < 0.5 {
163 |         4. * x * x * x
164 |     } else {
165 |         1. - (-2. * x + 2.).powi(3) / 2.
166 |     }
167 | }
168 | 
169 | fn ease_in_quart(x: f32) -> f32 {
170 |     x * x * x * x
171 | }
172 | 
173 | fn ease_out_quart(x: f32) -> f32 {
174 |     1. - (1. - x).powi(4)
175 | }
176 | 
177 | fn ease_in_out_quart(x: f32) -> f32 {
178 |     if x < 0.5 {
179 |         8. * x * x * x * x
180 |     } else {
181 |         1. - (-2. * x + 2.).powi(4) / 2.
182 |     }
183 | }
184 | 
185 | fn ease_in_quint(x: f32) -> f32 {
186 |     x * x * x * x * x
187 | }
188 | 
189 | fn ease_out_quint(x: f32) -> f32 {
190 |     1. - (1. - x).powi(5)
191 | }
192 | 
193 | fn ease_in_out_quint(x: f32) -> f32 {
194 |     if x < 0.5 {
195 |         16. * x * x * x * x * x
196 |     } else {
197 |         1. - (-2. * x + 2.).powi(5) / 2.
198 |     }
199 | }
200 | 
201 | fn ease_in_expo(x: f32) -> f32 {
202 |     if x == 0. {
203 |         0.
204 |     } else {
205 |         2f32.powf(10. * x - 10.)
206 |     }
207 | }
208 | 
209 | fn ease_out_expo(x: f32) -> f32 {
210 |     if x == 1. {
211 |         1.
212 |     } else {
213 |         1. - 2f32.powf(-10. * x)
214 |     }
215 | }
216 | 
217 | fn ease_in_out_expo(x: f32) -> f32 {
218 |     if x == 0. {
219 |         0.
220 |     } else if x == 1. {
221 |         1.
222 |     } else if x < 0.5 {
223 |         2f32.powf(20. * x - 10.) / 2.
224 |     } else {
225 |         (2. - 2f32.powf(-20. * x + 10.)) / 2.
226 |     }
227 | }
228 | 
229 | fn ease_in_circ(x: f32) -> f32 {
230 |     1. - (1. - x * x).sqrt()
231 | }
232 | 
233 | fn ease_out_circ(x: f32) -> f32 {
234 |     (1. - (1. - x).powi(2)).sqrt()
235 | }
236 | 
237 | fn ease_in_out_circ(x: f32) -> f32 {
238 |     if x < 0.5 {
239 |         (1. - (1. - 2. * x).powi(2)).sqrt() / 2.
240 |     } else {
241 |         (1. + (2. * x - 1.).powi(2)).sqrt() / 2.
242 |     }
243 | }
244 | 
245 | fn ease_in_back(x: f32) -> f32 {
246 |     2.70158 * x * x * x - 1.70158 * x * x
247 | }
248 | 
249 | fn ease_out_back(x: f32) -> f32 {
250 |     1. - (2.70158 * (1. - x) * (1. - x) * (1. - x) - 1.70158 * (1. - x) * (1. - x))
251 | }
252 | 
253 | fn ease_in_out_back(x: f32) -> f32 {
254 |     if x < 0.5 {
255 |         2. * (2.70158 * x * x * x - 1.70158 * x * x)
256 |     } else {
257 |         1. - 2. * (2.70158 * (1. - x) * (1. - x) * (1. - x) - 1.70158 * (1. - x) * (1. - x))
258 |     }
259 | }
260 | 
261 | fn ease_in_elastic(x: f32) -> f32 {
262 |     if x == 0. {
263 |         0.
264 |     } else if x == 1. {
265 |         1.
266 |     } else {
267 |         -(2f32.powf(10. * x - 10.)) * (2. * std::f32::consts::PI * (x - 0.1) / 0.4).sin()
268 |     }
269 | }
270 | 
271 | fn ease_out_elastic(x: f32) -> f32 {
272 |     if x == 0. {
273 |         0.
274 |     } else if x == 1. {
275 |         1.
276 |     } else {
277 |         2f32.powf(-10. * x) * (2. * std::f32::consts::PI * (x - 0.1) / 0.4).sin() + 1.
278 |     }
279 | }
280 | 
281 | fn ease_in_out_elastic(x: f32) -> f32 {
282 |     if x == 0. {
283 |         0.
284 |     } else if x == 1. {
285 |         1.
286 |     } else if x < 0.5 {
287 |         -(2f32.powf(20. * x - 10.)) * (2. * std::f32::consts::PI * (20. * x - 11.5) / 4.).sin() / 2.
288 |     } else {
289 |         2f32.powf(-20. * x + 10.) * (2. * std::f32::consts::PI * (20. * x - 11.5) / 4.).sin() / 2.
290 |             + 1.
291 |     }
292 | }
293 | 
294 | fn ease_in_bounce(x: f32) -> f32 {
295 |     1. - ease_out_bounce(1. - x)
296 | }
297 | 
298 | fn ease_out_bounce(x: f32) -> f32 {
299 |     if x < 4. / 11. {
300 |         (121. * x * x) / 16.
301 |     } else if x < 8. / 11. {
302 |         (363. / 40. * x * x) - (99. / 10. * x) + 17. / 5.
303 |     } else if x < 9. / 10. {
304 |         (4356. / 361. * x * x) - (35442. / 1805. * x) + 16061. / 1805.
305 |     } else {
306 |         (54. / 5. * x * x) - (513. / 25. * x) + 268. / 25.
307 |     }
308 | }
309 | 
310 | fn ease_in_out_bounce(x: f32) -> f32 {
311 |     if x < 0.5 {
312 |         (1. - ease_out_bounce(1. - 2. * x)) / 2.
313 |     } else {
314 |         (1. + ease_out_bounce(2. * x - 1.)) / 2.
315 |     }
316 | }
317 | 
318 | // Ease in with time startvalue and change
319 | 


--------------------------------------------------------------------------------
/src/player.rs:
--------------------------------------------------------------------------------
  1 | use std::usize;
  2 | 
  3 | use bevy::prelude::MouseButton;
  4 | use bevy::reflect::Reflect;
  5 | use bevy::sprite::{SpriteBundle, TextureAtlas};
  6 | use bevy::{
  7 |     prelude::{default, Bundle, Component, KeyCode, Transform, Vec3},
  8 |     utils::HashMap,
  9 | };
 10 | use bevy_rapier2d::prelude::{
 11 |     ActiveCollisionTypes, ActiveEvents, Collider, CollisionGroups, RigidBody,
 12 | };
 13 | use bevy_spritesheet_animation::prelude::SpritesheetAnimation;
 14 | use leafwing_input_manager::{
 15 |     prelude::{ActionState, InputMap},
 16 |     InputManagerBundle,
 17 | };
 18 | 
 19 | use crate::animation::{Animations, DirectionalAnimations};
 20 | use crate::effects::Shadow;
 21 | use crate::manifest::player::PlayerData;
 22 | use crate::sorting::{self, FeetOffset, YSort};
 23 | use crate::Progression;
 24 | use crate::{
 25 |     attack::Damageable,
 26 |     collision::BodyLayers,
 27 |     controller::Controlled,
 28 |     movement::direction::Direction,
 29 |     state::State,
 30 |     stats::{Cooldown, Damage, Health, MovementSpeed, StatsBundle, XP},
 31 |     PLAYER_Z,
 32 | };
 33 | 
 34 | use crate::stats::{Level, Revenge};
 35 | use leafwing_input_manager::Actionlike;
 36 | 
 37 | #[derive(Component)]
 38 | pub struct Player;
 39 | 
 40 | #[derive(Bundle)]
 41 | pub struct PlayerBundle {
 42 |     player: Player,
 43 |     sprite: SpriteBundle,
 44 |     atlas: TextureAtlas,
 45 |     collider: Collider,
 46 |     controlled: Controlled,
 47 |     rigid_body: RigidBody,
 48 |     animations: DirectionalAnimations,
 49 |     animation: SpritesheetAnimation,
 50 |     collision_events: ActiveEvents,
 51 |     collision_types: ActiveCollisionTypes,
 52 |     collision_groups: CollisionGroups,
 53 |     direction: Direction,
 54 |     state: State,
 55 |     level: Level,
 56 |     revenge: Revenge,
 57 |     stats: StatsBundle,
 58 |     progression: Progression,
 59 |     damageable: Damageable,
 60 |     input: InputManagerBundle<PlayerActions>,
 61 |     ysort: YSort,
 62 |     feet_offset: FeetOffset,
 63 |     shadow: Shadow,
 64 | }
 65 | 
 66 | impl PlayerBundle {
 67 |     pub fn new(data: &PlayerData) -> Self {
 68 |         /* let mut player_animations = HashMap::new();
 69 | 
 70 |                 let mut idle_animations = HashMap::new();
 71 |                 idle_animations.insert(Direction::SOUTH, (0..7).collect());
 72 |                 idle_animations.insert(Direction::EAST, (10..17).collect());
 73 |                 idle_animations.insert(Direction::NORTH, (20..27).collect());
 74 |                 idle_animations.insert(Direction::WEST, (30..37).collect());
 75 | 
 76 |                 let mut walk_animations = HashMap::new();
 77 |                 walk_animations.insert(Direction::SOUTH, (40..47).collect());
 78 |                 walk_animations.insert(Direction::EAST, (50..57).collect());
 79 |                 walk_animations.insert(Direction::NORTH, (60..67).collect());
 80 |                 walk_animations.insert(Direction::WEST, (70..77).collect());
 81 | 
 82 |                 let mut dash_animations = HashMap::new();
 83 |                 dash_animations.insert(Direction::SOUTH, (80..87).collect());
 84 |                 dash_animations.insert(Direction::EAST, (90..97).collect());
 85 |                 dash_animations.insert(Direction::NORTH, (100..107).collect());
 86 |                 dash_animations.insert(Direction::WEST, (110..117).collect());
 87 | 
 88 |                 let mut attack_animations = HashMap::new();
 89 |                 attack_animations.insert(Direction::SOUTH, (120..125).collect());
 90 |                 attack_animations.insert(Direction::EAST, (130..135).collect());
 91 |                 attack_animations.insert(Direction::NORTH, (140..145).collect());
 92 |                 attack_animations.insert(Direction::WEST, (150..155).collect());
 93 | 
 94 |                 let mut attack_animations_1 = HashMap::new();
 95 |                 attack_animations_1.insert(Direction::SOUTH, (160..165).collect());
 96 |                 attack_animations_1.insert(Direction::EAST, (170..175).collect());
 97 |                 attack_animations_1.insert(Direction::NORTH, (180..185).collect());
 98 |                 attack_animations_1.insert(Direction::WEST, (190..195).collect());
 99 | 
100 |                 let mut attack_animations_2 = HashMap::new();
101 |                 attack_animations_2.insert(Direction::SOUTH, (200..209).collect());
102 |                 attack_animations_2.insert(Direction::EAST, (210..219).collect());
103 |                 attack_animations_2.insert(Direction::NORTH, (220..229).collect());
104 |                 attack_animations_2.insert(Direction::WEST, (230..239).collect());
105 | 
106 |                 player_animations.insert(State::Idle, idle_animations);
107 |                 player_animations.insert(State::Walking, walk_animations);
108 |                 player_animations.insert(State::Attacking(0), attack_animations);
109 |                 player_animations.insert(State::Attacking(1), attack_animations_1);
110 |                 player_animations.insert(State::Attacking(2), attack_animations_2);
111 |                 player_animations.insert(State::Dashing, dash_animations);
112 |         */
113 | 
114 |         let feet_offset = data.feet_offset.unwrap_or_default();
115 | 
116 |         PlayerBundle {
117 |             player: Player,
118 |             atlas: TextureAtlas {
119 |                 layout: data.atlas.clone(),
120 |                 index: 0,
121 |             },
122 |             sprite: SpriteBundle {
123 |                 texture: data.texture.clone(),
124 |                 transform: Transform {
125 |                     translation: Vec3::new(0., 0., PLAYER_Z),
126 |                     scale: Vec3::new(0.75, 0.75, 0.75),
127 |                     ..default()
128 |                 },
129 |                 ..default()
130 |             },
131 |             controlled: Controlled { move_to: None },
132 |             collider: Collider::cuboid(data.hitbox.x / 2., data.hitbox.y / 2.),
133 |             rigid_body: RigidBody::KinematicPositionBased,
134 |             //animation_state: AnimationState::new(player_animations, data.frame_duration, true),
135 |             animations: data.animations.clone(),
136 |             //TODO: Fix this to have a default animation or be insert later on
137 |             animation: SpritesheetAnimation::from_id(
138 |                 *data
139 |                     .animations
140 |                     .0
141 |                     .get(&State::Idle)
142 |                     .expect("No IDLE animation found for player")
143 |                     .get(&Direction::SOUTH)
144 |                     .expect("No SOUTH animation found for player"),
145 |             ),
146 |             collision_events: ActiveEvents::COLLISION_EVENTS,
147 |             collision_types: ActiveCollisionTypes::all(),
148 |             collision_groups: CollisionGroups::new(
149 |                 BodyLayers::PLAYER,
150 |                 BodyLayers::XP_LAYER | BodyLayers::ENEMY_ATTACK,
151 |             ),
152 |             direction: Direction::SOUTH,
153 |             state: State::Idle,
154 |             stats: StatsBundle {
155 |                 health: Health::new(data.health),
156 |                 damage: Damage::new(data.damage),
157 |                 speed: MovementSpeed::new(data.speed),
158 |                 xp: XP::new(data.xp),
159 |                 cooldown: Cooldown::new(data.cooldown),
160 |             },
161 |             progression: Progression::new(data.base_xp, data.xp_multiplier),
162 |             level: Level::default(),
163 |             revenge: Revenge {
164 |                 amount: 0.,
165 |                 decay: 4.5,
166 |                 active_decay: 8.,
167 |                 active: false,
168 |                 total: 75.,
169 |             },
170 |             damageable: Damageable,
171 |             input: InputManagerBundle::<PlayerActions> {
172 |                 action_state: ActionState::default(),
173 |                 input_map: Self::default_keybindings(),
174 |             },
175 |             ysort: YSort(sorting::ENTITIES_LAYER),
176 |             feet_offset: FeetOffset(feet_offset),
177 |             shadow: Shadow,
178 |         }
179 |     }
180 | 
181 |     fn default_keybindings() -> InputMap<PlayerActions> {
182 |         //TODO: Check best keybindings
183 |         use PlayerActions::*;
184 |         let mut input_map = InputMap::default();
185 | 
186 |         input_map
187 |             .insert(PlayerActions::MoveUp, KeyCode::KeyW)
188 |             .insert(MoveDown, KeyCode::KeyS)
189 |             .insert(MoveLeft, KeyCode::KeyA)
190 |             .insert(MoveRight, KeyCode::KeyD)
191 |             .insert(Attack, KeyCode::KeyJ)
192 |             .insert(Attack, MouseButton::Left)
193 |             .insert(Dash, KeyCode::Space);
194 | 
195 |         input_map
196 |     }
197 | }
198 | 
199 | #[derive(Actionlike, PartialEq, Eq, Clone, Copy, Hash, Debug, Reflect)]
200 | pub enum PlayerActions {
201 |     MoveUp,
202 |     MoveDown,
203 |     MoveLeft,
204 |     MoveRight,
205 |     Attack,
206 |     Dash,
207 | }
208 | 
209 | impl PlayerActions {
210 |     pub const DIRECTIONS: [Self; 4] = [
211 |         Self::MoveUp,
212 |         Self::MoveDown,
213 |         Self::MoveLeft,
214 |         Self::MoveRight,
215 |     ];
216 | 
217 |     pub fn direction(&self) -> Option<Direction> {
218 |         match self {
219 |             PlayerActions::MoveUp => Some(Direction::NORTH),
220 |             PlayerActions::MoveDown => Some(Direction::SOUTH),
221 |             PlayerActions::MoveLeft => Some(Direction::WEST),
222 |             PlayerActions::MoveRight => Some(Direction::EAST),
223 |             _ => None,
224 |         }
225 |     }
226 | }
227 | 


--------------------------------------------------------------------------------
/src/attack.rs:
--------------------------------------------------------------------------------
  1 | use bevy::prelude::{Event, EventReader};
  2 | use bevy::reflect::Reflect;
  3 | use bevy::render::texture::Image;
  4 | use bevy::sprite::{SpriteBundle, TextureAtlas, TextureAtlasLayout};
  5 | use bevy::time::TimerMode;
  6 | use bevy::{
  7 |     prelude::{
  8 |         default, BuildChildren, Bundle, Commands, Component, DespawnRecursiveExt, Entity, Handle,
  9 |         Quat, Query, Res, Transform, TransformBundle, Vec2, Vec3,
 10 |     },
 11 |     time::{Time, Timer},
 12 | };
 13 | use bevy_rapier2d::prelude::{
 14 |     ActiveCollisionTypes, ActiveEvents, Collider, CollisionGroups, Sensor,
 15 | };
 16 | use seldom_state::prelude::{Done, StateMachine};
 17 | use seldom_state::trigger::done;
 18 | 
 19 | use crate::manifest::AttackData;
 20 | use crate::{
 21 |     collision::BodyLayers,
 22 |     movement::direction::Direction,
 23 |     movement::movement::Velocity,
 24 |     state::State,
 25 |     stats::{Cooldown, Damage},
 26 | };
 27 | 
 28 | #[derive(Component)]
 29 | pub struct Attack;
 30 | 
 31 | #[derive(Component)]
 32 | pub struct Lifetime(pub Timer);
 33 | 
 34 | #[derive(Component)]
 35 | pub struct Breakable(pub u32);
 36 | 
 37 | #[derive(Component)]
 38 | pub struct Damageable;
 39 | 
 40 | #[derive(Component)]
 41 | pub struct Knockback {
 42 |     pub force: f32,
 43 |     pub direction: Direction,
 44 | }
 45 | 
 46 | #[derive(Component, Clone, Reflect)]
 47 | #[component(storage = "SparseSet")]
 48 | pub struct ChargePhase(pub Timer, pub f32); // Timer, attackphase duration for spawning attack
 49 | 
 50 | #[derive(Component, Clone, Reflect)]
 51 | #[component(storage = "SparseSet")]
 52 | pub struct AttackPhase(pub Timer);
 53 | 
 54 | #[derive(Component, Clone, Reflect)]
 55 | #[component(storage = "SparseSet")]
 56 | pub struct RecoverPhase(pub Timer);
 57 | 
 58 | pub fn attack_phase(_charge: f32, attack: f32, recover: f32) -> StateMachine {
 59 |     StateMachine::default()
 60 |         .trans::<ChargePhase, _>(
 61 |             done(Some(Done::Success)),
 62 |             AttackPhase(Timer::from_seconds(attack, TimerMode::Once)),
 63 |         )
 64 |         .trans::<AttackPhase, _>(
 65 |             done(Some(Done::Success)),
 66 |             RecoverPhase(Timer::from_seconds(recover, TimerMode::Once)),
 67 |         )
 68 | }
 69 | 
 70 | #[derive(Component)]
 71 | pub struct EntitiesHit(pub Vec<Entity>);
 72 | 
 73 | /**
 74 |  * Generic attack bundle, missing an transform that can be added alone or with an sprite
 75 |  */
 76 | #[derive(Bundle)]
 77 | struct AttackBundle {
 78 |     attack: Attack,
 79 |     entities_hit: EntitiesHit,
 80 |     collider: Collider,
 81 |     sensor: Sensor,
 82 |     events: ActiveEvents,
 83 |     collision_types: ActiveCollisionTypes,
 84 |     collision_groups: CollisionGroups,
 85 |     lifetime: Lifetime,
 86 |     damage: Damage,
 87 | }
 88 | 
 89 | impl AttackBundle {
 90 |     pub fn new(size: Vec2, duration: f32, damage: Damage, is_player_attack: bool) -> Self {
 91 |         let collision_groups = if is_player_attack {
 92 |             CollisionGroups::new(BodyLayers::PLAYER_ATTACK, BodyLayers::ENEMY)
 93 |         } else {
 94 |             CollisionGroups::new(BodyLayers::ENEMY_ATTACK, BodyLayers::PLAYER)
 95 |         };
 96 | 
 97 |         Self {
 98 |             attack: Attack,
 99 |             entities_hit: EntitiesHit(Vec::new()),
100 |             collider: Collider::cuboid(size.x / 2., size.y / 2.),
101 |             sensor: Sensor,
102 |             events: ActiveEvents::COLLISION_EVENTS,
103 |             collision_types: ActiveCollisionTypes::default()
104 |                 | ActiveCollisionTypes::KINEMATIC_STATIC,
105 |             collision_groups,
106 |             lifetime: Lifetime(Timer::from_seconds(duration, bevy::time::TimerMode::Once)),
107 |             damage,
108 |         }
109 |     }
110 | }
111 | 
112 | #[derive(Bundle)]
113 | pub struct MeleeAttackBundle {
114 |     attack: AttackBundle,
115 |     transform_bundle: TransformBundle,
116 |     knockback: Knockback,
117 | }
118 | 
119 | impl MeleeAttackBundle {
120 |     pub fn new(
121 |         position: Vec3,
122 |         size: Vec2,
123 |         duration: f32,
124 |         damage: Damage,
125 |         knockback: Knockback,
126 |         is_player_attack: bool,
127 |     ) -> Self {
128 |         Self {
129 |             attack: AttackBundle::new(size, duration, damage, is_player_attack),
130 |             transform_bundle: TransformBundle {
131 |                 local: Transform::from_translation(position),
132 |                 ..default()
133 |             },
134 |             knockback,
135 |         }
136 |     }
137 | }
138 | 
139 | #[derive(Bundle)]
140 | pub struct ProjectileBundle {
141 |     attack: AttackBundle,
142 |     texture_atlas: TextureAtlas,
143 |     sprite_bundle: SpriteBundle,
144 |     velocity: Velocity,
145 |     breakable: Breakable,
146 | }
147 | 
148 | impl ProjectileBundle {
149 |     pub fn new(
150 |         texture: Handle<Image>,
151 |         atlas: Handle<TextureAtlasLayout>,
152 |         position: Vec3,
153 |         rotation: f32,
154 |         size: Vec2,
155 |         duration: f32,
156 |         damage: Damage,
157 |         is_player_attack: bool,
158 |         velocity: Velocity,
159 |     ) -> Self {
160 |         Self {
161 |             attack: AttackBundle::new(size, duration, damage, is_player_attack),
162 |             texture_atlas: TextureAtlas {
163 |                 layout: atlas,
164 |                 index: 0,
165 |             },
166 |             sprite_bundle: SpriteBundle {
167 |                 texture: texture.clone(),
168 |                 transform: Transform {
169 |                     translation: position,
170 |                     rotation: Quat::from_rotation_z(rotation),
171 |                     // scale: Vec3::new(size.x, size.y, 1.0),
172 |                     ..default()
173 |                 },
174 |                 ..default()
175 |             },
176 |             velocity,
177 |             breakable: Breakable(1),
178 |         }
179 |     }
180 | }
181 | 
182 | #[derive(Event)]
183 | pub struct SpawnEnemyAttack {
184 |     pub data: AttackData,
185 |     pub position: Vec3,
186 |     pub direction: Vec2,
187 |     pub damage: Damage,
188 |     pub enemy_size: Vec2,
189 | }
190 | 
191 | pub fn attack_spawner(mut event: EventReader<SpawnEnemyAttack>, mut commands: Commands) {
192 |     for spawn_attack in event.read() {
193 |         match &spawn_attack.data {
194 |             AttackData::Melee {
195 |                 size,
196 |                 duration,
197 |                 knockback,
198 |             } => {
199 |                 let direction = Direction::from_vec2(spawn_attack.direction * -1.)
200 |                     .expect("Bad knockback direction");
201 | 
202 |                 let offset = spawn_attack.direction * spawn_attack.enemy_size / 2.;
203 | 
204 |                 commands.spawn(MeleeAttackBundle::new(
205 |                     spawn_attack.position + offset.extend(0.),
206 |                     *size / 2.,
207 |                     *duration,
208 |                     spawn_attack.damage,
209 |                     Knockback {
210 |                         force: *knockback,
211 |                         direction,
212 |                     },
213 |                     false,
214 |                 ));
215 |             }
216 |             AttackData::Ranged {
217 |                 texture,
218 |                 velocity,
219 |                 size,
220 |                 duration,
221 |                 atlas,
222 |             } => {
223 |                 commands.spawn(ProjectileBundle::new(
224 |                     texture.clone(),
225 |                     atlas.clone(),
226 |                     spawn_attack.position,
227 |                     f32::atan2(spawn_attack.direction.y, spawn_attack.direction.x),
228 |                     *size / 2.,
229 |                     *duration,
230 |                     spawn_attack.damage,
231 |                     false,
232 |                     Velocity(spawn_attack.direction * *velocity, false),
233 |                 ));
234 |             }
235 |         }
236 |     }
237 | }
238 | 
239 | pub fn charge_phase_system(
240 |     mut query: Query<(&mut ChargePhase, &Direction, &Damage, Entity)>,
241 |     time: Res<Time>,
242 |     mut commands: Commands,
243 | ) {
244 |     for (mut charge_phase, direction, damage, entity) in query.iter_mut() {
245 |         if charge_phase.0.finished() {
246 |             commands.entity(entity).with_children(|children| {
247 |                 let player_size = Vec2::new(32., 24.) * 0.75;
248 |                 let offset = player_size.x * 0.75;
249 | 
250 |                 children.spawn(MeleeAttackBundle::new(
251 |                     (direction.vec() * offset).extend(10.),
252 |                     player_size,
253 |                     charge_phase.1,
254 |                     *damage,
255 |                     Knockback {
256 |                         force: 7.,
257 |                         direction: *direction,
258 |                     },
259 |                     true,
260 |                 ));
261 |             });
262 | 
263 |             commands.entity(entity).insert(Done::Success);
264 |         } else {
265 |             charge_phase.0.tick(time.delta());
266 |         }
267 |     }
268 | }
269 | 
270 | pub fn attack_phase_system(
271 |     mut query: Query<(&mut AttackPhase, Entity)>,
272 |     time: Res<Time>,
273 |     mut commands: Commands,
274 | ) {
275 |     for (mut attack_phase, entity) in query.iter_mut() {
276 |         if attack_phase.0.finished() {
277 |             commands.entity(entity).insert(Done::Success);
278 |         } else {
279 |             attack_phase.0.tick(time.delta());
280 |         }
281 |     }
282 | }
283 | 
284 | pub fn recover_phase_system(
285 |     mut query: Query<(&mut RecoverPhase, &mut State, Entity)>,
286 |     time: Res<Time>,
287 |     mut commands: Commands,
288 | ) {
289 |     for (mut recover_phase, mut state, entity) in query.iter_mut() {
290 |         if recover_phase.0.finished() {
291 |             state.set(State::Idle);
292 |             commands
293 |                 .entity(entity)
294 |                 .insert(Done::Success)
295 |                 .remove::<StateMachine>()
296 |                 .remove::<RecoverPhase>();
297 |         } else {
298 |             recover_phase.0.tick(time.delta());
299 |         }
300 |     }
301 | }
302 | 
303 | pub fn lifetimes(
304 |     mut commands: Commands,
305 |     mut lifetimes: Query<(Entity, &mut Lifetime)>,
306 |     time: Res<Time>,
307 | ) {
308 |     for (entity, mut lifetime) in lifetimes.iter_mut() {
309 |         lifetime.0.tick(time.delta());
310 | 
311 |         if lifetime.0.finished() {
312 |             commands.entity(entity).despawn_recursive();
313 |         }
314 |     }
315 | }
316 | 
317 | //TODO: Check the collisions in its own system
318 | pub fn projectile_break(mut commands: Commands, query: Query<(Entity, &Breakable)>) {
319 |     for (entity, breakable) in query.iter() {
320 |         if breakable.0 == 0 {
321 |             commands.entity(entity).despawn_recursive();
322 |         }
323 |     }
324 | }
325 | 
326 | pub fn tick_cooldown(mut query: Query<&mut Cooldown>, time: Res<Time>) {
327 |     for mut cooldown in query.iter_mut() {
328 |         cooldown.update(time.delta());
329 |     }
330 | }
331 | 


--------------------------------------------------------------------------------