1 files changed, 44 insertions, 28 deletions

diff --git a/server/src/server.rs b/server/src/server.rs
index 9141bc4e..2c01b496 100644
--- a/server/src/server.rs
+++ b/server/src/server.rs
@@ -25,7 +25,11 @@ use crate::{
 use anyhow::{Context, Result};
 use hurrycurry_client_lib::{Game, Involvement, Item, Player, Tile, gamedata_index::GamedataIndex};
 use hurrycurry_data::{Serverdata, index::DataIndex};
-use hurrycurry_locale::{TrError, tre};
+use hurrycurry_locale::{
+    FALLBACK_LOCALE, TrError,
+    message::{COLORED, MessageDisplayExt},
+    tre,
+};
 use hurrycurry_protocol::{
     Character, Gamedata, Hand, ItemLocation, Menu, MessageTimeout, PacketC, PacketS, PlayerClass,
     PlayerID, Score, TileIndex,
@@ -64,7 +68,6 @@ pub struct Server {
 
     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>,
@@ -345,7 +348,6 @@ impl Server {
             data: Serverdata::default().into(),
             gamedata_index: GamedataIndex::default(),
             entities: Vec::new(),
-            player_id_counter: PlayerID(1),
             score_changed: false,
             packet_loopback: VecDeque::new(),
             last_movement_update: HashMap::default(),
@@ -412,6 +414,7 @@ impl Server {
 
     pub fn packet_in(
         &mut self,
+        conn: Option<ConnectionID>,
         packet: PacketS,
         replies: &mut Vec<PacketC>,
     ) -> Result<(), TrError> {
@@ -419,9 +422,9 @@ impl Server {
             PacketS::Join {
                 name,
                 character,
-                id,
                 class,
                 position,
+                id,
             } => {
                 if name.chars().count() > 32 || name.len() > 64 {
                     return Err(tre!(
@@ -433,13 +436,10 @@ impl Server {
                 if self.game.players.len() > 64 {
                     return Err(tre!("s.error.too_many_players"));
                 }
-                let id = id.unwrap_or_else(|| {
-                    let id = self.player_id_counter;
-                    self.player_id_counter.0 += 1;
-                    id
-                });
+
+                let player = id.unwrap_or_else(|| self.game.get_unused_player_id());
                 self.game.join_player(
-                    id,
+                    player,
                     name,
                     character,
                     class,
@@ -447,9 +447,19 @@ impl Server {
                     position,
                     Some(&mut self.packet_out),
                 );
-                replies.push(PacketC::Joined { id })
+                if let Some(conn) = conn {
+                    info!("{conn} join {player}");
+                } else {
+                    info!("server join {player}");
+                }
+                replies.push(PacketC::Joined { id: player })
             }
             PacketS::Leave { player } => {
+                if let Some(conn) = conn {
+                    info!("{conn} leave {player}");
+                } else {
+                    info!("server leave {player}");
+                }
                 let p = self
                     .game
                     .players
@@ -640,23 +650,28 @@ impl Server {
                 player,
                 pin,
             } => {
-                info!("{player:?} message {message:?}");
+                if let Some(message) = &message {
+                    info!(
+                        "{player} message {}",
+                        message.display_message(&FALLBACK_LOCALE, &self.game.data, &COLORED)
+                    );
+                } else {
+                    info!("{player} clear message");
+                }
                 let pin = pin.unwrap_or(false);
-                let timeout = if let Some(timeout) = timeout {
-                    if let Some(player) = self.game.players.get_mut(&player) {
-                        let mut timeout = MessageTimeout {
-                            initial: timeout,
-                            remaining: timeout,
-                            pinned: pin,
-                        };
-                        if let Some((_, t)) = &player.communicate_persist {
-                            timeout.initial = t.initial;
-                        };
-                        player.communicate_persist = message.clone().map(|m| (m, timeout));
-                        Some(timeout)
-                    } else {
-                        None
-                    }
+                let timeout = if let Some(timeout) = timeout
+                    && let Some(player) = self.game.players.get_mut(&player)
+                {
+                    let mut timeout = MessageTimeout {
+                        initial: timeout,
+                        remaining: timeout,
+                        pinned: pin,
+                    };
+                    if let Some((_, t)) = &player.communicate_persist {
+                        timeout.initial = t.initial;
+                    };
+                    player.communicate_persist = message.clone().map(|m| (m, timeout));
+                    Some(timeout)
                 } else {
                     None
                 };
@@ -776,6 +791,7 @@ impl Server {
         }
         for (player, hand) in players_auto_release.drain(..) {
             let _ = self.packet_in(
+                None,
                 PacketS::Interact {
                     pos: None,
                     player,
@@ -825,7 +841,7 @@ impl Server {
         }
 
         while let Some(p) = self.packet_loopback.pop_front() {
-            if let Err(e) = self.packet_in(p, &mut vec![]) {
+            if let Err(e) = self.packet_in(None, p, &mut vec![]) {
                 warn!("Internal packet errored: {e}");
             }
         }