rust/hedgewars-server/src/core/server.rs
changeset 16000 d9f1b239b6d7
parent 15989 fb389df02e3e
child 16001 8ba2b5007c29
equal deleted inserted replaced
15999:d73e6cb37f83 16000:d9f1b239b6d7
   359             Err(WrongPassword)
   359             Err(WrongPassword)
   360         } else if room.is_join_restricted() {
   360         } else if room.is_join_restricted() {
   361             Err(Restricted)
   361             Err(Restricted)
   362         } else if room.is_registration_required() {
   362         } else if room.is_registration_required() {
   363             Err(RegistrationRequired)
   363             Err(RegistrationRequired)
   364         } else if room.players_number == u8::max_value() {
   364         } else if room.players_number == u8::MAX {
   365             Err(Full)
   365             Err(Full)
   366         } else {
   366         } else {
   367             move_to_room(client, room);
   367             move_to_room(client, room);
   368             let room_id = room.id;
   368             let room_id = room.id;
   369             Ok((
   369             Ok((
   618         let room_id = self.room_id;
   618         let room_id = self.room_id;
   619         HwRoomControl::new(self.server, client_id).filter(|c| c.room_id == room_id)
   619         HwRoomControl::new(self.server, client_id).filter(|c| c.room_id == room_id)
   620     }
   620     }
   621 
   621 
   622     fn remove_from_room(&mut self, client_id: ClientId) -> LeaveRoomResult {
   622     fn remove_from_room(&mut self, client_id: ClientId) -> LeaveRoomResult {
   623         let (client, room) = self.server.client_and_room_mut(client_id).expect("Caller should have ensured the client is in this room");
   623         let (client, room) = self
       
   624             .server
       
   625             .client_and_room_mut(client_id)
       
   626             .expect("Caller should have ensured the client is in this room");
   624         room.players_number -= 1;
   627         room.players_number -= 1;
   625         client.room_id = None;
   628         client.room_id = None;
   626 
   629 
   627         let is_empty = room.players_number == 0;
   630         let is_empty = room.players_number == 0;
   628         let is_fixed = room.is_fixed();
   631         let is_fixed = room.is_fixed();
   935             Err(TeamAlreadyExists)
   938             Err(TeamAlreadyExists)
   936         } else if room.is_team_add_restricted() {
   939         } else if room.is_team_add_restricted() {
   937             Err(Restricted)
   940             Err(Restricted)
   938         } else {
   941         } else {
   939             info.owner = client.nick.clone();
   942             info.owner = client.nick.clone();
   940             let team = room.add_team(client.id, *info, client.protocol_number < 42);
   943             let team = room.add_team(&client, *info, client.protocol_number < 42);
   941             client.teams_in_game += 1;
   944             client.teams_in_game += 1;
   942             client.clan = Some(team.color);
   945             client.clan = Some(team.color);
   943             Ok(team)
   946             Ok(team)
   944         }
   947         }
   945     }
   948     }
   947     pub fn remove_team(&mut self, team_name: &str) -> Result<(), RemoveTeamError> {
   950     pub fn remove_team(&mut self, team_name: &str) -> Result<(), RemoveTeamError> {
   948         use RemoveTeamError::*;
   951         use RemoveTeamError::*;
   949         let (client, room) = self.get_mut();
   952         let (client, room) = self.get_mut();
   950         match room.find_team_owner(team_name) {
   953         match room.find_team_owner(team_name) {
   951             None => Err(NoTeam),
   954             None => Err(NoTeam),
   952             Some((id, _)) if id != client.id => Err(RemoveTeamError::TeamNotOwned),
   955             Some((id, _)) if id != client.id => Err(TeamNotOwned),
   953             Some(_) => {
   956             Some(_) => {
   954                 client.teams_in_game -= 1;
   957                 client.teams_in_game -= 1;
   955                 client.clan = room.find_team_color(client.id);
   958                 client.clan = room.find_team_color(client.id);
   956                 room.remove_team(team_name);
   959                 room.remove_team(team_name);
   957                 Ok(())
   960                 Ok(())
  1169     room.players_number += 1;
  1172     room.players_number += 1;
  1170 
  1173 
  1171     client.room_id = Some(room.id);
  1174     client.room_id = Some(room.id);
  1172     client.set_is_in_game(room.game_info.is_some());
  1175     client.set_is_in_game(room.game_info.is_some());
  1173 
  1176 
  1174     if let Some(ref mut info) = room.game_info {
  1177     #[cfg(feature = "official-server")]
  1175         let teams = info.client_teams(client.id);
  1178     let can_rejoin = client.is_registered();
  1176         client.teams_in_game = teams.clone().count() as u8;
  1179 
  1177         client.clan = teams.clone().next().map(|t| t.color);
  1180     #[cfg(not(feature = "official-server"))]
  1178         let team_names: Vec<_> = teams.map(|t| t.name.clone()).collect();
  1181     let can_rejoin = true;
  1179 
  1182 
  1180         if !team_names.is_empty() {
  1183     if can_rejoin {
  1181             info.left_teams.retain(|name| !team_names.contains(&name));
  1184         if let Some(ref mut info) = room.game_info {
  1182         }
  1185             let teams = info.client_teams_by_nick(&client.nick);
  1183     }
  1186             client.teams_in_game = teams.clone().count() as u8;
  1184 }
  1187             client.clan = teams.clone().next().map(|t| t.color);
       
  1188             let team_names: Vec<_> = teams.map(|t| t.name.clone()).collect();
       
  1189 
       
  1190             if !team_names.is_empty() {
       
  1191                 info.left_teams.retain(|name| !team_names.contains(&name));
       
  1192             }
       
  1193         }
       
  1194     }
       
  1195 }