Remove inactive player

3 files changed, 42 insertions, 1 deletions

diff --git a/server/src/main.rs b/server/src/main.rs
index 3bf39f5a..55085f40 100644
--- a/server/src/main.rs
+++ b/server/src/main.rs
@@ -261,6 +261,11 @@ async fn run(data_path: PathBuf, args: Args) -> anyhow::Result<()> {
                    }
                 };
             }
+            while let Ok(packet) = replies_rx.try_recv() {
+                if send_packet(id, &mut sock, packet).await {
+                    break;
+                };
+            }
             state.write().await.disconnect(id, None);
             sleep(Duration::from_millis(100)).await; // avoids potential godot bug where disconnect packets are lost
         });
diff --git a/server/src/server.rs b/server/src/server.rs
index fc2df029..4c46a280 100644
--- a/server/src/server.rs
+++ b/server/src/server.rs
@@ -79,6 +79,7 @@ pub struct Server {
     pub score_changed: bool,
     pub packet_loopback: VecDeque<PacketS>,
     pub last_movement_update: HashMap<PlayerID, Instant>,
+    pub player_inactivity_timers: HashMap<PlayerID, f32>,
     pub index: DataIndex,
     pub packet_out: VecDeque<PacketC>,
     pub scoreboard: ScoreboardStore,
@@ -105,6 +106,7 @@ impl Server {
             score_changed: false,
             packet_loopback: VecDeque::new(),
             last_movement_update: HashMap::default(),
+            player_inactivity_timers: HashMap::new(),
             scoreboard: ScoreboardStore::load().context("Failed to load scoreboards")?,
             editor_address: None,
             paused: false,
diff --git a/server/src/state.rs b/server/src/state.rs
index 23339543..c9b7e8d4 100644
--- a/server/src/state.rs
+++ b/server/src/state.rs
@@ -32,16 +32,36 @@ use tokio::sync::{broadcast, mpsc};
 impl Server {
     pub fn tick_outer(&mut self, dt: f32) -> anyhow::Result<()> {
         let mut keepalive_kick = Vec::new();
+        let mut inactivity_kick = Vec::new();
         for (cid, conn) in &mut self.connections {
             conn.keepalive_timer += dt;
             if conn.keepalive_timer > KEEPALIVE_INTERVAL + 10. {
                 keepalive_kick.push(*cid);
             }
+            for pid in &conn.players {
+                if let Some(t) = self.player_inactivity_timers.get_mut(pid) {
+                    *t -= dt;
+                    if *t < 0. {
+                        inactivity_kick.push((*cid, *pid));
+                    }
+                }
+            }
         }
         for cid in keepalive_kick {
             warn!("{cid} Client did not send keepalive in time");
             self.disconnect(cid, Some(trm!("s.disconnect_reason.keepalive_timer")));
         }
+        for (cid, pid) in inactivity_kick {
+            if let Some(conn) = self.connections.get(&cid) {
+                let _ = conn.replies.try_send(PacketC::ServerMessage {
+                    message: trm!("s.leave_inactivity"),
+                    error: false,
+                });
+            }
+            if let Err(e) = self.packet_in_outer(cid, PacketS::Leave { player: pid }) {
+                warn!("error when auto-leaving player: {e}")
+            }
+        }
 
         if !self.paused {
             let start = Instant::now();
@@ -144,7 +164,7 @@ impl Server {
         if let Some(p) = get_packet_player(&packet)
             && !conn_data.players.contains(&p)
         {
-            return Err(tre!("s.error.packet_sender_invalid"));
+            return Ok(vec![]);
         }
         let mut replies = Vec::new();
         match &packet {
@@ -173,6 +193,8 @@ impl Server {
                 self.update_paused();
             }
             PacketS::Leave { player } => {
+                self.last_movement_update.remove(player);
+                self.player_inactivity_timers.remove(player);
                 self.connections
                     .get_mut(&conn)
                     .unwrap()
@@ -187,6 +209,16 @@ impl Server {
             PacketS::Keepalive => {
                 conn_data.keepalive_timer = 0.;
             }
+            PacketS::Movement {
+                player, dir, boost, ..
+            } if *boost || dir.length() > 0.5 => {
+                self.player_inactivity_timers
+                    .insert(*player, self.config.inactivity_timeout);
+            }
+            PacketS::Interact { player, .. } | PacketS::Communicate { player, .. } => {
+                self.player_inactivity_timers
+                    .insert(*player, self.config.inactivity_timeout);
+            }
             _ => (),
         }
         self.packet_in(Some(conn), packet, &mut replies)?;
@@ -194,6 +226,8 @@ impl Server {
         for p in &replies {
             if let PacketC::Joined { id } = p {
                 self.connections.get_mut(&conn).unwrap().players.insert(*id);
+                self.player_inactivity_timers
+                    .insert(*id, self.config.inactivity_timeout);
             }
         }