merge ServerState and State

3 files changed, 104 insertions, 170 deletions

diff --git a/server/src/main.rs b/server/src/main.rs
index 40ea3433..797e21f9 100644
--- a/server/src/main.rs
+++ b/server/src/main.rs
@@ -19,7 +19,11 @@ use anyhow::{anyhow, Result};
 use clap::Parser;
 use futures_util::{SinkExt, StreamExt};
 use hurrycurry_protocol::{PacketC, PacketS, BINCODE_CONFIG, VERSION};
-use hurrycurry_server::{data::DATA_DIR, server::GameServerExt, state::State, ConnectionID};
+use hurrycurry_server::{
+    data::DATA_DIR,
+    server::{GameServerExt, Server},
+    ConnectionID,
+};
 use log::{debug, info, trace, warn, LevelFilter};
 use std::{
     net::SocketAddr,
@@ -100,7 +104,10 @@ async fn run(addr: SocketAddr) -> anyhow::Result<()> {
 
     let (tx, rx) = broadcast::channel::<PacketC>(128 * 1024);
 
-    let state = Arc::new(RwLock::new(State::new(tx).await?));
+    let mut state = Server::new(tx).await?;
+    state.load(state.index.generate("lobby").await?, None);
+    let state = Arc::new(RwLock::new(state));
+
     {
         let state = state.clone();
         spawn(async move {
@@ -108,7 +115,7 @@ async fn run(addr: SocketAddr) -> anyhow::Result<()> {
             let mut tick = interval(Duration::from_secs_f32(dt));
             loop {
                 tick.tick().await;
-                if let Err(e) = state.write().await.tick(dt).await {
+                if let Err(e) = state.write().await.tick_outer(dt).await {
                     warn!("tick failed: {e}");
                 }
             }
@@ -216,7 +223,7 @@ async fn run(addr: SocketAddr) -> anyhow::Result<()> {
                 } else {
                     debug!("<- {id:?} {packet:?}");
                 }
-                let packet_out = match state.write().await.packet_in(id, packet).await {
+                let packet_out = match state.write().await.packet_in_outer(id, packet).await {
                     Ok(packets) => packets,
                     Err(e) => {
                         warn!("client error: {e}");
diff --git a/server/src/server.rs b/server/src/server.rs
index a5d1e1d8..12eca299 100644
--- a/server/src/server.rs
+++ b/server/src/server.rs
@@ -16,9 +16,10 @@
 
 */
 use crate::{
-    data::Serverdata,
+    data::{DataIndex, Serverdata},
     entity::{Entities, EntityContext},
     interaction::{interact, tick_slot, InteractEffect, TickEffect},
+    ConnectionID,
 };
 use anyhow::{anyhow, bail, Result};
 use hurrycurry_client_lib::{Game, Item, Player, Tile};
@@ -30,29 +31,25 @@ use hurrycurry_protocol::{
 use log::{info, warn};
 use rand::random;
 use std::{
-    collections::{HashMap, VecDeque},
+    collections::{HashMap, HashSet, VecDeque},
     sync::Arc,
     time::{Duration, Instant},
 };
+use tokio::sync::broadcast::Sender;
+
+pub struct Server {
+    pub game: Game,
 
-pub struct ServerState {
     pub data: Arc<Serverdata>,
     pub entities: Entities,
     pub player_id_counter: PlayerID,
     pub score_changed: bool,
     pub packet_loopback: VecDeque<PacketS>,
     pub last_movement_update: HashMap<PlayerID, Instant>,
-}
-
-pub struct Server<'a> {
-    pub game: &'a mut Game,
-    pub state: &'a mut ServerState,
-}
-
-impl Default for ServerState {
-    fn default() -> Self {
-        Self::new()
-    }
+    pub index: DataIndex,
+    pub packet_out: VecDeque<PacketC>,
+    pub tx: Sender<PacketC>,
+    pub connections: HashMap<ConnectionID, HashSet<PlayerID>>,
 }
 
 pub trait GameServerExt {
@@ -232,46 +229,48 @@ impl GameServerExt for Game {
     }
 }
 
-impl ServerState {
-    pub fn new() -> Self {
-        Self {
+impl Server {
+    pub async fn new(tx: Sender<PacketC>) -> Result<Self> {
+        let mut index = DataIndex::default();
+        index.reload()?;
+        Ok(Self {
+            game: Game::default(),
+            index,
+            tx,
+            packet_out: VecDeque::new(),
+            connections: HashMap::new(),
             data: Serverdata::default().into(),
             entities: vec![],
             player_id_counter: PlayerID(1),
             score_changed: false,
             packet_loopback: VecDeque::new(),
             last_movement_update: HashMap::default(),
-        }
+        })
     }
 }
-impl Server<'_> {
+impl Server {
     pub fn load(
         &mut self,
         (gamedata, serverdata, entities): (Gamedata, Serverdata, Entities),
         timer: Option<Duration>,
-        packet_out: &mut VecDeque<PacketC>,
     ) {
-        self.game.load(gamedata, &serverdata, timer, packet_out);
-        for mut e in self.state.entities.drain(..) {
+        self.game
+            .load(gamedata, &serverdata, timer, &mut self.packet_out);
+        for mut e in self.entities.drain(..) {
             e.destructor(EntityContext {
-                game: self.game,
-                packet_out,
-                packet_in: &mut self.state.packet_loopback,
-                score_changed: &mut self.state.score_changed,
+                game: &mut self.game,
+                packet_out: &mut self.packet_out,
+                packet_in: &mut self.packet_loopback,
+                score_changed: &mut self.score_changed,
                 dt: 0.,
                 load_map: &mut None,
             });
         }
-        self.state.data = serverdata.into();
-        self.state.entities = entities;
+        self.data = serverdata.into();
+        self.entities = entities;
     }
 
-    pub fn packet_in(
-        &mut self,
-        packet: PacketS,
-        replies: &mut Vec<PacketC>,
-        packet_out: &mut VecDeque<PacketC>,
-    ) -> Result<()> {
+    pub fn packet_in(&mut self, packet: PacketS, replies: &mut Vec<PacketC>) -> Result<()> {
         match packet {
             PacketS::Join {
                 name,
@@ -279,12 +278,12 @@ impl Server<'_> {
                 id,
             } => {
                 let id = id.unwrap_or_else(|| {
-                    let id = self.state.player_id_counter;
-                    self.state.player_id_counter.0 += 1;
+                    let id = self.player_id_counter;
+                    self.player_id_counter.0 += 1;
                     id
                 });
                 self.game
-                    .join_player(id, name, character, &self.state.data, Some(packet_out));
+                    .join_player(id, name, character, &self.data, Some(&mut self.packet_out));
                 replies.push(PacketC::Joined { id })
             }
             PacketS::Leave { player } => {
@@ -300,7 +299,7 @@ impl Server<'_> {
                     let pos = p.movement.position.floor().as_ivec2();
                     if let Some(tile) = self.game.tiles.get_mut(&pos) {
                         if tile.item.is_none() {
-                            packet_out.push_back(PacketC::SetItem {
+                            self.packet_out.push_back(PacketC::SetItem {
                                 location: ItemLocation::Tile(pos),
                                 item: Some(item.kind),
                             });
@@ -308,7 +307,8 @@ impl Server<'_> {
                         }
                     }
                 }
-                packet_out.push_back(PacketC::RemovePlayer { id: player })
+                self.packet_out
+                    .push_back(PacketC::RemovePlayer { id: player })
             }
             PacketS::Movement {
                 pos,
@@ -326,7 +326,6 @@ impl Server<'_> {
 
                 if let Some(pos) = pos {
                     let last_position_update = self
-                        .state
                         .last_movement_update
                         .entry(player)
                         .or_insert_with(|| Instant::now());
@@ -399,9 +398,9 @@ impl Server<'_> {
                         &mut other.item,
                         ItemLocation::Player(pid),
                         None,
-                        packet_out,
+                        &mut self.packet_out,
                         &mut self.game.score,
-                        &mut self.state.score_changed,
+                        &mut self.score_changed,
                         false,
                     )
                 } else {
@@ -419,9 +418,9 @@ impl Server<'_> {
                         &mut player.item,
                         ItemLocation::Player(pid),
                         Some(tile.kind),
-                        packet_out,
+                        &mut self.packet_out,
                         &mut self.game.score,
-                        &mut self.state.score_changed,
+                        &mut self.score_changed,
                         false,
                     )
                 }
@@ -445,7 +444,7 @@ impl Server<'_> {
                         });
                     }
                 }
-                packet_out.push_back(PacketC::Communicate {
+                self.packet_out.push_back(PacketC::Communicate {
                     player,
                     message,
                     timeout: timeout.map(|t| MessageTimeout {
@@ -464,7 +463,7 @@ impl Server<'_> {
                     kind: i,
                     active: None,
                 });
-                packet_out.push_back(PacketC::SetItem {
+                self.packet_out.push_back(PacketC::SetItem {
                     location: ItemLocation::Player(player),
                     item,
                 })
@@ -473,7 +472,7 @@ impl Server<'_> {
                 self.game.score.demands_completed += score.demands_completed;
                 self.game.score.demands_failed += score.demands_failed;
                 self.game.score.points += score.points;
-                self.state.score_changed = true;
+                self.score_changed = true;
             }
             PacketS::ReplayTick { .. } => bail!("packet not supported in this session"),
         }
@@ -481,14 +480,11 @@ impl Server<'_> {
     }
 
     /// Returns true if the game should end
-    pub fn tick(
-        &mut self,
-        dt: f32,
-        packet_out: &mut VecDeque<PacketC>,
-    ) -> Option<(String, Option<Duration>)> {
-        if self.state.score_changed {
-            self.state.score_changed = false;
-            packet_out.push_back(PacketC::Score(self.game.score.clone()));
+    pub fn tick(&mut self, dt: f32) -> Option<(String, Option<Duration>)> {
+        if self.score_changed {
+            self.score_changed = false;
+            self.packet_out
+                .push_back(PacketC::Score(self.game.score.clone()));
         }
 
         for (&pos, tile) in &mut self.game.tiles {
@@ -500,7 +496,7 @@ impl Server<'_> {
                 &mut self.game.score,
             ) {
                 match effect {
-                    TickEffect::Progress(warn) => packet_out.push_back(PacketC::SetProgress {
+                    TickEffect::Progress(warn) => self.packet_out.push_back(PacketC::SetProgress {
                         warn,
                         item: ItemLocation::Tile(pos),
                         progress: tile
@@ -512,12 +508,12 @@ impl Server<'_> {
                             .map(|i| i.progress),
                     }),
                     TickEffect::Produce => {
-                        packet_out.push_back(PacketC::SetProgress {
+                        self.packet_out.push_back(PacketC::SetProgress {
                             warn: false,
                             item: ItemLocation::Tile(pos),
                             progress: None,
                         });
-                        packet_out.push_back(PacketC::SetItem {
+                        self.packet_out.push_back(PacketC::SetItem {
                             location: ItemLocation::Tile(pos),
                             item: tile.item.as_ref().map(|i| i.kind),
                         });
@@ -545,7 +541,7 @@ impl Server<'_> {
         });
 
         for (&pid, player) in &mut self.game.players {
-            packet_out.push_back(PacketC::Movement {
+            self.packet_out.push_back(PacketC::Movement {
                 player: pid,
                 pos: player.movement.position,
                 dir: player.movement.input_direction,
@@ -561,7 +557,7 @@ impl Server<'_> {
                 &mut self.game.score,
             ) {
                 match effect {
-                    TickEffect::Progress(warn) => packet_out.push_back(PacketC::SetProgress {
+                    TickEffect::Progress(warn) => self.packet_out.push_back(PacketC::SetProgress {
                         warn,
                         item: ItemLocation::Player(pid),
                         progress: player
@@ -573,12 +569,12 @@ impl Server<'_> {
                             .map(|i| i.progress),
                     }),
                     TickEffect::Produce => {
-                        packet_out.push_back(PacketC::SetProgress {
+                        self.packet_out.push_back(PacketC::SetProgress {
                             warn: false,
                             item: ItemLocation::Player(pid),
                             progress: None,
                         });
-                        packet_out.push_back(PacketC::SetItem {
+                        self.packet_out.push_back(PacketC::SetItem {
                             location: ItemLocation::Player(pid),
                             item: player.item.as_ref().map(|i| i.kind),
                         });
@@ -608,21 +604,17 @@ impl Server<'_> {
             }
         }
         for player in players_auto_release.drain(..) {
-            let _ = self.packet_in(
-                PacketS::Interact { pos: None, player },
-                &mut vec![],
-                packet_out,
-            );
+            let _ = self.packet_in(PacketS::Interact { pos: None, player }, &mut vec![]);
         }
 
         let mut load_map = None;
-        for entity in self.state.entities.iter_mut() {
+        for entity in self.entities.iter_mut() {
             if let Err(e) = entity.tick(EntityContext {
-                game: self.game,
+                game: &mut self.game,
                 load_map: &mut load_map,
-                packet_out,
-                score_changed: &mut self.state.score_changed,
-                packet_in: &mut self.state.packet_loopback,
+                packet_out: &mut self.packet_out,
+                score_changed: &mut self.score_changed,
+                packet_in: &mut self.packet_loopback,
                 dt,
             }) {
                 warn!("entity tick failed: {e}")
@@ -632,8 +624,8 @@ impl Server<'_> {
             return Some((map, Some(Duration::from_secs(300))));
         }
 
-        while let Some(p) = self.state.packet_loopback.pop_front() {
-            if let Err(e) = self.packet_in(p, &mut vec![], packet_out) {
+        while let Some(p) = self.packet_loopback.pop_front() {
+            if let Err(e) = self.packet_in(p, &mut vec![]) {
                 warn!("internal packet errored: {e}");
             }
         }
@@ -644,14 +636,15 @@ impl Server<'_> {
             self.game.score.time_remaining = (end - now).as_secs_f64();
             if end < now {
                 let relative_score =
-                    (self.game.score.points * 100) / self.state.data.score_baseline.max(1);
+                    (self.game.score.points * 100) / self.data.score_baseline.max(1);
                 self.game.score.stars = match relative_score {
                     100.. => 3,
                     70.. => 2,
                     40.. => 1,
                     _ => 0,
                 };
-                packet_out.push_back(PacketC::Menu(Menu::Score(self.game.score.clone())));
+                self.packet_out
+                    .push_back(PacketC::Menu(Menu::Score(self.game.score.clone())));
                 Some(("lobby".to_string(), None))
             } else {
                 None
diff --git a/server/src/state.rs b/server/src/state.rs
index fe5f846e..ad9eeb1c 100644
--- a/server/src/state.rs
+++ b/server/src/state.rs
@@ -15,32 +15,13 @@
     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 */
-use crate::{
-    data::DataIndex,
-    entity::bot::BotDriver,
-    server::{Server, ServerState},
-    ConnectionID,
-};
+use crate::{entity::bot::BotDriver, server::Server, ConnectionID};
 use anyhow::{anyhow, bail, Result};
 use clap::{Parser, ValueEnum};
 use hurrycurry_bot::algos::ALGO_CONSTRUCTORS;
-use hurrycurry_client_lib::Game;
 use hurrycurry_protocol::{Message, PacketC, PacketS, PlayerID};
 use log::{debug, trace};
-use std::{
-    collections::{HashMap, HashSet, VecDeque},
-    time::Duration,
-};
-use tokio::sync::broadcast::Sender;
-
-pub struct State {
-    index: DataIndex,
-    packet_out: VecDeque<PacketC>,
-    tx: Sender<PacketC>,
-    connections: HashMap<ConnectionID, HashSet<PlayerID>>,
-    pub server: ServerState,
-    pub game: Game,
-}
+use std::time::Duration;
 
 #[derive(Parser)]
 #[clap(multicall = true)]
@@ -85,44 +66,11 @@ enum DownloadType {
     Recipes,
 }
 
-impl State {
-    pub async fn new(tx: Sender<PacketC>) -> Result<Self> {
-        let mut index = DataIndex::default();
-        index.reload()?;
-
-        let mut packet_out = VecDeque::new();
-        let mut game = Game::default();
-        let mut server = ServerState::default();
-
-        {
-            Server {
-                game: &mut game,
-                state: &mut server,
-            }
-            .load(index.generate("lobby").await?, None, &mut packet_out);
-        }
-
-        Ok(Self {
-            game,
-            server,
-            index,
-            tx,
-            packet_out,
-            connections: HashMap::new(),
-        })
-    }
-
-    pub async fn tick(&mut self, dt: f32) -> anyhow::Result<()> {
-        let mut server = Server {
-            game: &mut self.game,
-            state: &mut self.server,
-        };
-        if let Some((name, timer)) = server.tick(dt, &mut self.packet_out) {
-            server.load(
-                self.index.generate(&name).await?,
-                timer,
-                &mut self.packet_out,
-            );
+impl Server {
+    pub async fn tick_outer(&mut self, dt: f32) -> anyhow::Result<()> {
+        let r = self.tick(dt);
+        if let Some((name, timer)) = r {
+            self.load(self.index.generate(&name).await?, timer);
         }
         while let Some(p) = self.packet_out.pop_front() {
             if matches!(p, PacketC::UpdateMap { .. } | PacketC::Movement { .. }) {
@@ -134,7 +82,11 @@ impl State {
         }
         Ok(())
     }
-    pub async fn packet_in(&mut self, conn: ConnectionID, packet: PacketS) -> Result<Vec<PacketC>> {
+    pub async fn packet_in_outer(
+        &mut self,
+        conn: ConnectionID,
+        packet: PacketS,
+    ) -> Result<Vec<PacketC>> {
         if let Some(p) = get_packet_player(&packet) {
             if !self.connections.entry(conn).or_default().contains(&p) {
                 bail!("Packet sent to player that is not owned by this connection.");
@@ -166,11 +118,7 @@ impl State {
             }
             _ => (),
         }
-        let mut server = Server {
-            game: &mut self.game,
-            state: &mut self.server,
-        };
-        server.packet_in(packet, &mut replies, &mut self.packet_out)?;
+        self.packet_in(packet, &mut replies)?;
 
         for p in &replies {
             match p {
@@ -181,17 +129,13 @@ impl State {
             }
         }
 
-        if server.count_chefs() <= 0 && !server.game.lobby {
+        if self.count_chefs() <= 0 && !self.game.lobby {
             self.tx
                 .send(PacketC::ServerMessage {
                     text: "Game was aborted automatically due to a lack of players".to_string(),
                 })
                 .ok();
-            server.load(
-                self.index.generate("lobby").await?,
-                None,
-                &mut self.packet_out,
-            );
+            self.load(self.index.generate("lobby").await?, None);
         }
         Ok(replies)
     }
@@ -199,7 +143,7 @@ impl State {
     pub async fn disconnect(&mut self, conn: ConnectionID) {
         if let Some(players) = self.connections.get(&conn) {
             for player in players.to_owned() {
-                let _ = self.packet_in(conn, PacketS::Leave { player }).await;
+                let _ = self.packet_in_outer(conn, PacketS::Leave { player }).await;
             }
         }
         self.connections.remove(&conn);
@@ -221,22 +165,17 @@ impl State {
     }
 
     async fn handle_command(&mut self, player: PlayerID, command: Command) -> Result<()> {
-        let mut server = Server {
-            game: &mut self.game,
-            state: &mut self.server,
-        };
         match command {
             Command::Start { spec, timer } => {
                 let data = self.index.generate(&spec).await?;
-                server.load(data, Some(Duration::from_secs(timer)), &mut self.packet_out);
+                self.load(data, Some(Duration::from_secs(timer)));
             }
             Command::End => {
                 self.tx
                     .send(PacketC::ServerMessage {
                         text: format!(
                             "Game was aborted by {}.",
-                            server
-                                .game
+                            self.game
                                 .players
                                 .get(&player)
                                 .ok_or(anyhow!("player missing"))?
@@ -244,20 +183,15 @@ impl State {
                         ),
                     })
                     .ok();
-                server.load(
-                    self.index.generate("lobby").await?,
-                    None,
-                    &mut self.packet_out,
-                );
+                self.load(self.index.generate("lobby").await?, None);
             }
             Command::Reload => {
-                if server.count_chefs() > 1 {
+                if self.count_chefs() > 1 {
                     bail!("must be at most one player to reload");
                 }
-                server.load(
-                    self.index.generate(&server.game.data.current_map).await?,
+                self.load(
+                    self.index.generate(&self.game.data.current_map).await?,
                     None,
-                    &mut self.packet_out,
                 );
             }
             Command::ReloadIndex => {
@@ -287,7 +221,7 @@ impl State {
                     .ok();
             }
             Command::Item { name } => {
-                let item = server
+                let item = self
                     .game
                     .data
                     .get_item_by_name(&name)
@@ -306,7 +240,7 @@ impl State {
                     .find(|(name, _)| *name == algo.as_str())
                     .ok_or(anyhow!("algo name unknown"))?;
                 let algo = cons();
-                self.server.entities.push(Box::new(BotDriver::new(
+                self.entities.push(Box::new(BotDriver::new(
                     format!("{}-bot", name.unwrap_or((*aname).to_owned())),
                     51,
                     algo,