hedgewars: comparison rust/hedgewars-server/src/handlers/common.rs

equal deleted inserted replaced

-:3dc01bbcd0d8
+:395be40faa51
 use crate::{
 core::{
 client::HwClient,
 room::HwRoom,
-server::{HwServer, JoinRoomError, LeaveRoomResult},
+server::{HwServer, JoinRoomError, LeaveRoomError, LeaveRoomResult, StartGameError},
 types::{ClientId, GameCfg, RoomId, TeamInfo, Vote, VoteType},
 },
 protocol::messages::{
 add_flags, remove_flags, server_chat,
 HwProtocolMessage::{self, Rnd},
 let rooms_msg = Rooms(
 server
 .rooms
 .iter()
 .filter(|(_, r)| r.protocol_number == client.protocol_number)
-.flat_map(|(_, r)| r.info(r.master_id.map(|id| &server.clients[id])))
+.flat_map(|(_, r)| r.info(r.master_id.map(|id| server.client(id))))
 .collect(),
 );
 response.add(LobbyJoined(nick).send_all().but_self());
 response.add(
 for team_name in removed_teams {
 response.add(TeamRemove(team_name).send_all().in_room(room_id));
 }
 }
-pub fn get_room_leave_data(
+pub fn get_room_leave_result(
 server: &HwServer,
 room: &HwRoom,
 leave_message: &str,
 result: LeaveRoomResult,
 response: &mut Response,
 );
 }
 }
 }
+pub fn get_room_leave_data(
+server: &HwServer,
+room_id: RoomId,
+leave_message: &str,
+result: Result<LeaveRoomResult, LeaveRoomError>,
+response: &mut Response,
+) {
+match result {
+Ok(result) => {
+let room = server.room(room_id);
+get_room_leave_result(server, room, leave_message, result, response)
+}
+Err(_) => (),
+}
+}
 pub fn remove_client(server: &mut HwServer, response: &mut Response, msg: String) {
 let client_id = response.client_id();
 let client = server.client(client_id);
 let nick = client.nick.clone();
 if let Some(room_id) = client.room_id {
-match server.leave_room(client_id) {
+let result = server.leave_room(client_id);
-Ok(result) => {
+get_room_leave_data(server, room_id, &msg, result, response);
-let room = server.room(room_id);
-super::common::get_room_leave_data(server, room, &msg, result, response)
-}
-Err(_) => (),
-}
 }
 server.remove_client(client_id);
 response.add(LobbyLeft(nick, msg.clone()).send_all());
 let room = &server.rooms[room_id];
 if let Some(id) = room.master_id {
 response.add(
 ClientFlags(
 add_flags(&[Flags::RoomMaster]),
-vec![server.clients[id].nick.clone()],
+vec![server.client(id).nick.clone()],
 )
 .send(to_client),
 );
 }
-let nicks: Vec<_> = server
+let nicks = server.collect_nicks(|(_, c)| c.room_id == Some(room_id) && c.is_ready());
-.clients
-.iter()
-.filter(|(_, c)| c.room_id == Some(room_id) && c.is_ready())
-.map(|(_, c)| c.nick.clone())
-.collect();
 if !nicks.is_empty() {
 response.add(ClientFlags(add_flags(&[Flags::Ready]), nicks).send(to_client));
 }
 }
 VoteType::Kick(nick) => {
 if let Some(client) = server.find_client(&nick) {
 if client.room_id == Some(room_id) {
 let id = client.id;
 response.add(Kicked.send(id));
-match server.leave_room(response.client_id) {
+let result = server.leave_room(id);
-Ok(result) => {
+get_room_leave_data(server, room_id, "kicked", result, response);
-let room = server.room(room_id);
-super::common::get_room_leave_data(
-server, room, "kicked", result, response,
-)
-}
-Err(_) => (),
-}
 }
 }
 }
 VoteType::Map(None) => (),
 VoteType::Map(Some(name)) => {
 .send_all()
 .in_room(room_id),
 );
 let room = &server.rooms[room_id];
 let room_master = if let Some(id) = room.master_id {
-Some(&server.clients[id])
+Some(server.client(id))
 } else {
 None
 };
 get_room_update(None, room, room_master, response);
 result
 }
 pub fn submit_vote(server: &mut HwServer, vote: Vote, response: &mut Response) {
 let client_id = response.client_id;
-let client = &server.clients[client_id];
+let client = server.client(client_id);
 if let Some(room_id) = client.room_id {
-let room = &mut server.rooms[room_id];
+let room = server.room_mut(room_id);
 if let Some(res) = add_vote(room, response, vote) {
 response.add(
 server_chat("Voting closed.".to_string())
 .send_all()
 }
 }
 }
 }
-pub fn start_game(server: &mut HwServer, room_id: RoomId, response: &mut Response) {
+pub fn get_start_game_data(
-let (room_clients, room_nicks): (Vec<_>, Vec<_>) = server
+server: &HwServer,
-.clients
+room_id: RoomId,
-.iter()
+result: Result<Vec<String>, StartGameError>,
-.map(|(id, c)| (id, c.nick.clone()))
+response: &mut Response,
-.unzip();
+) {
-let room = &mut server.rooms[room_id];
+match result {
+Ok(room_nicks) => {
-if !room.has_multiple_clans() {
+let room = server.room(room_id);
-response.add(
+response.add(RunGame.send_all().in_room(room.id));
-Warning("The game can't be started with less than two clans!".to_string()).send_self(),
+response.add(
-);
+ClientFlags(add_flags(&[Flags::InGame]), room_nicks)
-} else if room.protocol_number <= 43 && room.players_number != room.ready_players_number {
+.send_all()
-response.add(Warning("Not all players are ready".to_string()).send_self());
+.in_room(room.id),
-} else if room.game_info.is_some() {
+);
-response.add(Warning("The game is already in progress".to_string()).send_self());
-} else {
+let room_master = room.master_id.map(|id| server.client(id));
-room.start_round();
+get_room_update(None, room, room_master, response);
-for id in room_clients {
+}
-let c = &mut server.clients[id];
+Err(StartGameError::NotEnoughClans) => {
-c.set_is_in_game(true);
+response.warn("The game can't be started with less than two clans!")
-c.team_indices = room.client_team_indices(c.id);
+}
-}
+Err(StartGameError::NotEnoughTeams) => (),
-response.add(RunGame.send_all().in_room(room.id));
+Err(StartGameError::NotReady) => response.warn("Not all players are ready"),
-response.add(
+Err(StartGameErrror) => response.warn("The game is already in progress"),
-ClientFlags(add_flags(&[Flags::InGame]), room_nicks)
-.send_all()
-.in_room(room.id),
-);
-let room_master = if let Some(id) = room.master_id {
-Some(&server.clients[id])
-} else {
-None
-};
-get_room_update(None, room, room_master, response);
 }
 }
 pub fn end_game(server: &mut HwServer, room_id: RoomId, response: &mut Response) {
 let room = &mut server.rooms[room_id];

changeset 15492	395be40faa51
parent 15487	91f0c5ec37b5
child 15516	b907b9071ec5