1 files changed, 30 insertions, 10 deletions
diff --git a/server/src/state.rs b/server/src/state.rs
index 20e2bf80..53ca3b42 100644
--- a/server/src/state.rs
+++ b/server/src/state.rs
@@ -18,14 +18,32 @@
 use crate::{message::TrError, server::Server, tre, trm, ConnectionID};
 use anyhow::Result;
 use hurrycurry_protocol::{Message, PacketC, PacketS, PlayerID};
-use log::{debug, trace};
+use log::{debug, info, trace};
 
 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.scoreboard.save().await?;
-            self.load(self.index.generate(&name).await?, timer);
+        let should_pause = self.connections.iter().all(|c| c.1 .1);
+        if should_pause != self.paused {
+            info!("Game paused: {}", should_pause);
+            self.paused = should_pause;
+            for p in self.game.players.keys() {
+                self.packet_out.push_back(PacketC::ServerHint {
+                    position: None,
+                    message: if self.paused {
+                        Some(trm!("s.state.paused"))
+                    } else {
+                        None
+                    },
+                    player: *p,
+                });
+            }
+        }
+        if !self.paused {
+            let r = self.tick(dt);
+            if let Some((name, timer)) = r {
+                self.scoreboard.save().await?;
+                self.load(self.index.generate(&name).await?, timer);
+            }
         }
         while let Some(p) = self.packet_out.pop_front() {
             if matches!(p, PacketC::UpdateMap { .. } | PacketC::Movement { .. }) {
@@ -43,7 +61,7 @@ impl Server {
         packet: PacketS,
     ) -> Result<Vec<PacketC>, TrError> {
         if let Some(p) = get_packet_player(&packet) {
-            if !self.connections.entry(conn).or_default().contains(&p) {
+            if !self.connections.entry(conn).or_default().0.contains(&p) {
                 return Err(tre!("s.error.packet_sender_invalid"));
             }
         }
@@ -65,11 +83,12 @@ impl Server {
                     }
                 }
             }
+            PacketS::Idle { paused } => self.connections.entry(conn).or_default().1 = *paused,
             PacketS::Leave { player } => {
-                self.connections.entry(conn).or_default().remove(player);
+                self.connections.entry(conn).or_default().0.remove(player);
             }
             PacketS::Join { .. } => {
-                if self.connections.entry(conn).or_default().len() > 8 {
+                if self.connections.entry(conn).or_default().0.len() > 8 {
                     return Err(tre!("s.error.conn_too_many_players"));
                 }
             }
@@ -79,7 +98,7 @@ impl Server {
 
         for p in &replies {
             if let PacketC::Joined { id } = p {
-                self.connections.entry(conn).or_default().insert(*id);
+                self.connections.entry(conn).or_default().0.insert(*id);
             }
         }
 
@@ -102,7 +121,7 @@ impl Server {
     }
 
     pub async fn disconnect(&mut self, conn: ConnectionID) {
-        if let Some(players) = self.connections.get(&conn) {
+        if let Some((players, _)) = self.connections.get(&conn) {
             for player in players.clone() {
                 let _ = self.packet_in_outer(conn, PacketS::Leave { player }).await;
             }
@@ -114,6 +133,7 @@ impl Server {
 fn get_packet_player(packet: &PacketS) -> Option<PlayerID> {
     match packet {
         PacketS::Join { .. } => None,
+        PacketS::Idle { .. } => None,
         PacketS::Leave { player } => Some(*player),
         PacketS::Movement { player, .. } => Some(*player),
         PacketS::Interact { player, .. } => Some(*player),