rust/hedgewars-server/src/core/server.rs
changeset 15569 4b2f3228f13b
parent 15553 852682c2003f
child 15697 25371cae9fd7
equal deleted inserted replaced
15568:de1b31c2d2f2 15569:4b2f3228f13b
   126     AlreadyInGame,
   126     AlreadyInGame,
   127 }
   127 }
   128 
   128 
   129 #[derive(Debug)]
   129 #[derive(Debug)]
   130 pub struct EndGameResult {
   130 pub struct EndGameResult {
   131     pub joined_mid_game_clients: Vec<ClientId>,
       
   132     pub left_teams: Vec<String>,
   131     pub left_teams: Vec<String>,
   133     pub unreadied_nicks: Vec<String>,
   132     pub unreadied_nicks: Vec<String>,
   134 }
   133 }
   135 
   134 
   136 #[derive(Debug)]
   135 #[derive(Debug)]
   605         if is_empty && !is_fixed {
   604         if is_empty && !is_fixed {
   606             if client.is_ready() && room.ready_players_number > 0 {
   605             if client.is_ready() && room.ready_players_number > 0 {
   607                 room.ready_players_number -= 1;
   606                 room.ready_players_number -= 1;
   608             }
   607             }
   609 
   608 
   610             removed_teams = room
   609             if let Some(ref mut info) = room.game_info {
   611                 .client_teams(client.id)
   610                 removed_teams = info
   612                 .map(|t| t.name.clone())
   611                     .client_teams(client.id)
   613                 .collect();
   612                     .map(|t| t.name.clone())
   614 
   613                     .collect();
   615             for team_name in &removed_teams {
   614                 info.mark_left_teams(removed_teams.iter());
   616                 room.remove_team(team_name);
   615             } else {
       
   616                 removed_teams = room
       
   617                     .client_teams(client.id)
       
   618                     .map(|t| t.name.clone())
       
   619                     .collect();
       
   620                 for team_name in &removed_teams {
       
   621                     room.remove_team(team_name);
       
   622                 }
   617             }
   623             }
   618 
   624 
   619             if client.is_master() && !is_fixed {
   625             if client.is_master() && !is_fixed {
   620                 client.set_is_master(false);
   626                 client.set_is_master(false);
   621                 room.master_id = None;
   627                 room.master_id = None;
   993                 let team_names: Vec<_> = info
   999                 let team_names: Vec<_> = info
   994                     .client_teams(client.id)
  1000                     .client_teams(client.id)
   995                     .map(|t| t.name.clone())
  1001                     .map(|t| t.name.clone())
   996                     .collect();
  1002                     .collect();
   997 
  1003 
   998                 info.left_teams.extend(team_names.iter().cloned());
  1004                 info.mark_left_teams(team_names.iter());
   999                 info.ingame_teams_count -= team_names.len() as u8;
  1005 
  1000 
       
  1001                 for team_name in &team_names {
       
  1002                     let remove_msg =
       
  1003                         utils::to_engine_msg(std::iter::once(b'F').chain(team_name.bytes()));
       
  1004                     if let Some(m) = &info.sync_msg {
       
  1005                         info.msg_log.push(m.clone());
       
  1006                     }
       
  1007                     if info.sync_msg.is_some() {
       
  1008                         info.sync_msg = None
       
  1009                     }
       
  1010                     info.msg_log.push(remove_msg);
       
  1011                 }
       
  1012                 Some(team_names)
  1006                 Some(team_names)
  1013             } else {
  1007             } else {
  1014                 None
  1008                 None
  1015             }
  1009             }
  1016         } else {
  1010         } else {
  1025         if let Some(mut info) = replace(&mut room.game_info, None) {
  1019         if let Some(mut info) = replace(&mut room.game_info, None) {
  1026             let room_id = room.id;
  1020             let room_id = room.id;
  1027             for team_name in &info.left_teams {
  1021             for team_name in &info.left_teams {
  1028                 room.remove_team(team_name);
  1022                 room.remove_team(team_name);
  1029             }
  1023             }
  1030 
       
  1031             let joined_mid_game_clients = self
       
  1032                 .server
       
  1033                 .clients
       
  1034                 .iter()
       
  1035                 .filter(|(_, c)| c.room_id == Some(self.room_id) && c.is_joined_mid_game())
       
  1036                 .map(|(_, c)| c.id)
       
  1037                 .collect();
       
  1038 
  1024 
  1039             let unreadied_nicks: Vec<_> = self
  1025             let unreadied_nicks: Vec<_> = self
  1040                 .server
  1026                 .server
  1041                 .clients
  1027                 .clients
  1042                 .iter_mut()
  1028                 .iter_mut()
  1043                 .filter(|(_, c)| c.room_id == Some(room_id))
  1029                 .filter(|(_, c)| c.room_id == Some(room_id))
  1044                 .map(|(_, c)| {
  1030                 .map(|(_, c)| {
  1045                     c.set_is_ready(c.is_master());
  1031                     c.set_is_ready(c.is_master());
  1046                     c.set_is_joined_mid_game(false);
       
  1047                     c
  1032                     c
  1048                 })
  1033                 })
  1049                 .filter_map(|c| {
  1034                 .filter_map(|c| {
  1050                     if !c.is_master() {
  1035                     if !c.is_master() {
  1051                         Some(c.nick.clone())
  1036                         Some(c.nick.clone())
  1054                     }
  1039                     }
  1055                 })
  1040                 })
  1056                 .collect();
  1041                 .collect();
  1057 
  1042 
  1058             Some(EndGameResult {
  1043             Some(EndGameResult {
  1059                 joined_mid_game_clients,
       
  1060                 left_teams: replace(&mut info.left_teams, vec![]),
  1044                 left_teams: replace(&mut info.left_teams, vec![]),
  1061                 unreadied_nicks,
  1045                 unreadied_nicks,
  1062             })
  1046             })
  1063         } else {
  1047         } else {
  1064             None
  1048             None
  1101 
  1085 
  1102     client.room_id = Some(room.id);
  1086     client.room_id = Some(room.id);
  1103     client.set_is_master(true);
  1087     client.set_is_master(true);
  1104     client.set_is_ready(true);
  1088     client.set_is_ready(true);
  1105     client.set_is_in_game(false);
  1089     client.set_is_in_game(false);
  1106     client.set_is_joined_mid_game(false);
       
  1107     client.clan = None;
  1090     client.clan = None;
  1108     client.teams_in_game = 0;
  1091     client.teams_in_game = 0;
  1109     client.team_indices = vec![];
  1092     client.team_indices = vec![];
  1110 
  1093 
  1111     (client, room)
  1094     (client, room)
  1115     debug_assert!(client.room_id != Some(room.id));
  1098     debug_assert!(client.room_id != Some(room.id));
  1116 
  1099 
  1117     room.players_number += 1;
  1100     room.players_number += 1;
  1118 
  1101 
  1119     client.room_id = Some(room.id);
  1102     client.room_id = Some(room.id);
  1120     client.set_is_joined_mid_game(room.game_info.is_some());
       
  1121     client.set_is_in_game(room.game_info.is_some());
  1103     client.set_is_in_game(room.game_info.is_some());
  1122 
  1104 
  1123     if let Some(ref mut info) = room.game_info {
  1105     if let Some(ref mut info) = room.game_info {
  1124         let teams = info.client_teams(client.id);
  1106         let teams = info.client_teams(client.id);
  1125         client.teams_in_game = teams.clone().count() as u8;
  1107         client.teams_in_game = teams.clone().count() as u8;
  1126         client.clan = teams.clone().next().map(|t| t.color);
  1108         client.clan = teams.clone().next().map(|t| t.color);
  1127         let team_names: Vec<_> = teams.map(|t| t.name.clone()).collect();
  1109         let team_names: Vec<_> = teams.map(|t| t.name.clone()).collect();
  1128 
  1110 
  1129         if !team_names.is_empty() {
  1111         if !team_names.is_empty() {
  1130             info.left_teams.retain(|name| !team_names.contains(&name));
  1112             info.left_teams.retain(|name| !team_names.contains(&name));
  1131             info.ingame_teams_count += team_names.len() as u8;
  1113         }
  1132         }
  1114     }
  1133     }
  1115 }
  1134 }