hedgewars: comparison rust/hedgewars-server/src/server/actions.rs

equal deleted inserted replaced

-:669eb45bda72
+:9f98086de1b6
 }
 }
 pub enum Action {
 ChangeMaster(RoomId, Option<ClientId>),
-SendRoomUpdate(Option<String>),
 StartRoomGame(RoomId),
 SendTeamRemovalMessage(String),
 FinishRoomGame(RoomId),
 SendRoomData {
 to: ClientId,
 teams: bool,
 config: bool,
 flags: bool,
 },
-AddVote {
-vote: bool,
-is_forced: bool,
-},
 ApplyVoting(VoteType, RoomId),
 }
 use self::Action::*;
 to,
 teams,
 config,
 flags,
 } => {
-let mut actions = Vec::new();
 let room_id = server.clients[client_id].room_id;
 if let Some(r) = room_id.and_then(|id| server.rooms.get(id)) {
 if config {
 /*                    actions.push(
 ConfigEntry("FULLMAPCONFIG".to_string(), r.map_config())
 /*actions.push(ClientFlags("+r".to_string(), nicks).send(to).action())*/
 ;
 }
 }
 }
-server.react(client_id, actions);
-}
-AddVote { vote, is_forced } => {
-let mut actions = Vec::new();
-if let Some(r) = server.room(client_id) {
-let mut result = None;
-if let Some(ref mut voting) = r.voting {
-if is_forced || voting.votes.iter().all(|(id, _)| client_id != *id) {
-/*                        actions.push(
-server_chat("Your vote has been counted.".to_string())
-.send_self()
-.action(),
-)*/
-;
-voting.votes.push((client_id, vote));
-let i = voting.votes.iter();
-let pro = i.clone().filter(|(_, v)| *v).count();
-let contra = i.filter(|(_, v)| !*v).count();
-let success_quota = voting.voters.len() / 2 + 1;
-if is_forced && vote || pro >= success_quota {
-result = Some(true);
-} else if is_forced && !vote || contra > voting.voters.len() - success_quota
-{
-result = Some(false);
-}
-} else {
-/*                        actions.push(
-server_chat("You already have voted.".to_string())
-.send_self()
-.action(),
-)*/
-;
-}
-} else {
-/*                    actions.push(
-server_chat("There's no voting going on.".to_string())
-.send_self()
-.action(),
-)*/
-;
-}
-if let Some(res) = result {
-/*actions.push(
-server_chat("Voting closed.".to_string())
-.send_all()
-.in_room(r.id)
-.action(),
-);*/
-let voting = replace(&mut r.voting, None).unwrap();
-if res {
-actions.push(ApplyVoting(voting.kind, r.id));
-}
-}
-}
-server.react(client_id, actions);
 }
 ApplyVoting(kind, room_id) => {
 let mut actions = Vec::new();
 let mut id = client_id;
 match kind {
 server_chat(location.to_string())
 .send_all()
 .in_room(room_id)
 .action(),
 );*/
-actions.push(SendRoomUpdate(None));
+//actions.push(SendRoomUpdate(None));
 for (_, c) in server.clients.iter() {
 if c.room_id == Some(room_id) {
 actions.push(SendRoomData {
 to: c.id,
 teams: false,
 .in_room(room_id)
 .action()
 }));*/
 }
 }
-server.react(id, actions);
 }
 ChangeMaster(room_id, new_id) => {
-let mut actions = Vec::new();
 let room_client_ids = server.room_clients(room_id);
 let new_id = if server
 .room(client_id)
 .map(|r| r.is_fixed())
 .unwrap_or(false)
 }
 }
 if let Some(id) = new_id {
 server.clients[id].set_is_master(true)
 }
-server.react(client_id, actions);
-}
-SendRoomUpdate(old_name) => {
-if let (c, Some(r)) = server.client_and_room(client_id) {
-let name = old_name.unwrap_or_else(|| r.name.clone());
-/*let actions = vec![RoomUpdated(name, r.info(Some(&c)))
-.send_all()
-.with_protocol(r.protocol_number)
-.action()];
-server.react(client_id, actions);*/
-}
 }
 StartRoomGame(room_id) => {
-let actions = {
+let (room_clients, room_nicks): (Vec<_>, Vec<_>) = server
-let (room_clients, room_nicks): (Vec<_>, Vec<_>) = server
+.clients
-.clients
+.iter()
-.iter()
+.map(|(id, c)| (id, c.nick.clone()))
-.map(|(id, c)| (id, c.nick.clone()))
+.unzip();
-.unzip();
+let room = &mut server.rooms[room_id];
-let room = &mut server.rooms[room_id];
+if !room.has_multiple_clans() {
-if !room.has_multiple_clans() {
+/*Warn(
-vec![/*Warn(
+"The game can't be started with less than two clans!".to_string(),
-"The game can't be started with less than two clans!".to_string(),
+)*/
-)*/]
+} else if room.protocol_number <= 43 && room.players_number != room.ready_players_number
-} else if room.protocol_number <= 43
+{
-&& room.players_number != room.ready_players_number
+/*Warn("Not all players are ready".to_string())*/
-{
+} else if room.game_info.is_some() {
-vec![/*Warn("Not all players are ready".to_string())*/]
+/*Warn("The game is already in progress".to_string())*/
-} else if room.game_info.is_some() {
+} else {
-vec![/*Warn("The game is already in progress".to_string())*/]
+room.start_round();
-} else {
+for id in room_clients {
-room.start_round();
+let c = &mut server.clients[id];
-for id in room_clients {
+c.set_is_in_game(false);
-let c = &mut server.clients[id];
+c.team_indices = room.client_team_indices(c.id);
-c.set_is_in_game(false);
+}
-c.team_indices = room.client_team_indices(c.id);
+/*RunGame.send_all().in_room(room.id).action(),*/
-}
+//SendRoomUpdate(None),
-vec![
+/*ClientFlags("+g".to_string(), room_nicks)
-/*RunGame.send_all().in_room(room.id).action(),*/
+.send_all()
-SendRoomUpdate(None),
+.in_room(room.id)
-/*ClientFlags("+g".to_string(), room_nicks)
+.action(),*/
-.send_all()
+}
-.in_room(room.id)
-.action(),*/
-]
-}
-};
-server.react(client_id, actions);
 }
 SendTeamRemovalMessage(team_name) => {
 let mut actions = Vec::new();
 if let Some(r) = server.room(client_id) {
 if let Some(ref mut info) = r.game_info {
 .but_self()
 .action(),
 );*/
 }
 }
-server.react(client_id, actions);
 }
 FinishRoomGame(room_id) => {
 let mut actions = Vec::new();
 let r = &mut server.rooms[room_id];
 r.ready_players_number = 1;
-actions.push(SendRoomUpdate(None));
+//actions.push(SendRoomUpdate(None));
 //actions.push(RoundFinished.send_all().in_room(r.id).action());
 if let Some(info) = replace(&mut r.game_info, None) {
 for (_, c) in server.clients.iter() {
 if c.room_id == Some(room_id) && c.is_joined_mid_game() {
 } else {
 ClientFlags("-r".to_string(), nicks)
 };
 //actions.push(msg.send_all().in_room(room_id).action());
 }
-server.react(client_id, actions);
+}
 }
 }
-}

changeset 14686	9f98086de1b6
parent 14683	932ff7683653
child 14687	5122c584804e