hedgewars-draft: comparison rust/hedgewars-server/src/handlers/inroom.rs

equal deleted inserted replaced

-:4a0b06b03199
+:f4f6060b536c
 use super::{common::rnd_reply, strings::*};
 use crate::core::room::GameInfo;
-use crate::core::server::AddTeamError;
+use crate::core::server::{AddTeamError, SetTeamCountError};
 use crate::{
 core::{
 room::{HwRoom, RoomFlags, MAX_TEAMS_IN_ROOM},
 server::{
-ChangeMasterError, ChangeMasterResult, HwServer, LeaveRoomResult, ModifyTeamError,
+ChangeMasterError, ChangeMasterResult, HwRoomControl, LeaveRoomResult, ModifyTeamError,
 StartGameError,
 },
 types,
 types::{ClientId, GameCfg, RoomId, VoteType, Voting, MAX_HEDGEHOGS_PER_TEAM},
 },
 _ => RoomFlags::empty(),
 }
 }
 pub fn handle(
-server: &mut HwServer,
+mut room_control: HwRoomControl,
-client_id: ClientId,
 response: &mut super::Response,
-room_id: RoomId,
 message: HwProtocolMessage,
 ) {
-let (client, room) = server.client_and_room_mut(client_id, room_id);
+let (client, room) = room_control.get();
+let (client_id, room_id) = (client.id, room.id);
 use crate::protocol::messages::HwProtocolMessage::*;
 match message {
 Part(msg) => {
 let msg = match msg {
 Some(s) => format!("part: {}", s),
 None => "part".to_string(),
 };
-let result = server.leave_room(client_id);
+let result = room_control.leave_room();
-super::common::get_room_leave_data(server, room_id, &msg, result, response);
+super::common::get_room_leave_result(
+room_control.server(),
+room_control.room(),
+&msg,
+result,
+response,
+);
 }
 Chat(msg) => {
 response.add(
 ChatMsg {
 nick: client.nick.clone(),
 response.add(ForwardEngineMessage(vec![engine_msg]).send_many(team))
 }
 }
 }
 Fix => {
-if client.is_admin() {
+if let Err(_) = room_control.fix_room() {
-room.set_is_fixed(true);
-room.set_join_restriction(false);
-room.set_team_add_restriction(false);
-room.set_unregistered_players_restriction(true);
-} else {
 response.warn(ACCESS_DENIED)
 }
 }
 Unfix => {
-if client.is_admin() {
+if let Err(_) = room_control.unfix_room() {
-room.set_is_fixed(false);
-} else {
 response.warn(ACCESS_DENIED)
 }
 }
 Greeting(text) => {
-if client.is_admin() || client.is_master() && !room.is_fixed() {
+if let Err(_) = room_control.set_room_greeting(text) {
-room.greeting = text.unwrap_or(String::new());
+response.warn(ACCESS_DENIED)
 }
 }
 MaxTeams(count) => {
-if !client.is_master() {
+use crate::core::server::SetTeamCountError;
-response.warn(NOT_MASTER);
+match room_control.set_room_max_teams(count) {
-} else if !(2..=MAX_TEAMS_IN_ROOM).contains(&count) {
+Ok(()) => {}
-response.warn("/maxteams: specify number from 2 to 8");
+Err(SetTeamCountError::NotMaster) => response.warn(NOT_MASTER),
-} else {
+Err(SetTeamCountError::InvalidNumber) => {
-room.max_teams = count;
+response.warn("/maxteams: specify number from 2 to 8")
 }
+};
 }
 RoomName(new_name) => {
 use crate::core::server::ModifyRoomNameError;
-match server.set_room_name(client_id, room_id, new_name) {
+match room_control.set_room_name(new_name) {
 Ok(old_name) => {
-let (client, room) = server.client_and_room(client_id, room_id);
+let (client, room) = room_control.get();
 super::common::get_room_update(Some(old_name), room, Some(client), response)
 }
 Err(ModifyRoomNameError::AccessDenied) => response.warn(ACCESS_DENIED),
 Err(ModifyRoomNameError::InvalidName) => response.warn(ILLEGAL_ROOM_NAME),
 Err(ModifyRoomNameError::DuplicateName) => response.warn(ROOM_EXISTS),
 }
 }
 ToggleReady => {
-let flags = if server.toggle_ready(client_id) {
+let flags = if room_control.toggle_ready() {
 add_flags(&[Flags::Ready])
 } else {
 remove_flags(&[Flags::Ready])
 };
-let (client, room) = server.client_and_room(client_id, room_id);
+let (client, room) = room_control.get();
 let msg = if client.protocol_number < 38 {
 LegacyReady(client.is_ready(), vec![client.nick.clone()])
 } else {
 ClientFlags(flags, vec![client.nick.clone()])
 };
 response.add(msg.send_all().in_room(room_id));
 if room.is_fixed() && room.ready_players_number == room.players_number {
-let result = server.start_game(room_id);
+let result = room_control.start_game();
-super::common::get_start_game_data(server, room_id, result, response);
+super::common::get_start_game_data(
+room_control.server(),
+room_id,
+result,
+response,
+);
 }
 }
 AddTeam(info) => {
 use crate::core::server::AddTeamError;
-match server.add_team(client_id, info) {
+match room_control.add_team(info) {
 Ok(team) => {
 response.add(TeamAccepted(team.name.clone()).send_self());
 response.add(
 TeamAdd(team.to_protocol())
 .send_all()
 HedgehogsNumber(team.name.clone(), team.hedgehogs_number)
 .send_all()
 .in_room(room_id),
 );
-let room = server.room(room_id);
+let room = room_control.room();
 let room_master = if let Some(id) = room.master_id {
-Some(server.client(id))
+Some(room_control.server().client(id))
 } else {
 None
 };
 super::common::get_room_update(None, room, room_master, response);
 }
 Err(AddTeamError::Restricted) => response.warn(TEAM_ADD_RESTRICTED),
 }
 }
 RemoveTeam(name) => {
 use crate::core::server::RemoveTeamError;
-match server.remove_team(client_id, &name) {
+match room_control.remove_team(&name) {
 Ok(()) => {
-let (client, room) = server.client_and_room(client_id, room_id);
+let (client, room) = room_control.get();
 let removed_teams = vec![name];
 super::common::get_remove_teams_data(
 room_id,
 client.is_in_game(),
 response,
 );
 match room.game_info {
 Some(ref info) if info.teams_in_game == 0 => {
-let result = server.end_game(room_id);
+if let Some(result) = room_control.end_game() {
-super::common::get_end_game_result(server, room_id, result, response);
+super::common::get_end_game_result(
+room_control.server(),
+room_id,
+result,
+response,
+);
+}
 }
 _ => (),
 }
 }
 Err(RemoveTeamError::NoTeam) => response.warn(NO_TEAM_TO_REMOVE),
 Err(RemoveTeamError::TeamNotOwned) => response.warn(TEAM_NOT_OWNED),
 }
 }
 SetHedgehogsNumber(team_name, number) => {
-let addable_hedgehogs = room.addable_hedgehogs();
+use crate::core::server::SetHedgehogsError;
-if let Some((_, team)) = room.find_team_and_owner_mut(|t| t.name == team_name) {
+match room_control.set_team_hedgehogs_number(&team_name, number) {
-let max_hedgehogs = min(
+Ok(()) => {
-MAX_HEDGEHOGS_PER_TEAM,
+response.add(
-addable_hedgehogs + team.hedgehogs_number,
+HedgehogsNumber(team_name.clone(), number)
-);
-if !client.is_master() {
-response.error(NOT_MASTER);
-} else if !(1..=max_hedgehogs).contains(&number) {
-response
-.add(HedgehogsNumber(team.name.clone(), team.hedgehogs_number).send_self());
-} else {
-team.hedgehogs_number = number;
-response.add(
-HedgehogsNumber(team.name.clone(), number)
 .send_all()
 .in_room(room_id)
 .but_self(),
 );
 }
-} else {
+Err(SetHedgehogsError::NotMaster) => response.error(NOT_MASTER),
-response.warn(NO_TEAM);
+Err(SetHedgehogsError::NoTeam) => response.warn(NO_TEAM),
-}
+Err(SetHedgehogsError::InvalidNumber(previous_number)) => {
-}
+response.add(HedgehogsNumber(team_name.clone(), previous_number).send_self())
-SetTeamColor(team_name, color) => {
+}
-match server.set_team_color(client_id, room_id, &team_name, color) {
+}
-Ok(()) => response.add(
+}
-TeamColor(team_name, color)
+SetTeamColor(team_name, color) => match room_control.set_team_color(&team_name, color) {
-.send_all()
+Ok(()) => response.add(
-.in_room(room_id)
+TeamColor(team_name, color)
-.but_self(),
+.send_all()
-),
+.in_room(room_id)
-Err(ModifyTeamError::NoTeam) => response.warn(NO_TEAM),
+.but_self(),
-Err(ModifyTeamError::NotMaster) => response.error(NOT_MASTER),
+),
-}
+Err(ModifyTeamError::NoTeam) => response.warn(NO_TEAM),
-}
+Err(ModifyTeamError::NotMaster) => response.error(NOT_MASTER),
+},
 Cfg(cfg) => {
-if room.is_fixed() {
+use crate::core::server::SetConfigError;
-response.warn(ACCESS_DENIED);
+let msg = cfg.to_server_msg();
-} else if !client.is_master() {
+match room_control.set_config(cfg) {
-response.error(NOT_MASTER);
+Ok(()) => {
-} else {
+response.add(msg.send_all().in_room(room_control.room().id).but_self());
-let cfg = match cfg {
+}
-GameCfg::Scheme(name, mut values) => {
+Err(SetConfigError::NotMaster) => response.error(NOT_MASTER),
-if client.protocol_number == 49 && values.len() >= 2 {
+Err(SetConfigError::RoomFixed) => response.warn(ACCESS_DENIED),
-let mut s = "X".repeat(50);
-s.push_str(&values.pop().unwrap());
-values.push(s);
-}
-GameCfg::Scheme(name, values)
-}
-cfg => cfg,
-};
-response.add(cfg.to_server_msg().send_all().in_room(room.id).but_self());
-room.set_config(cfg);
 }
 }
 Save(name, location) => {
 response.add(
 server_chat(format!("Room config saved as {}", name))
 .send_all()
 .in_room(room_id),
 );
-room.save_config(name, location);
+room_control.save_config(name, location);
 }
 #[cfg(feature = "official-server")]
 SaveRoom(filename) => {
 if client.is_admin() {
 match room.get_saves() {
 if client.is_admin() {
 response.request_io(super::IoTask::LoadRoom { room_id, filename });
 }
 }
 Delete(name) => {
-if !room.delete_config(&name) {
+if !room_control.delete_config(&name) {
 response.add(Warning(format!("Save doesn't exist: {}", name)).send_self());
 } else {
 response.add(
 server_chat(format!("Room config {} has been deleted", name))
 .send_all()
 }
 CallVote(None) => {
 response.add(server_chat("Available callvote commands: kick <nickname>, map <name>, pause, newseed, hedgehogs <number>".to_string())
 .send_self());
 }
-CallVote(Some(kind)) => {
+/*CallVote(Some(kind)) => {
 let is_in_game = room.game_info.is_some();
 let error = match &kind {
 VoteType::Kick(nick) => {
-if server
+if room_control.server()
 .find_client(&nick)
 .filter(|c| c.room_id == Some(room_id))
 .is_some()
 {
 None
 } else {
 Some("/callvote kick: No such user!".to_string())
 }
 }
 VoteType::Map(None) => {
-let names: Vec<_> = server.room(room_id).saves.keys().cloned().collect();
+let names: Vec<_> = room.saves.keys().cloned().collect();
 if names.is_empty() {
 Some("/callvote map: No maps saved in this room!".to_string())
 } else {
 Some(format!("Available maps: {}", names.join(", ")))
 }
 };
 match error {
 None => {
 let msg = voting_description(&kind);
-let voting = Voting::new(kind, server.room_clients(client_id).collect());
+let voting = Voting::new(kind, room_control.server().room_clients(client_id).collect());
-let room = server.room_mut(room_id);
+let room = room_control.server().room_mut(room_id);
 room.voting = Some(voting);
 response.add(server_chat(msg).send_all().in_room(room_id));
 super::common::submit_vote(
-server,
+room_control.server(),
 types::Vote {
 is_pro: true,
 is_forced: false,
 },
 response,
 }
 Some(msg) => {
 response.add(server_chat(msg).send_self());
 }
 }
-}
+}*/
-Vote(vote) => {
+/*Vote(vote) => {
 super::common::submit_vote(
-server,
+room_control.server(),
 types::Vote {
 is_pro: vote,
 is_forced: false,
 },
 response,
 );
-}
+}*/
-ForceVote(vote) => {
+/*ForceVote(vote) => {
 let is_forced = client.is_admin();
 super::common::submit_vote(
-server,
+room_control.server(),
 types::Vote {
 is_pro: vote,
 is_forced,
 },
 response,
 );
-}
+}*/
 ToggleRestrictJoin | ToggleRestrictTeams | ToggleRegisteredOnly => {
-if client.is_master() {
+if room_control.toggle_flag(room_message_flag(&message)) {
-room.flags.toggle(room_message_flag(&message));
+let (client, room) = room_control.get();
 super::common::get_room_update(None, room, Some(&client), response);
 }
 }
 StartGame => {
-let result = server.start_game(room_id);
+let result = room_control.start_game();
-super::common::get_start_game_data(server, room_id, result, response);
+super::common::get_start_game_data(room_control.server(), room_id, result, response);
 }
-EngineMessage(em) => {
+/*EngineMessage(em) => {
 if client.teams_in_game > 0 {
 let decoding = decode(&em[..]).unwrap();
 let messages = by_msg(&decoding);
 let valid = messages.filter(|m| is_msg_valid(m, &client.team_indices));
 let non_empty = valid.clone().filter(|m| !is_msg_empty(m));
 if let Some(msg) = sync_msg {
 info.sync_msg = msg;
 }
 }
 }
-}
+}*/
 RoundFinished => {
-if let Some(team_names) = server.leave_game(client_id) {
+if let Some(team_names) = room_control.leave_game() {
-let (client, room) = server.client_and_room(client_id, room_id);
+let (client, room) = room_control.get();
 response.add(
 ClientFlags(remove_flags(&[Flags::InGame]), vec![client.nick.clone()])
 .send_all()
 .in_room(room.id),
 );
 if let Some(GameInfo {
 teams_in_game: 0, ..
 }) = room.game_info
 {
-let result = server.end_game(room_id);
+if let Some(result) = room_control.end_game() {
-super::common::get_end_game_result(server, room_id, result, response);
+super::common::get_end_game_result(
+room_control.server(),
+room_id,
+result,
+response,
+);
+}
 }
 }
 }
 Rnd(v) => {
 let result = rnd_reply(&v);
 let mut echo = vec!["/rnd".to_string()];
 echo.extend(v.into_iter());
 let chat_msg = ChatMsg {
-nick: server.client(client_id).nick.clone(),
+nick: client.nick.clone(),
 msg: echo.join(" "),
 };
 response.add(chat_msg.send_all().in_room(room_id));
 response.add(result.send_all().in_room(room_id));
 }
-Delegate(nick) => match server.change_master(client_id, room_id, nick) {
+Delegate(nick) => match room_control.change_master(nick) {
 Ok(ChangeMasterResult {
 old_master_id,
 new_master_id,
 }) => {
 if let Some(master_id) = old_master_id {
 response.add(
 ClientFlags(
 remove_flags(&[Flags::RoomMaster]),
-vec![server.client(master_id).nick.clone()],
+vec![room_control.server().client(master_id).nick.clone()],
 )
 .send_all()
 .in_room(room_id),
 );
 }
 response.add(
 ClientFlags(
 add_flags(&[Flags::RoomMaster]),
-vec![server.client(new_master_id).nick.clone()],
+vec![room_control.server().client(new_master_id).nick.clone()],
 )
 .send_all()
 .in_room(room_id),
 );
 }

changeset 15545	f4f6060b536c
parent 15544	4a0b06b03199
child 15547	16d3c9acd715