gameServer2/src/server/actions.rs
changeset 13801 5fb40c8e5542
parent 13666 09f4a30e50cc
child 14350 31717e1436cd
equal deleted inserted replaced
13800:0118b7412570 13801:5fb40c8e5542
   141                 server.clients.remove(client_id);
   141                 server.clients.remove(client_id);
   142             }
   142             }
   143         },
   143         },
   144         ReactProtocolMessage(msg) =>
   144         ReactProtocolMessage(msg) =>
   145             handlers::handle(server, client_id, msg),
   145             handlers::handle(server, client_id, msg),
   146         CheckRegistered =>
   146         CheckRegistered => {
   147             if server.clients[client_id].protocol_number > 0 && server.clients[client_id].nick != "" {
   147             let client = &server.clients[client_id];
   148                 server.react(client_id, vec![
   148             if client.protocol_number > 0 && client.nick != "" {
   149                     JoinLobby,
   149                 let has_nick_clash = server.clients.iter().any(
   150                     ]);
   150                     |(id, c)| id != client_id && c.nick == client.nick);
   151             },
   151 
       
   152                 let actions = if !client.is_checker() && has_nick_clash {
       
   153                     if client.protocol_number < 38 {
       
   154                         vec![ByeClient("Nickname is already in use".to_string())]
       
   155                     } else {
       
   156                         server.clients[client_id].nick.clear();
       
   157                         vec![Notice("NickAlreadyInUse".to_string()).send_self().action()]
       
   158                     }
       
   159                 } else {
       
   160                     vec![JoinLobby]
       
   161                 };
       
   162                 server.react(client_id, actions);
       
   163             }
       
   164         },
   152         JoinLobby => {
   165         JoinLobby => {
   153             server.clients[client_id].room_id = Some(server.lobby_id);
   166             server.clients[client_id].room_id = Some(server.lobby_id);
   154 
   167 
   155             let mut lobby_nicks = Vec::new();
   168             let mut lobby_nicks = Vec::new();
   156             for (_, c) in server.clients.iter() {
   169             for (_, c) in server.clients.iter() {
   464                     }
   477                     }
   465                     Some(_) => unreachable!(),
   478                     Some(_) => unreachable!(),
   466                     None => {}
   479                     None => {}
   467                 }
   480                 }
   468                 r.master_id = new_id;
   481                 r.master_id = new_id;
       
   482                 if !r.is_fixed() && c.protocol_number < 42 {
       
   483                     r.name.replace_range(.., new_nick.as_ref().map_or("[]", String::as_str));
       
   484                 }
   469                 r.set_join_restriction(false);
   485                 r.set_join_restriction(false);
   470                 r.set_team_add_restriction(false);
   486                 r.set_team_add_restriction(false);
   471                 let is_fixed = r.is_fixed();
   487                 let is_fixed = r.is_fixed();
   472                 r.set_unregistered_players_restriction(is_fixed);
   488                 r.set_unregistered_players_restriction(is_fixed);
   473                 if let Some(nick) = new_nick {
   489                 if let Some(nick) = new_nick {
   515                     .map(|(id, c)| (id, c.nick.clone())).unzip();
   531                     .map(|(id, c)| (id, c.nick.clone())).unzip();
   516                 let room = &mut server.rooms[room_id];
   532                 let room = &mut server.rooms[room_id];
   517 
   533 
   518                 if !room.has_multiple_clans() {
   534                 if !room.has_multiple_clans() {
   519                     vec![Warn("The game can't be started with less than two clans!".to_string())]
   535                     vec![Warn("The game can't be started with less than two clans!".to_string())]
       
   536                 } else if room.protocol_number <= 43 && room.players_number != room.ready_players_number {
       
   537                     vec![Warn("Not all players are ready".to_string())]
   520                 } else if room.game_info.is_some() {
   538                 } else if room.game_info.is_some() {
   521                     vec![Warn("The game is already in progress".to_string())]
   539                     vec![Warn("The game is already in progress".to_string())]
   522                 } else {
   540                 } else {
   523                     room.start_round();
   541                     room.start_round();
   524                     for id in room_clients {
   542                     for id in room_clients {
   559             }
   577             }
   560             server.react(client_id, actions);
   578             server.react(client_id, actions);
   561         }
   579         }
   562         FinishRoomGame(room_id) => {
   580         FinishRoomGame(room_id) => {
   563             let mut actions = Vec::new();
   581             let mut actions = Vec::new();
   564             let old_info;
   582 
   565             {
   583             let r = &mut server.rooms[room_id];
   566                 let r = &mut server.rooms[room_id];
   584             r.ready_players_number = 1;
   567                 old_info = replace(&mut r.game_info, None);
   585             actions.push(SendRoomUpdate(None));
   568                 r.game_info = None;
   586             actions.push(RoundFinished.send_all().in_room(r.id).action());
   569                 r.ready_players_number = 1;
   587 
   570                 actions.push(SendRoomUpdate(None));
   588             if let Some(info) = replace(&mut r.game_info, None) {
   571                 actions.push(RoundFinished.send_all().in_room(r.id).action());
       
   572             }
       
   573 
       
   574             if let Some(info) = old_info {
       
   575                 for (_, c) in server.clients.iter() {
   589                 for (_, c) in server.clients.iter() {
   576                     if c.room_id == Some(room_id) && c.is_joined_mid_game() {
   590                     if c.room_id == Some(room_id) && c.is_joined_mid_game() {
   577                         actions.push(SendRoomData{
   591                         actions.push(SendRoomData{
   578                             to: c.id, teams: false,
   592                             to: c.id, teams: false,
   579                             config: true, flags: false});
   593                             config: true, flags: false});
   594                 }).filter_map(|c| if !c.is_master() {
   608                 }).filter_map(|c| if !c.is_master() {
   595                     Some(c.nick.clone())
   609                     Some(c.nick.clone())
   596                 } else {
   610                 } else {
   597                     None
   611                     None
   598                 }).collect();
   612                 }).collect();
       
   613 
   599             if !nicks.is_empty() {
   614             if !nicks.is_empty() {
   600                 actions.push(ClientFlags("-r".to_string(), nicks)
   615                 let msg = if r.protocol_number < 38 {
   601                     .send_all().in_room(room_id).action());
   616                     LegacyReady(false, nicks)
       
   617                 } else {
       
   618                     ClientFlags("-r".to_string(), nicks)
       
   619                 };
       
   620                 actions.push(msg.send_all().in_room(room_id).action());
   602             }
   621             }
   603             server.react(client_id, actions);
   622             server.react(client_id, actions);
   604         }
   623         }
   605         Warn(msg) => {
   624         Warn(msg) => {
   606             run_action(server, client_id, Warning(msg).send_self().action());
   625             run_action(server, client_id, Warning(msg).send_self().action());