Add missing guild replies

src/map/command.rs

@@ -176,6 +176,10 @@ pub enum Command {
     GetRidAndSize {
         respond_to: oneshot::Sender<([i32; 2], i32)>,
     },
+    GetPlayerCount {
+        respond_to: oneshot::Sender<usize>,
+        filter: fn(&Character) -> bool,
+    },
     AwardExperience {
         player_id: i32,
         amount: i32,

src/map/map.rs

@@ -322,7 +322,9 @@ impl Map {
             Command::GetRidAndSize { respond_to } => {
                 self.get_rid_and_size(respond_to);
             }
-
+            Command::GetPlayerCount { respond_to, filter } => {
+                let _ = respond_to.send(self.characters.values().filter(|c| filter(c)).count());
+            }
             Command::AwardExperience { player_id, amount } => {
                 self.award_experience(player_id, amount)
             }

src/map/map/auto_pickup/list_auto_pickup_items.rs

@@ -12,7 +12,12 @@ impl Map {
         let items = character
             .auto_pickup_items
             .iter()
-            .filter_map(|item_id| ITEM_DB.items.get(*item_id as usize - 1).map(|item| item.name.as_str()))
+            .filter_map(|item_id| {
+                ITEM_DB
+                    .items
+                    .get(*item_id as usize - 1)
+                    .map(|item| item.name.as_str())
+            })
             .collect::<Vec<_>>();
 
         self.show_info_box(

src/map/map/guild/join_guild.rs

@@ -1,4 +1,7 @@
-use eolib::protocol::net::{server::GuildAgreeServerPacket, PacketAction, PacketFamily};
+use eolib::protocol::net::{
+    server::{GuildAgreeServerPacket, GuildReply},
+    PacketAction, PacketFamily,
+};
 
 use super::super::Map;
 
@@ -35,5 +38,17 @@ impl Map {
                 },
             );
         }
+
+        let character = match self.characters.get(&recruiter_id) {
+            Some(character) => character,
+            None => return,
+        };
+
+        let recruiter = match character.player.as_ref() {
+            Some(player) => player,
+            None => return,
+        };
+
+        recruiter.send_guild_reply(GuildReply::Accepted);
     }
 }

src/map/map/guild/request_to_join_guild.rs

@@ -17,55 +17,75 @@ impl Map {
             None => return,
         };
 
+        let player = match character.player.as_ref() {
+            Some(player) => player.to_owned(),
+            None => return,
+        };
+
         if character.guild_tag.is_some() {
+            send_reply!(player, GuildReply::AlreadyMember);
             return;
         }
 
-        let player = match character.player.as_ref() {
-            Some(player) => player,
-            None => return,
-        };
+        let recruiter = self
+            .characters
+            .values()
+            .find(|c| c.name == recruiter_name)
+            .map(|character| character.to_owned());
 
-        let recruiter = match self.characters.values().find(|c| c.name == recruiter_name) {
-            Some(character) => character,
-            None => {
-                send_reply!(player, GuildReply::RecruiterNotHere);
-                return;
+        let world = self.world.to_owned();
+        let character_name = character.name.to_owned();
+
+        tokio::spawn(async move {
+            match world.get_character_by_name(recruiter_name.to_owned()).await {
+                Ok(_) => {}
+                _ => {
+                    send_reply!(player, GuildReply::RecruiterOffline);
+                    return;
+                }
             }
-        };
 
-        if recruiter.guild_tag.is_none() {
-            send_reply!(player, GuildReply::RecruiterWrongGuild);
-            return;
-        }
+            let recruiter = match recruiter {
+                Some(character) => character,
+                None => {
+                    send_reply!(player, GuildReply::RecruiterNotHere);
+                    return;
+                }
+            };
 
-        if let Some(tag) = &recruiter.guild_tag {
-            if *tag != guild_tag {
+            if recruiter.guild_tag.is_none() {
                 send_reply!(player, GuildReply::RecruiterWrongGuild);
                 return;
             }
-        }
 
-        if recruiter.guild_rank.unwrap_or(9) > 1 {
-            send_reply!(player, GuildReply::NotRecruiter);
-            return;
-        }
+            if let Some(tag) = &recruiter.guild_tag {
+                if *tag != guild_tag {
+                    send_reply!(player, GuildReply::RecruiterWrongGuild);
+                    return;
+                }
+            }
 
-        if let Some(player) = recruiter.player.as_ref() {
-            player.set_interact_player_id(Some(player_id));
-            player.send(
-                PacketAction::Reply,
-                PacketFamily::Guild,
-                &GuildReplyServerPacket {
-                    reply_code: GuildReply::JoinRequest,
-                    reply_code_data: Some(GuildReplyServerPacketReplyCodeData::JoinRequest(
-                        GuildReplyServerPacketReplyCodeDataJoinRequest {
-                            player_id,
-                            name: capitalize(&character.name),
-                        },
-                    )),
-                },
-            );
-        }
+            if recruiter.guild_rank.unwrap_or(9) > 1 {
+                send_reply!(player, GuildReply::NotRecruiter);
+                return;
+            }
+
+            if let Some(player) = recruiter.player.as_ref() {
+                player.set_interact_player_id(Some(player_id));
+                player.send(
+                    PacketAction::Reply,
+                    PacketFamily::Guild,
+                    &GuildReplyServerPacket {
+                        reply_code: GuildReply::JoinRequest,
+                        reply_code_data: Some(GuildReplyServerPacketReplyCodeData::JoinRequest(
+                            GuildReplyServerPacketReplyCodeDataJoinRequest {
+                                player_id,
+                                name: capitalize(&character_name),
+                            },
+                        )),
+                    },
+                );
+            }
+        });
     }
 }

src/map/map/utils/attack_npc_replies.rs

@@ -71,7 +71,10 @@ impl Map {
                 npc_index,
                 damage: damage_dealt,
                 hp_percentage: npc.get_hp_percentage(),
-                caster_tp: self.characters.get(&player_id).map(|character| character.tp),
+                caster_tp: self
+                    .characters
+                    .get(&player_id)
+                    .map(|character| character.tp),
                 kill_steal_protection: Some(if protected {
                     NpcKillStealProtectionState::Protected
                 } else {

src/map/map_handle.rs

@@ -297,6 +297,15 @@ impl MapHandle {
         rx.await.unwrap()
     }
 
+    pub async fn get_player_count(&self, filter: fn(&Character) -> bool) -> usize {
+        let (tx, rx) = oneshot::channel();
+        let _ = self.tx.send(Command::GetPlayerCount {
+            respond_to: tx,
+            filter,
+        });
+        rx.await.unwrap()
+    }
+
     pub fn award_experience(&self, player_id: i32, amount: i32) {
         let _ = self.tx.send(Command::AwardExperience { player_id, amount });
     }

src/player/player/handlers/guild.rs

@@ -139,6 +139,12 @@ impl Player {
             if SETTINGS.guild.min_players == 1 {
                 player.send_guild_reply(GuildReply::CreateAddConfirm);
             } else {
+                let player_count = map.get_player_count(|c| c.guild_tag.is_none()).await;
+                if player_count < SETTINGS.guild.min_players {
+                    player.send_guild_reply(GuildReply::NoCandidates);
+                    return;
+                }
+
                 player.send_guild_reply(GuildReply::CreateBegin);
                 map.send_guild_create_requests(
                     player_id,
@@ -1400,7 +1406,7 @@ async fn update_guild_ranks(player: &PlayerHandle, tag: &str, ranks: [String; 9]
         }
     }
 
-    player.send_guild_reply(GuildReply::Updated);
+    player.send_guild_reply(GuildReply::RanksUpdated);
 }
 
 async fn get_guild_description(conn: &mut Conn, tag: &str) -> String {