rust/hedgewars-server/src/server/handlers/common.rs
changeset 14674 b87c71ccd17d
parent 14673 08a8605bafaf
child 14675 dfe652c53470
equal deleted inserted replaced
14673:08a8605bafaf 14674:b87c71ccd17d
       
     1 use crate::server::client::HWClient;
       
     2 use crate::server::room::HWRoom;
       
     3 use crate::utils::to_engine_msg;
     1 use crate::{
     4 use crate::{
     2     protocol::messages::{
     5     protocol::messages::{
     3         HWProtocolMessage::{self, Rnd},
     6         HWProtocolMessage::{self, Rnd},
     4         HWServerMessage::{self, ChatMsg},
     7         HWServerMessage::{
       
     8             self, Bye, ChatMsg, ClientFlags, ForwardEngineMessage, LobbyLeft, RoomLeft, RoomRemove,
       
     9             RoomUpdated, TeamRemove,
       
    10         },
     5     },
    11     },
     6     server::{actions::Action, core::HWServer},
    12     server::{actions::Action, core::HWServer},
     7 };
    13 };
     8 use rand::{self, thread_rng, Rng};
    14 use rand::{self, thread_rng, Rng};
       
    15 use std::iter::once;
     9 
    16 
    10 pub fn rnd_reply(options: &[String]) -> HWServerMessage {
    17 pub fn rnd_reply(options: &[String]) -> HWServerMessage {
    11     let mut rng = thread_rng();
    18     let mut rng = thread_rng();
    12     let reply = if options.is_empty() {
    19     let reply = if options.is_empty() {
    13         (*rng.choose(&["heads", "tails"]).unwrap()).to_owned()
    20         (*rng.choose(&["heads", "tails"]).unwrap()).to_owned()
    19         nick: "[random]".to_owned(),
    26         nick: "[random]".to_owned(),
    20         msg: reply.clone(),
    27         msg: reply.clone(),
    21     }
    28     }
    22 }
    29 }
    23 
    30 
       
    31 pub fn remove_teams(room: &mut HWRoom, client: &HWClient, response: &mut super::Response) {
       
    32     let team_names: Vec<_> = room
       
    33         .client_teams(client.id)
       
    34         .map(|t| t.name.clone())
       
    35         .collect();
       
    36 
       
    37     if let Some(ref mut info) = room.game_info {
       
    38         for team_name in &team_names {
       
    39             info.left_teams.push(team_name.clone());
       
    40 
       
    41             if client.is_in_game() {
       
    42                 let msg = once(b'F').chain(team_name.bytes());
       
    43                 response.add(
       
    44                     ForwardEngineMessage(vec![to_engine_msg(msg)])
       
    45                         .send_all()
       
    46                         .in_room(room.id)
       
    47                         .but_self(),
       
    48                 );
       
    49 
       
    50                 info.teams_in_game -= 1;
       
    51                 if info.teams_in_game == 0 {
       
    52                     //FinishRoomGame(room.id)
       
    53                 }
       
    54 
       
    55                 let remove_msg = to_engine_msg(once(b'F').chain(team_name.bytes()));
       
    56                 if let Some(m) = &info.sync_msg {
       
    57                     info.msg_log.push(m.clone());
       
    58                     info.sync_msg = None
       
    59                 }
       
    60                 info.msg_log.push(remove_msg.clone());
       
    61 
       
    62                 response.add(
       
    63                     ForwardEngineMessage(vec![remove_msg])
       
    64                         .send_all()
       
    65                         .in_room(room.id)
       
    66                         .but_self(),
       
    67                 );
       
    68             }
       
    69         }
       
    70     }
       
    71 
       
    72     for team_name in team_names {
       
    73         room.remove_team(&team_name);
       
    74         response.add(TeamRemove(team_name).send_all().in_room(room.id));
       
    75     }
       
    76 }
       
    77 
    24 pub fn remove_client(server: &mut HWServer, response: &mut super::Response, msg: String) {
    78 pub fn remove_client(server: &mut HWServer, response: &mut super::Response, msg: String) {
    25     use HWServerMessage::*;
    79     let client_id = response.client_id();
    26     let nick = server.clients[response.client_id()].nick.clone();
    80     let lobby_id = server.lobby_id;
       
    81     let client = &mut server.clients[client_id];
       
    82     let (nick, room_id) = (client.nick.clone(), client.room_id);
       
    83 
       
    84     if let Some(room_id) = room_id {
       
    85         let room = &mut server.rooms[room_id];
       
    86 
       
    87         if room.players_number > 1 || room.is_fixed() {
       
    88             room.players_number -= 1;
       
    89             if client.is_ready() && room.ready_players_number > 0 {
       
    90                 room.ready_players_number -= 1;
       
    91             }
       
    92 
       
    93             remove_teams(room, client, response);
       
    94 
       
    95             if room.players_number > 1 {
       
    96                 response.add(
       
    97                     RoomLeft(client.nick.clone(), msg.clone())
       
    98                         .send_all()
       
    99                         .in_room(room.id)
       
   100                         .but_self(),
       
   101                 );
       
   102             }
       
   103 
       
   104             //ChangeMaster(room.id, None));
       
   105         }
       
   106 
       
   107         let update_msg = if room.players_number == 0 && !room.is_fixed() {
       
   108             RoomRemove(room.name.clone())
       
   109         } else {
       
   110             RoomUpdated(room.name.clone(), room.info(Some(&client)))
       
   111         };
       
   112         response.add(update_msg.send_all().with_protocol(room.protocol_number));
       
   113 
       
   114         response.add(ClientFlags("-i".to_string(), vec![nick.clone()]).send_all());
       
   115         client.room_id = Some(lobby_id);
       
   116     }
       
   117 
       
   118     server.remove_client(client_id);
       
   119 
    27     response.add(LobbyLeft(nick, msg.to_string()).send_all());
   120     response.add(LobbyLeft(nick, msg.to_string()).send_all());
    28     response.add(Bye("User quit: ".to_string() + &msg).send_self());
   121     response.add(Bye("User quit: ".to_string() + &msg).send_self());
    29 
       
    30     server.remove_client(response.client_id());
       
    31 }
   122 }
    32 
   123 
    33 #[cfg(test)]
   124 #[cfg(test)]
    34 mod tests {
   125 mod tests {
    35     use super::*;
   126     use super::*;