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

equal deleted inserted replaced

-:a077aac9df01
+:98ef2913ec73
-use std::{
-iter, collections::HashMap
-};
 use crate::server::{
-coretypes::{
+client::HWClient,
-ClientId, RoomId, TeamInfo, GameCfg, GameCfg::*, Voting,
+coretypes::{ClientId, GameCfg, GameCfg::*, RoomId, TeamInfo, Voting, MAX_HEDGEHOGS_PER_TEAM},
-MAX_HEDGEHOGS_PER_TEAM
-},
-client::{HWClient}
 };
 use bitflags::*;
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
-use serde_derive::{Serialize, Deserialize};
+use serde_derive::{Deserialize, Serialize};
 use serde_yaml;
+use std::{collections::HashMap, iter};
 const MAX_TEAMS_IN_ROOM: u8 = 8;
-const MAX_HEDGEHOGS_IN_ROOM: u8 =
+const MAX_HEDGEHOGS_IN_ROOM: u8 = MAX_HEDGEHOGS_PER_TEAM * MAX_HEDGEHOGS_PER_TEAM;
-MAX_HEDGEHOGS_PER_TEAM * MAX_HEDGEHOGS_PER_TEAM;
 #[derive(Clone, Serialize, Deserialize)]
 struct Ammo {
 name: String,
-settings: Option<String>
+settings: Option<String>,
 }
 #[derive(Clone, Serialize, Deserialize)]
 struct Scheme {
 name: String,
-settings: Vec<String>
+settings: Vec<String>,
 }
 #[derive(Clone, Serialize, Deserialize)]
 struct RoomConfig {
 feature_size: u32,
 ammo: Ammo,
 scheme: Scheme,
 script: String,
 theme: String,
-drawn_map: Option<String>
+drawn_map: Option<String>,
 }
 impl RoomConfig {
 fn new() -> RoomConfig {
 RoomConfig {
 map_generator: 0,
 maze_size: 0,
 seed: "seed".to_string(),
 template: 0,
-ammo: Ammo {name: "Default".to_string(), settings: None },
+ammo: Ammo {
-scheme: Scheme {name: "Default".to_string(), settings: Vec::new() },
+name: "Default".to_string(),
+settings: None,
+},
+scheme: Scheme {
+name: "Default".to_string(),
+settings: Vec::new(),
+},
 script: "Normal".to_string(),
 theme: "\u{1f994}".to_string(),
-drawn_map: None
+drawn_map: None,
 }
 }
 }
-fn client_teams_impl(teams: &[(ClientId, TeamInfo)], client_id: ClientId)
+fn client_teams_impl(
--> impl Iterator<Item = &TeamInfo> + Clone
+teams: &[(ClientId, TeamInfo)],
-{
+client_id: ClientId,
-teams.iter().filter(move |(id, _)| *id == client_id).map(|(_, t)| t)
+) -> impl Iterator<Item = &TeamInfo> + Clone {
+teams
+.iter()
+.filter(move |(id, _)| *id == client_id)
+.map(|(_, t)| t)
 }
 fn map_config_from(c: &RoomConfig) -> Vec<String> {
-vec![c.feature_size.to_string(), c.map_type.to_string(),
+vec![
-c.map_generator.to_string(), c.maze_size.to_string(),
+c.feature_size.to_string(),
-c.seed.to_string(), c.template.to_string()]
+c.map_type.to_string(),
+c.map_generator.to_string(),
+c.maze_size.to_string(),
+c.seed.to_string(),
+c.template.to_string(),
+]
 }
 fn game_config_from(c: &RoomConfig) -> Vec<GameCfg> {
 use crate::server::coretypes::GameCfg::*;
 let mut v = vec![
 Ammo(c.ammo.name.to_string(), c.ammo.settings.clone()),
 Scheme(c.scheme.name.to_string(), c.scheme.settings.clone()),
 Script(c.script.to_string()),
-Theme(c.theme.to_string())];
+Theme(c.theme.to_string()),
+];
 if let Some(ref m) = c.drawn_map {
 v.push(DrawnMap(m.to_string()))
 }
 v
 }
 pub teams_at_start: Vec<(ClientId, TeamInfo)>,
 pub left_teams: Vec<String>,
 pub msg_log: Vec<String>,
 pub sync_msg: Option<String>,
 pub is_paused: bool,
-config: RoomConfig
+config: RoomConfig,
 }
 impl GameInfo {
 fn new(teams: Vec<(ClientId, TeamInfo)>, config: RoomConfig) -> GameInfo {
 GameInfo {
 msg_log: Vec::new(),
 sync_msg: None,
 is_paused: false,
 teams_in_game: teams.len() as u8,
 teams_at_start: teams,
-config
+config,
 }
 }
 pub fn client_teams(&self, client_id: ClientId) -> impl Iterator<Item = &TeamInfo> + Clone {
 client_teams_impl(&self.teams_at_start, client_id)
 }
 #[derive(Serialize, Deserialize)]
 pub struct RoomSave {
 pub location: String,
-config: RoomConfig
+config: RoomConfig,
 }
-bitflags!{
+bitflags! {
 pub struct RoomFlags: u8 {
 const FIXED = 0b0000_0001;
 const RESTRICTED_JOIN = 0b0000_0010;
 const RESTRICTED_TEAM_ADD = 0b0000_0100;
 const RESTRICTED_UNREGISTERED_PLAYERS = 0b0000_1000;
 pub ready_players_number: u8,
 pub teams: Vec<(ClientId, TeamInfo)>,
 config: RoomConfig,
 pub voting: Option<Voting>,
 pub saves: HashMap<String, RoomSave>,
-pub game_info: Option<GameInfo>
+pub game_info: Option<GameInfo>,
 }
 impl HWRoom {
 pub fn new(id: RoomId) -> HWRoom {
 HWRoom {
 ready_players_number: 0,
 teams: Vec::new(),
 config: RoomConfig::new(),
 voting: None,
 saves: HashMap::new(),
-game_info: None
+game_info: None,
 }
 }
 pub fn hedgehogs_number(&self) -> u8 {
 self.teams.iter().map(|(_, t)| t.hedgehogs_number).sum()
 pub fn addable_hedgehogs(&self) -> u8 {
 MAX_HEDGEHOGS_IN_ROOM - self.hedgehogs_number()
 }
-pub fn add_team(&mut self, owner_id: ClientId, mut team: TeamInfo, preserve_color: bool) -> &TeamInfo {
+pub fn add_team(
+&mut self,
+owner_id: ClientId,
+mut team: TeamInfo,
+preserve_color: bool,
+) -> &TeamInfo {
 if !preserve_color {
-team.color = iter::repeat(()).enumerate()
+team.color = iter::repeat(())
-.map(|(i, _)| i as u8).take(u8::max_value() as usize + 1)
+.enumerate()
+.map(|(i, _)| i as u8)
+.take(u8::max_value() as usize + 1)
 .find(|i| self.teams.iter().all(|(_, t)| t.color != *i))
 .unwrap_or(0u8)
 };
 team.hedgehogs_number = if self.teams.is_empty() {
 self.default_hedgehog_number
 } else {
-self.teams[0].1.hedgehogs_number.min(self.addable_hedgehogs())
+self.teams[0]
+.1
+.hedgehogs_number
+.min(self.addable_hedgehogs())
 };
 self.teams.push((owner_id, team));
 &self.teams.last().unwrap().1
 }
 pub fn set_hedgehogs_number(&mut self, n: u8) -> Vec<String> {
 let mut names = Vec::new();
 let teams = match self.game_info {
 Some(ref mut info) => &mut info.teams_at_start,
-None => &mut self.teams
+None => &mut self.teams,
 };
 if teams.len() as u8 * n <= MAX_HEDGEHOGS_IN_ROOM {
 for (_, team) in teams.iter_mut() {
 team.hedgehogs_number = n;
 names.push(team.name.clone())
-};
+}
 self.default_hedgehog_number = n;
 }
 names
 }
 pub fn find_team_and_owner_mut<F>(&mut self, f: F) -> Option<(ClientId, &mut TeamInfo)>
-where F: Fn(&TeamInfo) -> bool {
+where
-self.teams.iter_mut().find(|(_, t)| f(t)).map(|(id, t)| (*id, t))
+F: Fn(&TeamInfo) -> bool,
+{
+self.teams
+.iter_mut()
+.find(|(_, t)| f(t))
+.map(|(id, t)| (*id, t))
 }
 pub fn find_team<F>(&self, f: F) -> Option<&TeamInfo>
-where F: Fn(&TeamInfo) -> bool {
+where
-self.teams.iter().find_map(|(_, t)| Some(t).filter(|t| f(&t)))
+F: Fn(&TeamInfo) -> bool,
+{
+self.teams
+.iter()
+.find_map(|(_, t)| Some(t).filter(|t| f(&t)))
 }
 pub fn client_teams(&self, client_id: ClientId) -> impl Iterator<Item = &TeamInfo> {
 client_teams_impl(&self.teams, client_id)
 }
 pub fn client_team_indices(&self, client_id: ClientId) -> Vec<u8> {
-self.teams.iter().enumerate()
+self.teams
+.iter()
+.enumerate()
 .filter(move |(_, (id, _))| *id == client_id)
-.map(|(i, _)| i as u8).collect()
+.map(|(i, _)| i as u8)
+.collect()
 }
 pub fn find_team_owner(&self, team_name: &str) -> Option<(ClientId, &str)> {
-self.teams.iter().find(|(_, t)| t.name == team_name)
+self.teams
+.iter()
+.find(|(_, t)| t.name == team_name)
 .map(|(id, t)| (*id, &t.name[..]))
 }
 pub fn find_team_color(&self, owner_id: ClientId) -> Option<u8> {
 self.client_teams(owner_id).nth(0).map(|t| t.color)
 }
 pub fn has_multiple_clans(&self) -> bool {
-self.teams.iter().min_by_key(|(_, t)| t.color) !=
+self.teams.iter().min_by_key(|(_, t)| t.color)
-self.teams.iter().max_by_key(|(_, t)| t.color)
+!= self.teams.iter().max_by_key(|(_, t)| t.color)
 }
 pub fn set_config(&mut self, cfg: GameCfg) {
 let c = &mut self.config;
 match cfg {
 MapGenerator(g) => c.map_generator = g,
 MazeSize(s) => c.maze_size = s,
 Seed(s) => c.seed = s,
 Template(t) => c.template = t,
-Ammo(n, s) => c.ammo = Ammo {name: n, settings: s},
+Ammo(n, s) => {
-Scheme(n, s) => c.scheme = Scheme {name: n, settings: s},
+c.ammo = Ammo {
+name: n,
+settings: s,
+}
+}
+Scheme(n, s) => {
+c.scheme = Scheme {
+name: n,
+settings: s,
+}
+}
 Script(s) => c.script = s,
 Theme(t) => c.theme = t,
-DrawnMap(m) => c.drawn_map = Some(m)
+DrawnMap(m) => c.drawn_map = Some(m),
 };
 }
 pub fn start_round(&mut self) {
 if self.game_info.is_none() {
-self.game_info = Some(GameInfo::new(
+self.game_info = Some(GameInfo::new(self.teams.clone(), self.config.clone()));
-self.teams.clone(), self.config.clone()));
 }
 }
 pub fn is_fixed(&self) -> bool {
 self.flags.contains(RoomFlags::FIXED)
 }
 pub fn is_team_add_restricted(&self) -> bool {
 self.flags.contains(RoomFlags::RESTRICTED_TEAM_ADD)
 }
 pub fn are_unregistered_players_restricted(&self) -> bool {
-self.flags.contains(RoomFlags::RESTRICTED_UNREGISTERED_PLAYERS)
+self.flags
+.contains(RoomFlags::RESTRICTED_UNREGISTERED_PLAYERS)
 }
 pub fn set_is_fixed(&mut self, value: bool) {
 self.flags.set(RoomFlags::FIXED, value)
 }
 }
 pub fn set_team_add_restriction(&mut self, value: bool) {
 self.flags.set(RoomFlags::RESTRICTED_TEAM_ADD, value)
 }
 pub fn set_unregistered_players_restriction(&mut self, value: bool) {
-self.flags.set(RoomFlags::RESTRICTED_UNREGISTERED_PLAYERS, value)
+self.flags
+.set(RoomFlags::RESTRICTED_UNREGISTERED_PLAYERS, value)
 }
 fn flags_string(&self) -> String {
 let mut result = "-".to_string();
-if self.game_info.is_some()  { result += "g" }
+if self.game_info.is_some() {
-if self.password.is_some()   { result += "p" }
+result += "g"
-if self.is_join_restricted() { result += "j" }
+}
+if self.password.is_some() {
+result += "p"
+}
+if self.is_join_restricted() {
+result += "j"
+}
 if self.are_unregistered_players_restricted() {
 result += "r"
 }
 result
 }
 self.teams.len().to_string(),
 master.map_or("[]", |c| &c.nick).to_string(),
 c.map_type.to_string(),
 c.script.to_string(),
 c.scheme.name.to_string(),
-c.ammo.name.to_string()
+c.ammo.name.to_string(),
 ]
 }
 pub fn map_config(&self) -> Vec<String> {
 match self.game_info {
 Some(ref info) => map_config_from(&info.config),
-None => map_config_from(&self.config)
+None => map_config_from(&self.config),
 }
 }
 pub fn game_config(&self) -> Vec<GameCfg> {
 match self.game_info {
 Some(ref info) => game_config_from(&info.config),
-None => game_config_from(&self.config)
+None => game_config_from(&self.config),
 }
 }
 pub fn save_config(&mut self, name: String, location: String) {
-self.saves.insert(name, RoomSave { location, config: self.config.clone() });
+self.saves.insert(
+name,
+RoomSave {
+location,
+config: self.config.clone(),
+},
+);
 }
 pub fn load_config(&mut self, name: &str) -> Option<&str> {
 if let Some(save) = self.saves.get(name) {
 self.config = save.config.clone();
 pub fn get_saves(&self) -> Result<String, serde_yaml::Error> {
 serde_yaml::to_string(&(&self.greeting, &self.saves))
 }
 pub fn set_saves(&mut self, text: &str) -> Result<(), serde_yaml::Error> {
-serde_yaml::from_str::<(String, HashMap<String, RoomSave>)>(text).map(|(greeting, saves)| {
+serde_yaml::from_str::<(String, HashMap<String, RoomSave>)>(text).map(
-self.greeting = greeting;
+|(greeting, saves)| {
-self.saves = saves;
+self.greeting = greeting;
-})
+self.saves = saves;
+},
+)
 }
 pub fn team_info(owner: &HWClient, team: &TeamInfo) -> Vec<String> {
 let mut info = vec![
 team.name.clone(),
 team.grave.clone(),
 team.fort.clone(),
 team.voice_pack.clone(),
 team.flag.clone(),
 owner.nick.clone(),
-team.difficulty.to_string()];
+team.difficulty.to_string(),
-let hogs = team.hedgehogs.iter().flat_map(|h|
+];
-iter::once(h.name.clone()).chain(iter::once(h.hat.clone())));
+let hogs = team
+.hedgehogs
+.iter()
+.flat_map(|h| iter::once(h.name.clone()).chain(iter::once(h.hat.clone())));
 info.extend(hogs);
 info
 }
 }

changeset 14457	98ef2913ec73
parent 14415	06672690d71b
child 14785	a1077e8d26f4