1 use serde_derive::{Deserialize, Serialize};

     2 

     3 pub const MAX_HEDGEHOGS_PER_TEAM: u8 = 8;

     4 

     5 #[derive(PartialEq, Eq, Clone, Debug)]

     6 pub enum ServerVar {

     7     MOTDNew(String),

     8     MOTDOld(String),

     9     LatestProto(u16),

    10 }

    11 

    12 #[derive(PartialEq, Eq, Clone, Debug)]

    13 pub enum GameCfg {

    14     FeatureSize(u32),

    15     MapType(String),

    16     MapGenerator(u32),

    17     MazeSize(u32),

    18     Seed(String),

    19     Template(u32),

    20 

    21     Ammo(String, Option<String>),

    22     Scheme(String, Vec<String>),

    23     Script(String),

    24     Theme(String),

    25     DrawnMap(String),

    26 }

    27 

    28 #[derive(PartialEq, Eq, Clone, Debug, Default)]

    29 pub struct TeamInfo {

    30     pub owner: String,

    31     pub name: String,

    32     pub color: u8,

    33     pub grave: String,

    34     pub fort: String,

    35     pub voice_pack: String,

    36     pub flag: String,

    37     pub difficulty: u8,

    38     pub hedgehogs_number: u8,

    39     pub hedgehogs: [HedgehogInfo; MAX_HEDGEHOGS_PER_TEAM as usize],

    40 }

    41 

    42 #[derive(PartialEq, Eq, Clone, Debug, Default)]

    43 pub struct HedgehogInfo {

    44     pub name: String,

    45     pub hat: String,

    46 }

    47 

    48 #[derive(Clone, Serialize, Deserialize, Debug)]

    49 pub struct Ammo {

    50     pub name: String,

    51     pub settings: Option<String>,

    52 }

    53 

    54 #[derive(Clone, Serialize, Deserialize, Debug)]

    55 pub struct Scheme {

    56     pub name: String,

    57     pub settings: Vec<String>,

    58 }

    59 

    60 #[derive(Clone, Serialize, Deserialize, Debug)]

    61 pub struct RoomConfig {

    62     pub feature_size: u32,

    63     pub map_type: String,

    64     pub map_generator: u32,

    65     pub maze_size: u32,

    66     pub seed: String,

    67     pub template: u32,

    68 

    69     pub ammo: Ammo,

    70     pub scheme: Scheme,

    71     pub script: String,

    72     pub theme: String,

    73     pub drawn_map: Option<String>,

    74 }

    75 

    76 impl RoomConfig {

    77     pub fn new() -> RoomConfig {

    78         RoomConfig {

    79             feature_size: 12,

    80             map_type: "+rnd+".to_string(),

    81             map_generator: 0,

    82             maze_size: 0,

    83             seed: "seed".to_string(),

    84             template: 0,

    85 

    86             ammo: Ammo {

    87                 name: "Default".to_string(),

    88                 settings: None,

    89             },

    90             scheme: Scheme {

    91                 name: "Default".to_string(),

    92                 settings: Vec::new(),

    93             },

    94             script: "Normal".to_string(),

    95             theme: "\u{1f994}".to_string(),

    96             drawn_map: None,

    97         }

    98     }

    99 

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

   101         match cfg {

   102             GameCfg::FeatureSize(s) => self.feature_size = s,

   103             GameCfg::MapType(t) => self.map_type = t,

   104             GameCfg::MapGenerator(g) => self.map_generator = g,

   105             GameCfg::MazeSize(s) => self.maze_size = s,

   106             GameCfg::Seed(s) => self.seed = s,

   107             GameCfg::Template(t) => self.template = t,

   108 

   109             GameCfg::Ammo(n, s) => {

   110                 self.ammo = Ammo {

   111                     name: n,

   112                     settings: s,

   113                 }

   114             }

   115             GameCfg::Scheme(n, s) => {

   116                 self.scheme = Scheme {

   117                     name: n,

   118                     settings: s,

   119                 }

   120             }

   121             GameCfg::Script(s) => self.script = s,

   122             GameCfg::Theme(t) => self.theme = t,

   123             GameCfg::DrawnMap(m) => self.drawn_map = Some(m),

   124         };

   125     }

   126 

   127     pub fn to_map_config(&self) -> Vec<String> {

   128         vec![

   129             self.feature_size.to_string(),

   130             self.map_type.to_string(),

   131             self.map_generator.to_string(),

   132             self.maze_size.to_string(),

   133             self.seed.to_string(),

   134             self.template.to_string(),

   135         ]

   136     }

   137 

   138     pub fn to_game_config(&self) -> Vec<GameCfg> {

   139         use GameCfg::*;

   140         let mut v = vec![

   141             Ammo(self.ammo.name.to_string(), self.ammo.settings.clone()),

   142             Scheme(self.scheme.name.to_string(), self.scheme.settings.clone()),

   143             Script(self.script.to_string()),

   144             Theme(self.theme.to_string()),

   145         ];

   146         if let Some(ref m) = self.drawn_map {

   147             v.push(DrawnMap(m.to_string()))

   148         }

   149         v

   150     }

   151 }

   152 

   153 #[derive(PartialEq, Eq, Clone, Debug)]

   154 pub enum VoteType {

   155     Kick(String),

   156     Map(Option<String>),

   157     Pause,

   158     NewSeed,

   159     HedgehogsPerTeam(u8),

   160 }

   161 

   162 pub struct Vote {

   163     pub is_pro: bool,

   164     pub is_forced: bool,

   165 }

   166 

   167 //#[cfg(test)]

   168 #[macro_use]

   169 pub mod testing {

   170     use crate::types::ServerVar::*;

   171     use crate::types::*;

   172     use proptest::{

   173         arbitrary::{any, Arbitrary},

   174         strategy::{BoxedStrategy, Just, Strategy},

   175     };

   176 

   177     // Due to inability to define From between Options

   178     pub trait Into2<T>: Sized {

   179         fn into2(self) -> T;

   180     }

   181     impl<T> Into2<T> for T {

   182         fn into2(self) -> T {

   183             self

   184         }

   185     }

   186     impl Into2<Vec<String>> for Vec<Ascii> {

   187         fn into2(self) -> Vec<String> {

   188             self.into_iter().map(|x| x.0).collect()

   189         }

   190     }

   191     impl Into2<String> for Ascii {

   192         fn into2(self) -> String {

   193             self.0

   194         }

   195     }

   196     impl Into2<Option<String>> for Option<Ascii> {

   197         fn into2(self) -> Option<String> {

   198             self.map(|x| x.0)

   199         }

   200     }

   201 

   202     #[macro_export]

   203     macro_rules! proto_msg_case {

   204         ($val: ident()) => {

   205             Just($val)

   206         };

   207         ($val: ident($arg: ty)) => {

   208             any::<$arg>().prop_map(|v| $val(v.into2()))

   209         };

   210         ($val: ident($arg1: ty, $arg2: ty)) => {

   211             any::<($arg1, $arg2)>().prop_map(|v| $val(v.0.into2(), v.1.into2()))

   212         };

   213         ($val: ident($arg1: ty, $arg2: ty, $arg3: ty)) => {

   214             any::<($arg1, $arg2, $arg3)>().prop_map(|v| $val(v.0.into2(), v.1.into2(), v.2.into2()))

   215         };

   216     }

   217 

   218     #[macro_export]

   219     macro_rules! proto_msg_match {

   220     ($var: expr, def = $default: expr, $($num: expr => $constr: ident $res: tt),*) => (

   221         match $var {

   222             $($num => (proto_msg_case!($constr $res)).boxed()),*,

   223             _ => Just($default).boxed()

   224         }

   225     )

   226 }

   227 

   228     /// Wrapper type for generating non-empty strings

   229     #[derive(Debug)]

   230     pub struct Ascii(String);

   231 

   232     impl Arbitrary for Ascii {

   233         type Parameters = <String as Arbitrary>::Parameters;

   234 

   235         fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {

   236             "[a-zA-Z0-9]+".prop_map(Ascii).boxed()

   237         }

   238 

   239         type Strategy = BoxedStrategy<Ascii>;

   240     }

   241 

   242     impl Arbitrary for GameCfg {

   243         type Parameters = ();

   244 

   245         fn arbitrary_with(_args: <Self as Arbitrary>::Parameters) -> <Self as Arbitrary>::Strategy {

   246             use crate::types::GameCfg::*;

   247             (0..10)

   248                 .no_shrink()

   249                 .prop_flat_map(|i| {

   250                     proto_msg_match!(i, def = FeatureSize(0),

   251             0 => FeatureSize(u32),

   252             1 => MapType(Ascii),

   253             2 => MapGenerator(u32),

   254             3 => MazeSize(u32),

   255             4 => Seed(Ascii),

   256             5 => Template(u32),

   257             6 => Ammo(Ascii, Option<Ascii>),

   258             7 => Scheme(Ascii, Vec<Ascii>),

   259             8 => Script(Ascii),

   260             9 => Theme(Ascii),

   261             10 => DrawnMap(Ascii))

   262                 })

   263                 .boxed()

   264         }

   265 

   266         type Strategy = BoxedStrategy<GameCfg>;

   267     }

   268 

   269     impl Arbitrary for TeamInfo {

   270         type Parameters = ();

   271 

   272         fn arbitrary_with(_args: <Self as Arbitrary>::Parameters) -> <Self as Arbitrary>::Strategy {

   273             (

   274                 "[a-z]+",

   275                 0u8..127u8,

   276                 "[a-z]+",

   277                 "[a-z]+",

   278                 "[a-z]+",

   279                 "[a-z]+",

   280                 0u8..127u8,

   281             )

   282                 .prop_map(|(name, color, grave, fort, voice_pack, flag, difficulty)| {

   283                     fn hog(n: u8) -> HedgehogInfo {

   284                         HedgehogInfo {

   285                             name: format!("hog{}", n),

   286                             hat: format!("hat{}", n),

   287                         }

   288                     }

   289                     let hedgehogs = [

   290                         hog(1),

   291                         hog(2),

   292                         hog(3),

   293                         hog(4),

   294                         hog(5),

   295                         hog(6),

   296                         hog(7),

   297                         hog(8),

   298                     ];

   299                     TeamInfo {

   300                         owner: String::new(),

   301                         name,

   302                         color,

   303                         grave,

   304                         fort,

   305                         voice_pack,

   306                         flag,

   307                         difficulty,

   308                         hedgehogs,

   309                         hedgehogs_number: 0,

   310                     }

   311                 })

   312                 .boxed()

   313         }

   314 

   315         type Strategy = BoxedStrategy<TeamInfo>;

   316     }

   317 

   318     impl Arbitrary for ServerVar {

   319         type Parameters = ();

   320 

   321         fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {

   322             (0..=2)

   323                 .no_shrink()

   324                 .prop_flat_map(|i| {

   325                     proto_msg_match!(i, def = ServerVar::LatestProto(0),

   326                         0 => MOTDNew(Ascii),

   327                         1 => MOTDOld(Ascii),

   328                         2 => LatestProto(u16)

   329                     )

   330                 })

   331                 .boxed()

   332         }

   333 

   334         type Strategy = BoxedStrategy<ServerVar>;

   335     }

   336 

   337     impl Arbitrary for VoteType {

   338         type Parameters = ();

   339 

   340         fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {

   341             use VoteType::*;

   342             (0..=4)

   343                 .no_shrink()

   344                 .prop_flat_map(|i| {

   345                     proto_msg_match!(i, def = VoteType::Pause,

   346                         0 => Kick(Ascii),

   347                         1 => Map(Option<Ascii>),

   348                         2 => Pause(),

   349                         3 => NewSeed(),

   350                         4 => HedgehogsPerTeam(u8)

   351                     )

   352                 })

   353                 .boxed()

   354         }

   355 

   356         type Strategy = BoxedStrategy<VoteType>;

   357     }

   358 }