1 use super::types::ClientId;

     2 use bitflags::*;

     3 

     4 bitflags! {

     5     pub struct ClientFlags: u16 {

     6         const IS_ADMIN = 0b0000_0001;

     7         const IS_MASTER = 0b0000_0010;

     8         const IS_READY = 0b0000_0100;

     9         const IS_IN_GAME = 0b0000_1000;

    10         const IS_JOINED_MID_GAME = 0b0001_0000;

    11         const IS_CHECKER = 0b0010_0000;

    12         const IS_CONTRIBUTOR = 0b0100_0000;

    13         const HAS_SUPER_POWER = 0b1000_0000;

    14         const IS_REGISTERED = 0b0001_0000_0000;

    15 

    16         const NONE = 0b0000_0000;

    17         const DEFAULT = Self::NONE.bits;

    18     }

    19 }

    20 

    21 pub struct HWClient {

    22     pub id: ClientId,

    23     pub room_id: Option<usize>,

    24     pub nick: String,

    25     pub protocol_number: u16,

    26     pub flags: ClientFlags,

    27     pub teams_in_game: u8,

    28     pub team_indices: Vec<u8>,

    29     pub clan: Option<u8>,

    30 }

    31 

    32 impl HWClient {

    33     pub fn new(id: ClientId, protocol_number: u16, nick: String) -> HWClient {

    34         HWClient {

    35             id,

    36             nick,

    37             protocol_number,

    38             room_id: None,

    39             flags: ClientFlags::DEFAULT,

    40             teams_in_game: 0,

    41             team_indices: Vec::new(),

    42             clan: None,

    43         }

    44     }

    45 

    46     fn contains(&self, mask: ClientFlags) -> bool {

    47         self.flags.contains(mask)

    48     }

    49 

    50     fn set(&mut self, mask: ClientFlags, value: bool) {

    51         self.flags.set(mask, value);

    52     }

    53 

    54     pub fn is_admin(&self) -> bool {

    55         self.contains(ClientFlags::IS_ADMIN)

    56     }

    57     pub fn is_master(&self) -> bool {

    58         self.contains(ClientFlags::IS_MASTER)

    59     }

    60     pub fn is_ready(&self) -> bool {

    61         self.contains(ClientFlags::IS_READY)

    62     }

    63     pub fn is_in_game(&self) -> bool {

    64         self.contains(ClientFlags::IS_IN_GAME)

    65     }

    66     pub fn is_joined_mid_game(&self) -> bool {

    67         self.contains(ClientFlags::IS_JOINED_MID_GAME)

    68     }

    69     pub fn is_checker(&self) -> bool {

    70         self.contains(ClientFlags::IS_CHECKER)

    71     }

    72     pub fn is_contributor(&self) -> bool {

    73         self.contains(ClientFlags::IS_CONTRIBUTOR)

    74     }

    75     pub fn has_super_power(&self) -> bool {

    76         self.contains(ClientFlags::HAS_SUPER_POWER)

    77     }

    78     pub fn is_registered(&self) -> bool {

    79         self.contains(ClientFlags::IS_REGISTERED)

    80     }

    81 

    82     pub fn set_is_admin(&mut self, value: bool) {

    83         self.set(ClientFlags::IS_ADMIN, value)

    84     }

    85     pub fn set_is_master(&mut self, value: bool) {

    86         self.set(ClientFlags::IS_MASTER, value)

    87     }

    88     pub fn set_is_ready(&mut self, value: bool) {

    89         self.set(ClientFlags::IS_READY, value)

    90     }

    91     pub fn set_is_in_game(&mut self, value: bool) {

    92         self.set(ClientFlags::IS_IN_GAME, value)

    93     }

    94     pub fn set_is_joined_mid_game(&mut self, value: bool) {

    95         self.set(ClientFlags::IS_JOINED_MID_GAME, value)

    96     }

    97     pub fn set_is_checker(&mut self, value: bool) {

    98         self.set(ClientFlags::IS_CHECKER, value)

    99     }

   100     pub fn set_is_contributor(&mut self, value: bool) {

   101         self.set(ClientFlags::IS_CONTRIBUTOR, value)

   102     }

   103     pub fn set_has_super_power(&mut self, value: bool) {

   104         self.set(ClientFlags::HAS_SUPER_POWER, value)

   105     }

   106     pub fn set_is_registered(&mut self, value: bool) {

   107         self.set(ClientFlags::IS_REGISTERED, value)

   108     }

   109 }