track stats in a singleton, add exp scaling for player attack, spawn player attack with averaged values of absorbed attacks

.idea/runConfigurations/Run_Web_dev.xml

···
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="Run Web dev" type="ShConfigurationType" folderName="Build">
-    <option name="SCRIPT_TEXT" value="bevy run --yes web" />
+    <option name="SCRIPT_TEXT" value="bevy run --yes web --open" />
     <option name="INDEPENDENT_SCRIPT_PATH" value="true" />
     <option name="SCRIPT_PATH" value="" />
     <option name="SCRIPT_OPTIONS" value="" />

.vscode/bevy.code-snippets

···
         "body": [
             "use bevy::prelude::*;",
             "",
-            "pub(super) fn plugin(app: &mut App) {",
+            "pub fn plugin(app: &mut App) {",
             "\t$0",
             "}"
         ]
···
             "}"
         ]
     }
-}
+}

src/asset_tracking.rs

···
 
 use bevy::prelude::*;
 
-pub(super) fn plugin(app: &mut App) {
+pub fn plugin(app: &mut App) {
     app.init_resource::<ResourceHandles>();
     app.add_systems(PreUpdate, load_resource_assets);
 }

src/audio.rs

···
 use bevy::prelude::*;
 
-pub(super) fn plugin(app: &mut App) {
+pub fn plugin(app: &mut App) {
     app.register_type::<Music>();
     app.register_type::<SoundEffect>();
 

src/menus/credits.rs

···
 
 use crate::{asset_tracking::LoadResource, audio::music, menus::Menu, theme::prelude::*};
 
-pub(super) fn plugin(app: &mut App) {
+pub fn plugin(app: &mut App) {
     app.add_systems(OnEnter(Menu::Credits), spawn_credits_menu);
     app.add_systems(
         Update,

src/menus/main.rs

···
 
 use crate::{asset_tracking::ResourceHandles, menus::Menu, screens::Screen, theme::widget};
 
-pub(super) fn plugin(app: &mut App) {
+pub fn plugin(app: &mut App) {
     app.add_systems(OnEnter(Menu::Main), spawn_main_menu);
 }
 

src/menus/mod.rs

···
 
 use bevy::prelude::*;
 
-pub(super) fn plugin(app: &mut App) {
+pub fn plugin(app: &mut App) {
     app.init_state::<Menu>();
 
     app.add_plugins((

src/menus/pause.rs

···
 
 use crate::{menus::Menu, screens::Screen, theme::widget};
 
-pub(super) fn plugin(app: &mut App) {
+pub fn plugin(app: &mut App) {
     app.add_systems(OnEnter(Menu::Pause), spawn_pause_menu);
     app.add_systems(
         Update,

src/menus/settings.rs

···
 
 use crate::{menus::Menu, screens::Screen, theme::prelude::*};
 
-pub(super) fn plugin(app: &mut App) {
+pub fn plugin(app: &mut App) {
     app.add_systems(OnEnter(Menu::Settings), spawn_settings_menu);
     app.add_systems(
         Update,

src/parylord/attack.rs

···
 
 #[derive(Component, Debug, Clone, Copy, PartialEq, Eq, Default, Reflect)]
 #[reflect(Component)]
-pub struct Attack(pub(crate) u8);
+pub struct Attack(pub u8);

src/parylord/enemy.rs

···
 use crate::parylord::health::{DisplayHealth, Health, ZeroHealth};
 use crate::parylord::player::Player;
 use crate::parylord::ttl::Ttl;
-use crate::parylord::CollisionLayer;
+use crate::parylord::{CollisionLayer, ParrylordSingleton};
 use crate::screens::Screen;
 use crate::{AppSystems, PausableSystems};
 use avian2d::prelude::{
···
     mut events: EventReader<SpawnEnemy>,
     mut commands: Commands,
     enemy_assets: Res<EnemyAssets>,
+    singleton: Res<ParrylordSingleton>,
 ) {
     for _ in events.read() {
-        commands.spawn(Enemy::bundle(&enemy_assets, get_random_vec2_in_play_area()));
+        commands.spawn(Enemy::bundle(
+            &enemy_assets,
+            get_random_vec2_in_play_area(),
+            Enemy::BASE_HEALTH.pow(u32::from(singleton.level) - 1),
+        ));
     }
 }
 
···
     }
 }
 
-const DEBUG_STATE_MACHINE: bool = true;
+const DEBUG_STATE_MACHINE: bool = false;
 
 #[tracing::instrument(skip_all)]
 pub fn write_enemy_intents(
···
 }
 
 impl Enemy {
-    const SPEED: f32 = 100.0;
+    const SPEED: f32 = 300.0;
+    const BASE_HEALTH: u8 = 2;
 
     #[tracing::instrument()]
-    pub fn bundle(enemy_assets: &EnemyAssets, position: Vec2) -> impl Bundle {
+    pub fn bundle(enemy_assets: &EnemyAssets, position: Vec2, health: u8) -> impl Bundle {
         let mut rng = thread_rng();
         let pick = rng.gen_range(0..=EnemyAssets::MAX_ASSETS);
         (
             Self::default(),
-            Health(15),
+            Health(health),
             DisplayHealth::bundle(),
             EnemyStateTimer(Timer::from_seconds(2.0, TimerMode::Repeating)),
-            Transform::from_translation(position.extend(1.0)),
+            Transform::from_translation(position.extend(1.0)).with_scale(Vec3::splat(0.8)),
             Sprite {
                 image: match pick % EnemyAssets::MAX_ASSETS {
                     0 => enemy_assets.beige.clone(),
···
             },
             RigidBody::Dynamic,
             LinearVelocity::default(),
-            CollisionEventsEnabled,
             Collider::circle(64.0),
             CollisionLayers::new(
                 [CollisionLayer::Enemy],
                 [
+                    CollisionLayer::Enemy,
                     CollisionLayer::Walls,
-                    CollisionLayer::Player,
                     CollisionLayer::PlayerProjectile,
                     CollisionLayer::PlayerHurt,
                 ],
···
 pub fn handle_dead_enemies(
     dead_enemies: Query<Entity, (With<ZeroHealth>, With<Enemy>)>,
     mut commands: Commands,
+    mut singleton: ResMut<ParrylordSingleton>,
 ) {
     for entity in dead_enemies {
         let Ok(mut entity) = commands.get_entity(entity) else {
             continue;
         };
-        entity.despawn();
+        entity.try_despawn();
+
+        singleton.enemies_killed += 1;
     }
 }
 

src/parylord/health.rs

···
 
 #[derive(Component, Debug, Clone, Copy, PartialEq, Eq, Default, Reflect)]
 #[reflect(Component)]
-pub struct Health(pub i8);
+pub struct Health(pub u8);
 
 #[derive(Component, Debug, Clone, Copy, PartialEq, Eq, Default, Reflect)]
 #[reflect(Component)]

src/parylord/level.rs

···
 use crate::parylord::assets::{LevelAssets, PlayerAssets};
 use crate::parylord::enemy::{Enemy, SpawnEnemy};
 use crate::parylord::player::Player;
-use crate::parylord::{CollisionLayer, ParrylordLevel};
+use crate::parylord::{CollisionLayer, ParrylordSingleton};
 use crate::screens::Screen;
 use crate::PausableSystems;
 use avian2d::prelude::{Collider, CollisionLayers, RigidBody};
 use bevy::prelude::*;
 
-pub(super) fn plugin(app: &mut App) {
+pub fn plugin(app: &mut App) {
     app.register_type::<Level>();
     app.register_type::<EnemySpawn>();
     app.register_type::<LevelAssets>();
···
 fn new_level(
     enemies: Query<(), With<Enemy>>,
     mut spawn_enemy_event_writer: EventWriter<SpawnEnemy>,
-    mut level: ResMut<ParrylordLevel>,
+    mut singleton: ResMut<ParrylordSingleton>,
 ) {
     if !enemies.is_empty() {
         return;
     }
 
-    for _ in 0..level.0 {
+    for _ in 0..singleton.level {
         spawn_enemy_event_writer.write(SpawnEnemy);
     }
 
-    level.0 += 1;
+    singleton.level += 1;
 }
 
 //     let root = context.entity;

src/parylord/mod.rs

···
 pub mod ttl;
 
 pub fn plugin(app: &mut App) {
-    app.init_resource::<ParrylordLevel>();
+    app.init_resource::<ParrylordSingleton>();
 
     app.add_plugins((
         assets::plugin,
···
 
 #[derive(Resource, Clone, Reflect, Debug, Default)]
 #[reflect(Resource)]
-pub struct ParrylordLevel(u8);
+pub struct ParrylordSingleton {
+    pub enemies_killed: u32,
+    pub level: u32,
+    pub max_parried: u32,
+}

src/parylord/player.rs

···
     fn flip_x(&self) -> bool {
         match self {
             Self::Front(_) => false,
-            Self::Walk(dir, _) | Self::Stand(dir) => {
-                !dir.is_sign_positive()
-            }
+            Self::Walk(dir, _) | Self::Stand(dir) => !dir.is_sign_positive(),
         }
     }
 
···
                 continue;
             };
 
-            entity.despawn();
+            entity.try_despawn();
         }
     }
 }
 
 #[tracing::instrument(skip_all)]
-fn handle_player_death(query: Option<Single<(), (With<Player>, With<ZeroHealth>)>>) {
+fn handle_player_death(
+    query: Option<Single<(), (With<Player>, With<ZeroHealth>)>>,
+    next: ResMut<NextState<Screen>>,
+) {
     if query.is_none() {
         return;
     }

src/parylord/player_attack.rs

···
 use crate::parylord::health::{Health, InvincibilityTimer};
 use crate::parylord::player::Player;
 use crate::parylord::ttl::Ttl;
-use crate::parylord::CollisionLayer;
+use crate::parylord::{CollisionLayer, ParrylordSingleton};
 use crate::screens::Screen;
 use crate::{exponential_decay, AppSystems, PausableSystems};
 use avian2d::prelude::{
···
     attack_assets: Res<AttackAssets>,
     window: Single<&Window>,
     camera: Single<(&Camera, &GlobalTransform)>,
+    mut singleton: ResMut<ParrylordSingleton>,
 ) {
     let Some(entities) = entities else {
         return;
     };
 
-    let number_of_entities = entities.len().clamp(0, AttackAssets::MAX as usize - 1); //remove clamp
     let Some(&entity) = entities.first() else {
         warn!("Some(&entity) = entities.get(0)");
         return;
     };
-    let Ok((velocity, _transform, ttl)) = change_components.get(entity) else {
+    let Ok(_) = change_components.get(entity) else {
         warn!("Entity {entity} not in change_components");
         return;
     };
 
-    let pos = entities
+    let Some((sum_speed, sum_pos, sum_ttl, total)) = entities
         .iter()
         .flat_map(|&x| change_components.get(x))
-        .map(|(_, x, _)| x)
-        .map(|x| x.translation)
-        .map(|x| x.truncate())
-        .collect::<Vec<_>>();
-
-    let Some(sum) = pos.iter().copied().reduce(|acc, x| acc + x) else {
+        .map(|(x, y, z)| (x.length(), y.translation, z.0.remaining_secs()))
+        .map(|(x, y, z)| (x, y.truncate(), z, 1u32))
+        .reduce(|(a, b, c, d), (x, y, z, w)| (a + x, b + y, c + z, d + w))
+    else {
         warn!("Some(&sum) = pos.iter().reduce(|acc, x| acc + x)");
         return;
     };
-    let total = pos.len() as f32;
+
+    singleton.max_parried = singleton.max_parried.max(total);
+
+    #[allow(clippy::cast_precision_loss)]
+    let total_f32 = total as f32;
 
     let window = *window;
     let Some(mouse) = window.cursor_position() else {
···
         camera_transform,
     );
     let angle = Vec2::from_angle(angle);
-    let speed = velocity.0.length();
 
-    let pos = sum / total;
-    let velocity = LinearVelocity(angle * speed); // average the speed
-    let ttl = Ttl::new(ttl.0.remaining_secs() + 1.0);
+    let pos = sum_pos / total_f32;
+    let velocity = LinearVelocity(angle * sum_speed / total_f32);
+    let ttl = Ttl::new((sum_ttl / total_f32) + 1.0);
+
+    let power = 2u8.checked_pow(total - 1).unwrap_or(u8::MAX);
 
     commands.spawn(PlayerAttack::bundle(
-        number_of_entities as u8, //remove clamp
+        power,
         &attack_assets,
         pos,
         velocity,
···
         let Ok(mut entity) = commands.get_entity(entity) else {
             continue;
         };
-        entity.despawn();
+        entity.try_despawn();
     }
 }
 
···
                 continue 'outer;
             };
 
-            health.0 -= attack.0 as i8;
+            health.0 = health.0.saturating_sub(attack.0);
 
             commands
                 .entity(entity)
···
             let Ok(mut attack_entity) = commands.get_entity(attack_entity) else {
                 continue;
             };
-            attack_entity.despawn();
+            attack_entity.try_despawn();
         }
     }
 }

src/parylord/ttl.rs

···
 
 #[derive(Component, Debug, Clone, PartialEq, Eq, Default, Reflect)]
 #[reflect(Component)]
-pub struct Ttl(pub(crate) Timer);
+pub struct Ttl(pub Timer);
 
 impl Ttl {
     pub fn new(secs: f32) -> Self {
···
         let Ok(mut entity) = commands.get_entity(timer) else {
             continue;
         };
-        entity.despawn();
+        entity.try_despawn();
     }
 }

src/screens/gameplay.rs

···
 
 use bevy::{input::common_conditions::input_just_pressed, prelude::*, ui::Val::*};
 
-use crate::{Pause, parylord::level::spawn_level, menus::Menu, screens::Screen};
+use crate::{menus::Menu, parylord::level::spawn_level, screens::Screen, Pause};
 
-pub(super) fn plugin(app: &mut App) {
+pub fn plugin(app: &mut App) {
     app.add_systems(OnEnter(Screen::Gameplay), spawn_level);
 
     // Toggle pause on key press.

src/screens/loading.rs

···
 
 use crate::{asset_tracking::ResourceHandles, screens::Screen, theme::prelude::*};
 
-pub(super) fn plugin(app: &mut App) {
+pub fn plugin(app: &mut App) {
     app.add_systems(OnEnter(Screen::Loading), spawn_loading_screen);
 
     app.add_systems(

src/screens/mod.rs

···
 
 use bevy::prelude::*;
 
-pub(super) fn plugin(app: &mut App) {
+pub fn plugin(app: &mut App) {
     app.init_state::<Screen>();
 
     app.add_plugins((

src/screens/splash.rs

···
     prelude::*,
 };
 
-use crate::{AppSystems, screens::Screen, theme::prelude::*};
+use crate::{screens::Screen, theme::prelude::*, AppSystems};
 
-pub(super) fn plugin(app: &mut App) {
+pub fn plugin(app: &mut App) {
     // Spawn splash screen.
     app.insert_resource(ClearColor(SPLASH_BACKGROUND_COLOR));
     app.add_systems(OnEnter(Screen::Splash), spawn_splash_screen);

src/screens/title.rs

···
 
 use crate::{menus::Menu, screens::Screen};
 
-pub(super) fn plugin(app: &mut App) {
+pub fn plugin(app: &mut App) {
     app.add_systems(OnEnter(Screen::Title), open_main_menu);
     app.add_systems(OnExit(Screen::Title), close_menu);
 }

src/theme/interaction.rs

···
 
 use crate::{asset_tracking::LoadResource, audio::sound_effect};
 
-pub(super) fn plugin(app: &mut App) {
+pub fn plugin(app: &mut App) {
     app.register_type::<InteractionPalette>();
     app.add_systems(Update, apply_interaction_palette);
 

src/theme/mod.rs

···
 
 #[allow(unused_imports)]
 pub mod prelude {
-    pub use super::{interaction::InteractionPalette, palette as ui_palette, widget};
+    pub use super::widget;
 }
 
 use bevy::prelude::*;
 
-pub(super) fn plugin(app: &mut App) {
+pub fn plugin(app: &mut App) {
     app.add_plugins(interaction::plugin);
 }