refactor environment effects

5 files changed, 102 insertions, 77 deletions

diff --git a/server/protocol/src/lib.rs b/server/protocol/src/lib.rs
index 2fcc5598..02c6d0b1 100644
--- a/server/protocol/src/lib.rs
+++ b/server/protocol/src/lib.rs
@@ -203,7 +203,9 @@ pub enum PacketC {
     },
     Menu(Menu),
     MovementSync,
-    UpdateEnvironment(Environment),
+    Environment {
+        effects: HashSet<String>,
+    },
 
     /// For use in replay sessions only
     ReplayStart,
@@ -229,13 +231,6 @@ pub struct Score {
     pub instant_recipes: usize,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, Encode, Decode, Default)]
-pub struct Environment {
-    pub rain: f32, // 0-1; clear..raining
-    pub wind: f32, // 0-1; still..stormy
-    pub time: f32, // 0-1; night..morning..noon..evening
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize, Encode, Decode, Copy, PartialEq, Eq, Hash)]
 #[serde(rename_all = "snake_case")]
 pub enum ItemLocation {
diff --git a/server/src/entity/environment_effect.rs b/server/src/entity/environment_effect.rs
new file mode 100644
index 00000000..dcfc08c1
--- /dev/null
+++ b/server/src/entity/environment_effect.rs
@@ -0,0 +1,84 @@
+/*
+    Hurry Curry! - a game about cooking
+    Copyright 2024 metamuffin
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, version 3 of the License only.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+*/
+use super::EntityT;
+use crate::game::Game;
+use hurrycurry_protocol::PacketC;
+use rand::random;
+use serde::{Deserialize, Serialize};
+use std::{
+    collections::VecDeque,
+    time::{Duration, Instant},
+};
+
+#[derive(Clone, Debug, Deserialize, Serialize, Default)]
+pub struct EnvironmentEffect {
+    name: String,
+    #[serde(default = "default_onoff")]
+    on: f32,
+    #[serde(default = "default_onoff")]
+    off: f32,
+    exclusive: bool,
+}
+fn default_onoff() -> f32 {
+    40.
+}
+
+#[derive(Clone, Debug)]
+pub struct EnvironmentEffectController {
+    config: EnvironmentEffect,
+    next_transition: Instant,
+    active: bool,
+}
+
+impl EnvironmentEffectController {
+    pub fn new(config: EnvironmentEffect) -> Self {
+        Self {
+            next_transition: Instant::now() + Duration::from_secs_f32(config.on),
+            active: false,
+            config,
+        }
+    }
+}
+impl EntityT for EnvironmentEffectController {
+    fn tick(
+        &mut self,
+        game: &mut Game,
+        packet_out: &mut VecDeque<PacketC>,
+        _dt: f32,
+    ) -> anyhow::Result<()> {
+        if self.next_transition < Instant::now() {
+            if self.active {
+                self.next_transition +=
+                    Duration::from_secs_f32(self.config.on + (0.5 + random::<f32>()));
+                self.active = false;
+                game.environment_effects.remove(&self.config.name);
+            } else {
+                self.next_transition +=
+                    Duration::from_secs_f32(self.config.off * (0.5 + random::<f32>()));
+                if game.environment_effects.is_empty() || !self.config.exclusive {
+                    self.active = true;
+                    game.environment_effects.insert(self.config.name.clone());
+                }
+            }
+            packet_out.push_back(PacketC::Environment {
+                effects: game.environment_effects.clone(),
+            })
+        }
+        Ok(())
+    }
+}
diff --git a/server/src/entity/mod.rs b/server/src/entity/mod.rs
index d042d458..747dd6b7 100644
--- a/server/src/entity/mod.rs
+++ b/server/src/entity/mod.rs
@@ -17,14 +17,15 @@
 */
 pub mod conveyor;
 pub mod customers;
+pub mod environment_effect;
 pub mod item_portal;
 pub mod player_portal;
-pub mod weather;
 
 use crate::{data::ItemTileRegistry, game::Game, interaction::Recipe};
 use anyhow::{anyhow, Result};
 use conveyor::Conveyor;
 use customers::{demands::generate_demands, Customers};
+use environment_effect::{EnvironmentEffect, EnvironmentEffectController};
 use hurrycurry_protocol::{
     glam::{IVec2, Vec2},
     ItemIndex, PacketC, TileIndex,
@@ -33,7 +34,6 @@ use item_portal::ItemPortal;
 use player_portal::PlayerPortal;
 use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, HashSet, VecDeque};
-use weather::WeatherController;
 
 pub trait EntityT: Clone {
     fn tick(&mut self, game: &mut Game, packet_out: &mut VecDeque<PacketC>, dt: f32) -> Result<()>;
@@ -56,7 +56,7 @@ entities!(
     ItemPortal,
     PlayerPortal,
     Customers,
-    WeatherController
+    EnvironmentEffectController
 );
 
 #[derive(Debug, Clone, Deserialize, Serialize)]
@@ -79,7 +79,7 @@ pub enum EntityDecl {
         to: Vec2,
     },
     Customers {},
-    Weather {},
+    EnvironmentEffect(EnvironmentEffect),
 }
 
 pub fn construct_entity(
@@ -134,6 +134,8 @@ pub fn construct_entity(
                 .collect();
             Entity::Customers(Customers::new(chairs, demands)?)
         }
-        EntityDecl::Weather {} => Entity::WeatherController(WeatherController::default()),
+        EntityDecl::EnvironmentEffect(config) => {
+            Entity::EnvironmentEffectController(EnvironmentEffectController::new(config))
+        }
     })
 }
diff --git a/server/src/entity/weather.rs b/server/src/entity/weather.rs
deleted file mode 100644
index 79ac364f..00000000
--- a/server/src/entity/weather.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-use super::EntityT;
-use crate::{game::Game, InterpolateExt};
-use hurrycurry_protocol::PacketC;
-use rand::{random, seq::IndexedRandom, thread_rng};
-use std::{
-    collections::VecDeque,
-    time::{Duration, Instant},
-};
-
-#[derive(Clone, Debug)]
-pub struct WeatherController {
-    next_event: Instant,
-    event: usize,
-}
-
-impl Default for WeatherController {
-    fn default() -> Self {
-        Self {
-            next_event: Instant::now() + Duration::from_secs(10),
-            event: Default::default(),
-        }
-    }
-}
-impl EntityT for WeatherController {
-    fn tick(
-        &mut self,
-        game: &mut Game,
-        _packet_out: &mut VecDeque<PacketC>,
-        dt: f32,
-    ) -> anyhow::Result<()> {
-        if self.next_event < Instant::now() {
-            self.next_event += Duration::from_secs_f32(30. + random::<f32>() * 40.);
-            if self.event > 0 {
-                self.event = 0;
-            } else {
-                self.event = *[0, 0, 1, 2].choose(&mut thread_rng()).unwrap();
-            }
-        }
-
-        let (rain, wind) = match self.event {
-            0 => (0., 0.),
-            1 => (0.7, 0.),
-            2 => (0., 0.7),
-            _ => (1., 1.),
-        };
-        game.environment.wind.exp_to(wind, dt * 0.05);
-        game.environment.rain.exp_to(rain, dt * 0.15);
-        eprintln!("{:#?}", game.environment);
-        Ok(())
-    }
-}
diff --git a/server/src/game.rs b/server/src/game.rs
index 69272159..d7e62413 100644
--- a/server/src/game.rs
+++ b/server/src/game.rs
@@ -25,8 +25,8 @@ use anyhow::{anyhow, bail, Result};
 use hurrycurry_protocol::{
     glam::{IVec2, Vec2},
     movement::MovementBase,
-    ClientGamedata, Environment, ItemIndex, ItemLocation, Menu, Message, PacketC, PacketS,
-    PlayerID, RecipeIndex, Score, TileIndex,
+    ClientGamedata, ItemIndex, ItemLocation, Menu, Message, PacketC, PacketS, PlayerID,
+    RecipeIndex, Score, TileIndex,
 };
 use log::{info, warn};
 use std::{
@@ -76,8 +76,7 @@ pub struct Game {
     end: Option<Instant>,
     pub lobby: bool,
 
-    pub environment_next_update: Instant,
-    pub environment: Environment,
+    pub environment_effects: HashSet<String>,
     pub score_changed: bool,
     pub score: Score,
 }
@@ -95,13 +94,12 @@ impl Game {
             data: Gamedata::default().into(),
             players: HashMap::new(),
             tiles: HashMap::new(),
-            environment_next_update: Instant::now(),
             walkable: HashSet::new(),
             end: None,
             entities: Arc::new(RwLock::new(vec![])),
             players_spatial_index: SpatialIndex::default(),
             score: Score::default(),
-            environment: Environment::default(),
+            environment_effects: HashSet::default(),
             score_changed: false,
         }
     }
@@ -123,7 +121,7 @@ impl Game {
         }
         self.score = Score::default();
         self.end = None;
-        self.environment = Environment::default();
+        self.environment_effects.clear();
         self.walkable.clear();
     }
     pub fn load(
@@ -222,7 +220,9 @@ impl Game {
                     .collect(),
             },
         });
-        out.push(PacketC::UpdateEnvironment(self.environment.clone()));
+        out.push(PacketC::Environment {
+            effects: self.environment_effects.clone(),
+        });
         for (&id, player) in &self.players {
             out.push(PacketC::AddPlayer {
                 id,
@@ -599,11 +599,6 @@ impl Game {
 
         let now = Instant::now();
 
-        if self.environment_next_update < now {
-            packet_out.push_back(PacketC::UpdateEnvironment(self.environment.clone()));
-            self.environment_next_update += Duration::from_secs(5);
-        }
-
         if let Some(end) = self.end {
             self.score.time_remaining = (end - now).as_secs_f64();
             if end < now {