From 9d8bf0fde7b12fa77569333d17f310e55df58db9 Mon Sep 17 00:00:00 2001
From: Alexander Foremny <aforemny@posteo.de>
Date: Tue, 19 Mar 2024 06:52:42 +0100
Subject: feat: focus ability

---
 src/server.rs            | 47 +++++++++++++++++-----------
 src/server/entity_map.rs |  6 ++++
 src/shared/ability.rs    | 81 ++++++++++++++++++++++++++++++++++++++++++++++++
 src/shared/buffs.rs      |  1 +
 src/shared/champion.rs   | 19 +++++++-----
 src/shared/cooldown.rs   |  3 ++
 src/shared/stats.rs      |  3 +-
 7 files changed, 134 insertions(+), 26 deletions(-)
 create mode 100644 src/server/entity_map.rs

(limited to 'src')

diff --git a/src/server.rs b/src/server.rs
index b3c2a30..483314d 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -1,4 +1,5 @@
 use crate::protocol::*;
+use crate::server::entity_map::*;
 use crate::server::network::*;
 use crate::shared::ability::*;
 use crate::shared::activation::*;
@@ -13,16 +14,14 @@ use crate::shared::projectile::*;
 use crate::shared::stats::*;
 use crate::shared::*;
 use bevy::prelude::*;
-use bevy::utils::HashMap;
+use bevy::utils::*;
 use lightyear::prelude::*;
 use lightyear::server::events::MessageEvent;
 use rand::Rng;
 
+pub mod entity_map;
 mod network;
 
-#[derive(Resource, Default)]
-struct EntityMap(HashMap<ClientId, Entity>);
-
 pub fn main(transport: TransportConfig) {
     App::new()
         .add_plugins(MinimalPlugins)
@@ -284,7 +283,11 @@ fn imperative_attack_attack(
                     };
                     let base_cooldown = champion.base_cooldown();
                     if cooldown.0[ability_slot].is_zero() {
-                        cooldown.0[ability_slot] = base_cooldown.0[ability_slot];
+                        cooldown.0[ability_slot] = if ability_slot == AbilitySlot::A {
+                            Duration::from_secs_f32(effective_stats.0.attack_speed)
+                        } else {
+                            base_cooldown.0[ability_slot]
+                        };
                         commands.spawn(ProjectileBundle::new(ability.to_projectile(
                             *id,
                             position.0,
@@ -318,12 +321,13 @@ fn imperative_attack_attack(
 }
 
 fn activation(
+    champions: Query<&Champion>,
+    mut commands: Commands,
     entity_map: Res<EntityMap>,
     mut cooldowns: Query<&mut Cooldown>,
-    mut players: Query<(&PlayerId, &mut Activation, &mut Buffs)>,
-    champions: Query<&Champion>,
+    mut players: Query<(&PlayerId, &mut Activation)>,
 ) {
-    for (id, mut activation, mut buffs) in players.iter_mut() {
+    for (id, mut activation) in players.iter_mut() {
         let Some(entity) = entity_map.0.get(&id.0) else {
             *activation = Activation::None;
             continue;
@@ -344,15 +348,11 @@ fn activation(
             *activation = Activation::None;
             continue;
         };
-        match ability {
-            ActivatedAbility::Speed(Speed { duration }) => {
-                let base_cooldown = champion.base_cooldown();
-                if cooldown.0[ability_slot].is_zero() {
-                    cooldown.0[ability_slot] = base_cooldown.0[ability_slot];
-                    buffs.speed = Some(Timer::from_seconds(duration, TimerMode::Once));
-                    *activation = Activation::None;
-                }
-            }
+        let base_cooldown = champion.base_cooldown();
+        if cooldown.0[ability_slot].is_zero() {
+            cooldown.0[ability_slot] = base_cooldown.0[ability_slot];
+            ability.activate()(&mut commands, *id);
+            *activation = Activation::None;
         }
     }
 }
@@ -440,7 +440,7 @@ fn projectile_despawn(
                         free_projectile
                             .position
                             .distance(free_projectile.starting_position)
-                            >= 10000.0,
+                            >= free_projectile.max_distance,
                         None,
                     )
                 }
@@ -527,6 +527,9 @@ fn effective_stats(
         if buffs.speed.is_some() {
             stats.movement_speed *= 1.25;
         }
+        if buffs.haste.is_some() {
+            stats.attack_speed *= 0.5;
+        }
         effective_stats.0 = stats;
         health.0 = health.0.min(effective_stats.0.max_health);
     }
@@ -535,6 +538,9 @@ fn effective_stats(
 fn buffs_tick(mut buffses: Query<&mut Buffs>, time: Res<Time>) {
     let dt = time.delta();
     for mut buffs in buffses.iter_mut() {
+        if let Some(ref mut timer) = &mut buffs.haste {
+            timer.tick(dt);
+        }
         if let Some(ref mut timer) = &mut buffs.slow {
             timer.tick(dt);
         }
@@ -546,6 +552,11 @@ fn buffs_tick(mut buffses: Query<&mut Buffs>, time: Res<Time>) {
 
 fn buffs_despawn(mut buffses: Query<&mut Buffs>) {
     for mut buffs in buffses.iter_mut() {
+        if let Some(timer) = &buffs.haste {
+            if timer.finished() {
+                buffs.haste = None;
+            }
+        }
         if let Some(timer) = &buffs.slow {
             if timer.finished() {
                 buffs.slow = None;
diff --git a/src/server/entity_map.rs b/src/server/entity_map.rs
new file mode 100644
index 0000000..13225fb
--- /dev/null
+++ b/src/server/entity_map.rs
@@ -0,0 +1,6 @@
+use bevy::prelude::*;
+use bevy::utils::*;
+use lightyear::prelude::*;
+
+#[derive(Resource, Default)]
+pub struct EntityMap(pub HashMap<ClientId, Entity>);
diff --git a/src/shared/ability.rs b/src/shared/ability.rs
index 4d45a4d..b841661 100644
--- a/src/shared/ability.rs
+++ b/src/shared/ability.rs
@@ -1,3 +1,5 @@
+use crate::server::entity_map::*;
+use crate::shared::buffs::*;
 use crate::shared::player::*;
 use crate::shared::projectile::*;
 use crate::shared::*;
@@ -55,14 +57,93 @@ impl TargetedAbility {
 
 #[derive(Copy, Clone, PartialEq, Debug, Deserialize, Serialize)]
 pub enum ActivatedAbility {
+    Focus(Focus),
+    Haste(Haste),
     Speed(Speed),
 }
 
+#[derive(Copy, Clone, PartialEq, Debug, Deserialize, Serialize)]
+pub struct Focus {
+    pub duration: f32,
+}
+
+#[derive(Copy, Clone, PartialEq, Debug, Deserialize, Serialize)]
+pub struct Haste {
+    pub duration: f32,
+}
+
 #[derive(Copy, Clone, PartialEq, Debug, Deserialize, Serialize)]
 pub struct Speed {
     pub duration: f32,
 }
 
+pub type ActivatedAbilityActivation = Box<dyn FnOnce(&mut Commands, PlayerId) -> ()>;
+
+impl ActivatedAbility {
+    pub fn activate(self) -> ActivatedAbilityActivation {
+        match self {
+            ActivatedAbility::Focus(focus) => focus_activation(focus),
+            ActivatedAbility::Haste(haste) => haste_activation(haste),
+            ActivatedAbility::Speed(speed) => speed_activation(speed),
+        }
+    }
+}
+
+fn speed_activation(speed: Speed) -> ActivatedAbilityActivation {
+    Box::new(move |commands: &mut Commands, source_id: PlayerId| {
+        commands.add(move |world: &mut World| {
+            world.run_system_once(
+                move |entity_map: Res<EntityMap>, mut buffses: Query<&mut Buffs>| {
+                    let Some(entity_id) = entity_map.0.get(&source_id.0) else {
+                        return;
+                    };
+                    let Ok(mut buffs) = buffses.get_mut(*entity_id) else {
+                        return;
+                    };
+                    buffs.speed = Some(Timer::from_seconds(speed.duration, TimerMode::Once));
+                },
+            )
+        });
+    })
+}
+
+fn haste_activation(haste: Haste) -> ActivatedAbilityActivation {
+    Box::new(move |commands: &mut Commands, source_id: PlayerId| {
+        commands.add(move |world: &mut World| {
+            world.run_system_once(
+                move |entity_map: Res<EntityMap>, mut buffses: Query<&mut Buffs>| {
+                    let Some(entity_id) = entity_map.0.get(&source_id.0) else {
+                        return;
+                    };
+                    let Ok(mut buffs) = buffses.get_mut(*entity_id) else {
+                        return;
+                    };
+                    buffs.haste = Some(Timer::from_seconds(haste.duration, TimerMode::Once));
+                },
+            )
+        });
+    })
+}
+
+fn focus_activation(focus: Focus) -> ActivatedAbilityActivation {
+    Box::new(move |commands: &mut Commands, source_id: PlayerId| {
+        commands.add(move |world: &mut World| {
+            world.run_system_once(
+                move |entity_map: Res<EntityMap>, mut buffses: Query<&mut Buffs>| {
+                    let Some(entity_id) = entity_map.0.get(&source_id.0) else {
+                        return;
+                    };
+                    let Ok(mut buffs) = buffses.get_mut(*entity_id) else {
+                        return;
+                    };
+                    buffs.haste = Some(Timer::from_seconds(focus.duration, TimerMode::Once));
+                    buffs.speed = Some(Timer::from_seconds(focus.duration, TimerMode::Once));
+                },
+            )
+        });
+    })
+}
+
 #[derive(Copy, Clone, PartialEq, Debug, Deserialize, Serialize)]
 pub enum DirectionalAbility {
     Dash(Dash),
diff --git a/src/shared/buffs.rs b/src/shared/buffs.rs
index 4fe033d..e8992d5 100644
--- a/src/shared/buffs.rs
+++ b/src/shared/buffs.rs
@@ -2,6 +2,7 @@ use crate::shared::*;
 
 #[derive(Clone, Component, Default, Debug)]
 pub struct Buffs {
+    pub haste: Option<Timer>,
     pub slow: Option<Timer>,
     pub speed: Option<Timer>,
 }
diff --git a/src/shared/champion.rs b/src/shared/champion.rs
index 05f13ef..da63664 100644
--- a/src/shared/champion.rs
+++ b/src/shared/champion.rs
@@ -33,13 +33,15 @@ impl Champion {
         match self {
             Champion::Meele => BaseStats(Stats {
                 attack_range: 25.,
-                movement_speed: 75.,
+                attack_speed: 0.75,
                 max_health: 150.,
+                movement_speed: 75.,
             }),
             Champion::Ranged => BaseStats(Stats {
                 attack_range: 60.,
-                movement_speed: 85.,
+                attack_speed: 1.5,
                 max_health: 100.,
+                movement_speed: 85.,
             }),
         }
     }
@@ -62,14 +64,17 @@ impl Champion {
                 _ => Ability::Targeted(TargetedAbility::MeeleAttack(MeeleAttack { damage: 5. })),
             },
             Champion::Ranged => match ability_slot {
-                AbilitySlot::Q => Ability::Directional(DirectionalAbility::Spear(Spear {
+                AbilitySlot::E => Ability::Directional(DirectionalAbility::Spear(Spear {
                     max_distance: 250.,
-                    damage: 15.,
+                    damage: 25.,
                 })),
+                AbilitySlot::R => {
+                    Ability::Activated(ActivatedAbility::Focus(Focus { duration: 5. }))
+                }
                 AbilitySlot::G => {
                     Ability::Activated(ActivatedAbility::Speed(Speed { duration: 2.5 }))
                 }
-                _ => Ability::Targeted(TargetedAbility::RangedAttack(RangedAttack { damage: 6. })),
+                _ => Ability::Targeted(TargetedAbility::RangedAttack(RangedAttack { damage: 8. })),
             },
         }
     }
@@ -77,10 +82,10 @@ impl Champion {
     pub fn base_cooldown(self) -> BaseCooldown {
         match self {
             Champion::Meele => {
-                BaseCooldown([0.75, 5., 5., 10., 25., 50., 50.].map(Duration::from_secs_f32))
+                BaseCooldown([0., 5., 5., 10., 25., 50., 50.].map(Duration::from_secs_f32))
             }
             Champion::Ranged => {
-                BaseCooldown([1.25, 5., 5., 10., 25., 50., 50.].map(Duration::from_secs_f32))
+                BaseCooldown([0., 10., 10., 15., 35., 50., 50.].map(Duration::from_secs_f32))
             }
         }
     }
diff --git a/src/shared/cooldown.rs b/src/shared/cooldown.rs
index 8f72520..6995941 100644
--- a/src/shared/cooldown.rs
+++ b/src/shared/cooldown.rs
@@ -4,6 +4,9 @@ use serde::Deserialize;
 use serde::Serialize;
 use std::default::Default;
 
+// TODO `AbilitySlot::A`'s cooldown is unused
+//
+// cf. `Stats`' `attack_speed`
 #[derive(Component, Message, Serialize, Deserialize, Clone, Copy, PartialEq, Debug, Default)]
 pub struct Cooldown(pub [Duration; 7]);
 
diff --git a/src/shared/stats.rs b/src/shared/stats.rs
index bc9a509..239405e 100644
--- a/src/shared/stats.rs
+++ b/src/shared/stats.rs
@@ -3,8 +3,9 @@ use crate::shared::*;
 #[derive(Clone, Copy, Serialize, Deserialize, PartialEq, Debug)]
 pub struct Stats {
     pub attack_range: f32,
-    pub movement_speed: f32,
+    pub attack_speed: f32,
     pub max_health: f32,
+    pub movement_speed: f32,
 }
 
 #[derive(Component, Message, Clone, Copy, Serialize, Deserialize, PartialEq, Debug)]
-- 
cgit v1.2.3