1 use crate::server::{

     2     client::HWClient,

     3     coretypes::{

     4         ClientId, GameCfg, GameCfg::*, RoomConfig, RoomId, TeamInfo, Voting, MAX_HEDGEHOGS_PER_TEAM,

     5     },

     6 };

     7 use bitflags::*;

     8 use serde::{Deserialize, Serialize};

     9 use serde_derive::{Deserialize, Serialize};

    10 use serde_yaml;

    11 use std::{collections::HashMap, iter};

    12 

    13 pub const MAX_TEAMS_IN_ROOM: u8 = 8;

    14 pub const MAX_HEDGEHOGS_IN_ROOM: u8 = MAX_HEDGEHOGS_PER_TEAM * MAX_HEDGEHOGS_PER_TEAM;

    15 

    16 fn client_teams_impl(

    17     teams: &[(ClientId, TeamInfo)],

    18     client_id: ClientId,

    19 ) -> impl Iterator<Item = &TeamInfo> + Clone {

    20     teams

    21         .iter()

    22         .filter(move |(id, _)| *id == client_id)

    23         .map(|(_, t)| t)

    24 }

    25 

    26 pub struct GameInfo {

    27     pub teams_in_game: u8,

    28     pub teams_at_start: Vec<(ClientId, TeamInfo)>,

    29     pub left_teams: Vec<String>,

    30     pub msg_log: Vec<String>,

    31     pub sync_msg: Option<String>,

    32     pub is_paused: bool,

    33     config: RoomConfig,

    34 }

    35 

    36 impl GameInfo {

    37     fn new(teams: Vec<(ClientId, TeamInfo)>, config: RoomConfig) -> GameInfo {

    38         GameInfo {

    39             left_teams: Vec::new(),

    40             msg_log: Vec::new(),

    41             sync_msg: None,

    42             is_paused: false,

    43             teams_in_game: teams.len() as u8,

    44             teams_at_start: teams,

    45             config,

    46         }

    47     }

    48 

    49     pub fn client_teams(&self, client_id: ClientId) -> impl Iterator<Item = &TeamInfo> + Clone {

    50         client_teams_impl(&self.teams_at_start, client_id)

    51     }

    52 }

    53 

    54 #[derive(Serialize, Deserialize)]

    55 pub struct RoomSave {

    56     pub location: String,

    57     config: RoomConfig,

    58 }

    59 

    60 bitflags! {

    61     pub struct RoomFlags: u8 {

    62         const FIXED = 0b0000_0001;

    63         const RESTRICTED_JOIN = 0b0000_0010;

    64         const RESTRICTED_TEAM_ADD = 0b0000_0100;

    65         const RESTRICTED_UNREGISTERED_PLAYERS = 0b0000_1000;

    66     }

    67 }

    68 

    69 pub struct HWRoom {

    70     pub id: RoomId,

    71     pub master_id: Option<ClientId>,

    72     pub name: String,

    73     pub password: Option<String>,

    74     pub greeting: String,

    75     pub protocol_number: u16,

    76     pub flags: RoomFlags,

    77 

    78     pub players_number: u8,

    79     pub default_hedgehog_number: u8,

    80     pub max_teams: u8,

    81     pub ready_players_number: u8,

    82     pub teams: Vec<(ClientId, TeamInfo)>,

    83     config: RoomConfig,

    84     pub voting: Option<Voting>,

    85     pub saves: HashMap<String, RoomSave>,

    86     pub game_info: Option<GameInfo>,

    87 }

    88 

    89 impl HWRoom {

    90     pub fn new(id: RoomId) -> HWRoom {

    91         HWRoom {

    92             id,

    93             master_id: None,

    94             name: String::new(),

    95             password: None,

    96             greeting: "".to_string(),

    97             flags: RoomFlags::empty(),

    98             protocol_number: 0,

    99             players_number: 0,

   100             default_hedgehog_number: 4,

   101             max_teams: MAX_TEAMS_IN_ROOM,

   102             ready_players_number: 0,

   103             teams: Vec::new(),

   104             config: RoomConfig::new(),

   105             voting: None,

   106             saves: HashMap::new(),

   107             game_info: None,

   108         }

   109     }

   110 

   111     pub fn hedgehogs_number(&self) -> u8 {

   112         self.teams.iter().map(|(_, t)| t.hedgehogs_number).sum()

   113     }

   114 

   115     pub fn addable_hedgehogs(&self) -> u8 {

   116         MAX_HEDGEHOGS_IN_ROOM - self.hedgehogs_number()

   117     }

   118 

   119     pub fn add_team(

   120         &mut self,

   121         owner_id: ClientId,

   122         mut team: TeamInfo,

   123         preserve_color: bool,

   124     ) -> &TeamInfo {

   125         if !preserve_color {

   126             team.color = iter::repeat(())

   127                 .enumerate()

   128                 .map(|(i, _)| i as u8)

   129                 .take(u8::max_value() as usize + 1)

   130                 .find(|i| self.teams.iter().all(|(_, t)| t.color != *i))

   131                 .unwrap_or(0u8)

   132         };

   133         team.hedgehogs_number = if self.teams.is_empty() {

   134             self.default_hedgehog_number

   135         } else {

   136             self.teams[0]

   137                 .1

   138                 .hedgehogs_number

   139                 .min(self.addable_hedgehogs())

   140         };

   141         self.teams.push((owner_id, team));

   142         &self.teams.last().unwrap().1

   143     }

   144 

   145     pub fn remove_team(&mut self, name: &str) {

   146         if let Some(index) = self.teams.iter().position(|(_, t)| t.name == name) {

   147             self.teams.remove(index);

   148         }

   149     }

   150 

   151     pub fn set_hedgehogs_number(&mut self, n: u8) -> Vec<String> {

   152         let mut names = Vec::new();

   153         let teams = match self.game_info {

   154             Some(ref mut info) => &mut info.teams_at_start,

   155             None => &mut self.teams,

   156         };

   157 

   158         if teams.len() as u8 * n <= MAX_HEDGEHOGS_IN_ROOM {

   159             for (_, team) in teams.iter_mut() {

   160                 team.hedgehogs_number = n;

   161                 names.push(team.name.clone())

   162             }

   163             self.default_hedgehog_number = n;

   164         }

   165         names

   166     }

   167 

   168     pub fn find_team_and_owner_mut<F>(&mut self, f: F) -> Option<(ClientId, &mut TeamInfo)>

   169     where

   170         F: Fn(&TeamInfo) -> bool,

   171     {

   172         self.teams

   173             .iter_mut()

   174             .find(|(_, t)| f(t))

   175             .map(|(id, t)| (*id, t))

   176     }

   177 

   178     pub fn find_team<F>(&self, f: F) -> Option<&TeamInfo>

   179     where

   180         F: Fn(&TeamInfo) -> bool,

   181     {

   182         self.teams

   183             .iter()

   184             .find_map(|(_, t)| Some(t).filter(|t| f(&t)))

   185     }

   186 

   187     pub fn client_teams(&self, client_id: ClientId) -> impl Iterator<Item = &TeamInfo> {

   188         client_teams_impl(&self.teams, client_id)

   189     }

   190 

   191     pub fn client_team_indices(&self, client_id: ClientId) -> Vec<u8> {

   192         self.teams

   193             .iter()

   194             .enumerate()

   195             .filter(move |(_, (id, _))| *id == client_id)

   196             .map(|(i, _)| i as u8)

   197             .collect()

   198     }

   199 

   200     pub fn clan_team_owners(&self, color: u8) -> impl Iterator<Item = ClientId> + '_ {

   201         self.teams

   202             .iter()

   203             .filter(move |(_, t)| t.color == color)

   204             .map(|(id, _)| *id)

   205     }

   206 

   207     pub fn find_team_owner(&self, team_name: &str) -> Option<(ClientId, &str)> {

   208         self.teams

   209             .iter()

   210             .find(|(_, t)| t.name == team_name)

   211             .map(|(id, t)| (*id, &t.name[..]))

   212     }

   213 

   214     pub fn find_team_color(&self, owner_id: ClientId) -> Option<u8> {

   215         self.client_teams(owner_id).nth(0).map(|t| t.color)

   216     }

   217 

   218     pub fn has_multiple_clans(&self) -> bool {

   219         self.teams.iter().min_by_key(|(_, t)| t.color)

   220             != self.teams.iter().max_by_key(|(_, t)| t.color)

   221     }

   222 

   223     pub fn set_config(&mut self, cfg: GameCfg) {

   224         self.config.set_config(cfg);

   225     }

   226 

   227     pub fn start_round(&mut self) {

   228         if self.game_info.is_none() {

   229             self.game_info = Some(GameInfo::new(self.teams.clone(), self.config.clone()));

   230         }

   231     }

   232 

   233     pub fn is_fixed(&self) -> bool {

   234         self.flags.contains(RoomFlags::FIXED)

   235     }

   236     pub fn is_join_restricted(&self) -> bool {

   237         self.flags.contains(RoomFlags::RESTRICTED_JOIN)

   238     }

   239     pub fn is_team_add_restricted(&self) -> bool {

   240         self.flags.contains(RoomFlags::RESTRICTED_TEAM_ADD)

   241     }

   242     pub fn are_unregistered_players_restricted(&self) -> bool {

   243         self.flags

   244             .contains(RoomFlags::RESTRICTED_UNREGISTERED_PLAYERS)

   245     }

   246 

   247     pub fn set_is_fixed(&mut self, value: bool) {

   248         self.flags.set(RoomFlags::FIXED, value)

   249     }

   250     pub fn set_join_restriction(&mut self, value: bool) {

   251         self.flags.set(RoomFlags::RESTRICTED_JOIN, value)

   252     }

   253     pub fn set_team_add_restriction(&mut self, value: bool) {

   254         self.flags.set(RoomFlags::RESTRICTED_TEAM_ADD, value)

   255     }

   256     pub fn set_unregistered_players_restriction(&mut self, value: bool) {

   257         self.flags

   258             .set(RoomFlags::RESTRICTED_UNREGISTERED_PLAYERS, value)

   259     }

   260 

   261     fn flags_string(&self) -> String {

   262         let mut result = "-".to_string();

   263         if self.game_info.is_some() {

   264             result += "g"

   265         }

   266         if self.password.is_some() {

   267             result += "p"

   268         }

   269         if self.is_join_restricted() {

   270             result += "j"

   271         }

   272         if self.are_unregistered_players_restricted() {

   273             result += "r"

   274         }

   275         result

   276     }

   277 

   278     pub fn info(&self, master: Option<&HWClient>) -> Vec<String> {

   279         let c = &self.config;

   280         vec![

   281             self.flags_string(),

   282             self.name.clone(),

   283             self.players_number.to_string(),

   284             self.teams.len().to_string(),

   285             master.map_or("[]", |c| &c.nick).to_string(),

   286             c.map_type.to_string(),

   287             c.script.to_string(),

   288             c.scheme.name.to_string(),

   289             c.ammo.name.to_string(),

   290         ]

   291     }

   292 

   293     pub fn active_config(&self) -> &RoomConfig {

   294         match self.game_info {

   295             Some(ref info) => &info.config,

   296             None => &self.config,

   297         }

   298     }

   299 

   300     pub fn map_config(&self) -> Vec<String> {

   301         match self.game_info {

   302             Some(ref info) => info.config.to_map_config(),

   303             None => self.config.to_map_config(),

   304         }

   305     }

   306 

   307     pub fn game_config(&self) -> Vec<GameCfg> {

   308         match self.game_info {

   309             Some(ref info) => info.config.to_game_config(),

   310             None => self.config.to_game_config(),

   311         }

   312     }

   313 

   314     pub fn save_config(&mut self, name: String, location: String) {

   315         self.saves.insert(

   316             name,

   317             RoomSave {

   318                 location,

   319                 config: self.config.clone(),

   320             },

   321         );

   322     }

   323 

   324     pub fn load_config(&mut self, name: &str) -> Option<&str> {

   325         if let Some(save) = self.saves.get(name) {

   326             self.config = save.config.clone();

   327             Some(&save.location[..])

   328         } else {

   329             None

   330         }

   331     }

   332 

   333     pub fn delete_config(&mut self, name: &str) -> bool {

   334         self.saves.remove(name).is_some()

   335     }

   336 

   337     pub fn get_saves(&self) -> Result<String, serde_yaml::Error> {

   338         serde_yaml::to_string(&(&self.greeting, &self.saves))

   339     }

   340 

   341     pub fn set_saves(&mut self, text: &str) -> Result<(), serde_yaml::Error> {

   342         serde_yaml::from_str::<(String, HashMap<String, RoomSave>)>(text).map(

   343             |(greeting, saves)| {

   344                 self.greeting = greeting;

   345                 self.saves = saves;

   346             },

   347         )

   348     }

   349 }