rust/hedgewars-server/src/server/handlers/inroom.rs
changeset 14691 2071da901c63
parent 14690 f61ce544d436
child 14694 25c564f77b7d
equal deleted inserted replaced
14690:f61ce544d436 14691:2071da901c63
   188                     LegacyReady(client.is_ready(), vec![client.nick.clone()])
   188                     LegacyReady(client.is_ready(), vec![client.nick.clone()])
   189                 } else {
   189                 } else {
   190                     ClientFlags(flags.to_string(), vec![client.nick.clone()])
   190                     ClientFlags(flags.to_string(), vec![client.nick.clone()])
   191                 };
   191                 };
   192                 response.add(msg.send_all().in_room(room.id));
   192                 response.add(msg.send_all().in_room(room.id));
       
   193                 client.set_is_ready(!client.is_ready());
       
   194 
   193                 if room.is_fixed() && room.ready_players_number == room.players_number {
   195                 if room.is_fixed() && room.ready_players_number == room.players_number {
   194                     //StartRoomGame(r.id)
   196                     super::common::start_game(server, room_id, response);
   195                 }
   197                 }
   196 
       
   197                 client.set_is_ready(!client.is_ready());
       
   198             }
   198             }
   199         }
   199         }
   200         AddTeam(info) => {
   200         AddTeam(info) => {
   201             let client = &mut server.clients[client_id];
   201             let client = &mut server.clients[client_id];
   202             let room = &mut server.rooms[room_id];
   202             let room = &mut server.rooms[room_id];
   247                 };
   247                 };
   248                 super::common::get_room_update(None, room, room_master, response);
   248                 super::common::get_room_update(None, room, room_master, response);
   249             }
   249             }
   250         }
   250         }
   251         RemoveTeam(name) => {
   251         RemoveTeam(name) => {
   252             if let (client, Some(room)) = server.client_and_room(client_id) {
   252             let client = &mut server.clients[client_id];
   253                 match room.find_team_owner(&name) {
   253             let room = &mut server.rooms[room_id];
   254                     None => response.add(
   254             match room.find_team_owner(&name) {
   255                         Warning("Error: The team you tried to remove does not exist.".to_string())
   255                 None => response.add(
   256                             .send_self(),
   256                     Warning("Error: The team you tried to remove does not exist.".to_string())
   257                     ),
   257                         .send_self(),
   258                     Some((id, _)) if id != client_id => response.add(
   258                 ),
   259                         Warning("You can't remove a team you don't own.".to_string()).send_self(),
   259                 Some((id, _)) if id != client_id => response
   260                     ),
   260                     .add(Warning("You can't remove a team you don't own.".to_string()).send_self()),
   261                     Some((_, name)) => {
   261                 Some((_, name)) => {
   262                         client.teams_in_game -= 1;
   262                     client.teams_in_game -= 1;
   263                         client.clan = room.find_team_color(client.id);
   263                     client.clan = room.find_team_color(client.id);
   264                         super::common::remove_teams(
   264                     super::common::remove_teams(
   265                             room,
   265                         room,
   266                             vec![name.to_string()],
   266                         vec![name.to_string()],
   267                             client.is_in_game(),
   267                         client.is_in_game(),
   268                             response,
   268                         response,
   269                         );
   269                     );
       
   270 
       
   271                     match room.game_info {
       
   272                         Some(ref info) if info.teams_in_game == 0 => {
       
   273                             super::common::end_game(server, room_id, response)
       
   274                         }
       
   275                         _ => (),
   270                     }
   276                     }
   271                 }
   277                 }
   272             }
   278             }
   273         }
   279         }
   274         SetHedgehogsNumber(team_name, number) => {
   280         SetHedgehogsNumber(team_name, number) => {
   511                 room.flags.toggle(room_message_flag(&message));
   517                 room.flags.toggle(room_message_flag(&message));
   512                 super::common::get_room_update(None, room, Some(&client), response);
   518                 super::common::get_room_update(None, room, Some(&client), response);
   513             }
   519             }
   514         }
   520         }
   515         StartGame => {
   521         StartGame => {
   516             // StartRoomGame(room_id);
   522             super::common::start_game(server, room_id, response);
   517         }
   523         }
   518         EngineMessage(em) => {
   524         EngineMessage(em) => {
   519             if let (c, Some(r)) = server.client_and_room(client_id) {
   525             if let (c, Some(r)) = server.client_and_room(client_id) {
   520                 if c.teams_in_game > 0 {
   526                 if c.teams_in_game > 0 {
   521                     let decoding = decode(&em[..]).unwrap();
   527                     let decoding = decode(&em[..]).unwrap();