rust/hedgewars-server/src/server/handlers/common.rs
changeset 14675 dfe652c53470
parent 14674 b87c71ccd17d
child 14683 932ff7683653
equal deleted inserted replaced
14674:b87c71ccd17d 14675:dfe652c53470
    26         nick: "[random]".to_owned(),
    26         nick: "[random]".to_owned(),
    27         msg: reply.clone(),
    27         msg: reply.clone(),
    28     }
    28     }
    29 }
    29 }
    30 
    30 
    31 pub fn remove_teams(room: &mut HWRoom, client: &HWClient, response: &mut super::Response) {
    31 pub fn remove_teams(
    32     let team_names: Vec<_> = room
    32     room: &mut HWRoom,
    33         .client_teams(client.id)
    33     team_names: Vec<String>,
    34         .map(|t| t.name.clone())
    34     is_in_game: bool,
    35         .collect();
    35     response: &mut super::Response,
    36 
    36 ) {
    37     if let Some(ref mut info) = room.game_info {
    37     if let Some(ref mut info) = room.game_info {
    38         for team_name in &team_names {
    38         for team_name in &team_names {
    39             info.left_teams.push(team_name.clone());
    39             info.left_teams.push(team_name.clone());
    40 
    40 
    41             if client.is_in_game() {
    41             if is_in_game {
    42                 let msg = once(b'F').chain(team_name.bytes());
    42                 let msg = once(b'F').chain(team_name.bytes());
    43                 response.add(
    43                 response.add(
    44                     ForwardEngineMessage(vec![to_engine_msg(msg)])
    44                     ForwardEngineMessage(vec![to_engine_msg(msg)])
    45                         .send_all()
    45                         .send_all()
    46                         .in_room(room.id)
    46                         .in_room(room.id)
    73         room.remove_team(&team_name);
    73         room.remove_team(&team_name);
    74         response.add(TeamRemove(team_name).send_all().in_room(room.id));
    74         response.add(TeamRemove(team_name).send_all().in_room(room.id));
    75     }
    75     }
    76 }
    76 }
    77 
    77 
       
    78 pub fn exit_room(client: &HWClient, room: &mut HWRoom, response: &mut super::Response, msg: &str) {
       
    79     if room.players_number > 1 || room.is_fixed() {
       
    80         room.players_number -= 1;
       
    81         if client.is_ready() && room.ready_players_number > 0 {
       
    82             room.ready_players_number -= 1;
       
    83         }
       
    84 
       
    85         let team_names: Vec<_> = room
       
    86             .client_teams(client.id)
       
    87             .map(|t| t.name.clone())
       
    88             .collect();
       
    89         remove_teams(room, team_names, client.is_in_game(), response);
       
    90 
       
    91         if room.players_number > 0 {
       
    92             response.add(
       
    93                 RoomLeft(client.nick.clone(), msg.to_string())
       
    94                     .send_all()
       
    95                     .in_room(room.id)
       
    96                     .but_self(),
       
    97             );
       
    98         }
       
    99 
       
   100         //ChangeMaster(room.id, None));
       
   101     }
       
   102 
       
   103     let update_msg = if room.players_number == 0 && !room.is_fixed() {
       
   104         RoomRemove(room.name.clone())
       
   105     } else {
       
   106         RoomUpdated(room.name.clone(), room.info(Some(&client)))
       
   107     };
       
   108     response.add(update_msg.send_all().with_protocol(room.protocol_number));
       
   109 
       
   110     response.add(ClientFlags("-i".to_string(), vec![client.nick.clone()]).send_all());
       
   111 }
       
   112 
    78 pub fn remove_client(server: &mut HWServer, response: &mut super::Response, msg: String) {
   113 pub fn remove_client(server: &mut HWServer, response: &mut super::Response, msg: String) {
    79     let client_id = response.client_id();
   114     let client_id = response.client_id();
    80     let lobby_id = server.lobby_id;
   115     let lobby_id = server.lobby_id;
    81     let client = &mut server.clients[client_id];
   116     let client = &mut server.clients[client_id];
    82     let (nick, room_id) = (client.nick.clone(), client.room_id);
   117     let (nick, room_id) = (client.nick.clone(), client.room_id);
    83 
   118 
    84     if let Some(room_id) = room_id {
   119     if let Some(room_id) = room_id {
    85         let room = &mut server.rooms[room_id];
   120         let room = &mut server.rooms[room_id];
    86 
   121         exit_room(client, room, response, &msg);
    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);
   122         client.room_id = Some(lobby_id);
   116     }
   123     }
   117 
   124 
   118     server.remove_client(client_id);
   125     server.remove_client(client_id);
   119 
   126