refactor server to use client-lib data model (breaks customers)

1 files changed, 49 insertions, 21 deletions

diff --git a/server/src/state.rs b/server/src/state.rs
index 526f70aa..ecfa0fcb 100644
--- a/server/src/state.rs
+++ b/server/src/state.rs
@@ -15,9 +15,14 @@
     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 */
-use crate::{data::DataIndex, game::Game, ConnectionID};
+use crate::{
+    data::DataIndex,
+    server::{Server, ServerState},
+    ConnectionID,
+};
 use anyhow::{anyhow, bail, Result};
 use clap::{Parser, ValueEnum};
+use hurrycurry_client_lib::Game;
 use hurrycurry_protocol::{Message, PacketC, PacketS, PlayerID};
 use log::{debug, trace};
 use std::{
@@ -31,6 +36,7 @@ pub struct State {
     packet_out: VecDeque<PacketC>,
     tx: Sender<PacketC>,
     connections: HashMap<ConnectionID, HashSet<PlayerID>>,
+    pub server: ServerState,
     pub game: Game,
 }
 
@@ -81,15 +87,24 @@ impl State {
         index.reload()?;
 
         let mut packet_out = VecDeque::new();
-        let mut game = Game::new();
-        game.load(
-            index.generate("lobby-none".to_string()).await?,
-            None,
-            &mut packet_out,
-        );
+        let mut game = Game::default();
+        let mut server = ServerState::default();
+
+        {
+            Server {
+                game: &mut game,
+                state: &mut server,
+            }
+            .load(
+                index.generate("lobby-none".to_string()).await?,
+                None,
+                &mut packet_out,
+            );
+        }
 
         Ok(Self {
             game,
+            server,
             index,
             tx,
             packet_out,
@@ -98,8 +113,12 @@ impl State {
     }
 
     pub async fn tick(&mut self, dt: f32) -> anyhow::Result<()> {
-        if self.game.tick(dt, &mut self.packet_out) {
-            self.game.load(
+        let mut server = Server {
+            game: &mut self.game,
+            state: &mut self.server,
+        };
+        if server.tick(dt, &mut self.packet_out) {
+            server.load(
                 self.index.generate("lobby-none".to_string()).await?,
                 None,
                 &mut self.packet_out,
@@ -147,8 +166,11 @@ impl State {
             }
             _ => (),
         }
-        self.game
-            .packet_in(packet, &mut replies, &mut self.packet_out)?;
+        let mut server = Server {
+            game: &mut self.game,
+            state: &mut self.server,
+        };
+        server.packet_in(packet, &mut replies, &mut self.packet_out)?;
 
         for p in &replies {
             match p {
@@ -159,13 +181,13 @@ impl State {
             }
         }
 
-        if self.game.count_chefs() <= 0 && !self.game.lobby {
+        if server.count_chefs() <= 0 && !server.state.lobby {
             self.tx
                 .send(PacketC::ServerMessage {
                     text: "Game was aborted automatically due to a lack of players".to_string(),
                 })
                 .ok();
-            self.game.load(
+            server.load(
                 self.index.generate("lobby-none".to_string()).await?,
                 None,
                 &mut self.packet_out,
@@ -197,18 +219,22 @@ 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?;
-                self.game
-                    .load(data, Some(Duration::from_secs(timer)), &mut self.packet_out);
+                server.load(data, Some(Duration::from_secs(timer)), &mut self.packet_out);
             }
             Command::End => {
                 self.tx
                     .send(PacketC::ServerMessage {
                         text: format!(
                             "Game was aborted by {}.",
-                            self.game
+                            server
+                                .game
                                 .players
                                 .get(&player)
                                 .ok_or(anyhow!("player missing"))?
@@ -216,18 +242,20 @@ impl State {
                         ),
                     })
                     .ok();
-                self.game.load(
+                server.load(
                     self.index.generate("lobby-none".to_string()).await?,
                     None,
                     &mut self.packet_out,
                 );
             }
             Command::Reload => {
-                if self.game.count_chefs() > 1 {
+                if server.count_chefs() > 1 {
                     bail!("must be at most one player to reload");
                 }
-                self.game.load(
-                    self.index.generate(self.game.data.spec.to_string()).await?,
+                server.load(
+                    self.index
+                        .generate(server.state.data.spec.to_string())
+                        .await?,
                     None,
                     &mut self.packet_out,
                 );
@@ -259,7 +287,7 @@ impl State {
                     .ok();
             }
             Command::Item { name } => {
-                let item = self
+                let item = server
                     .game
                     .data
                     .get_item_by_name(&name)