1 use mio;

     2 use std::io::Write;

     3 use std::io;

     4 

     5 use super::server::HWServer;

     6 use super::room::HWRoom;

     7 use protocol::messages::HWProtocolMessage;

     8 use protocol::messages::HWServerMessage;

     9 use protocol::messages::HWServerMessage::*;

    10 use super::handlers;

    11 

    12 pub enum Action {

    13     SendMe(HWServerMessage),

    14     SendAllButMe(HWServerMessage),

    15     RemoveClient,

    16     ByeClient(String),

    17     ReactProtocolMessage(HWProtocolMessage),

    18     CheckRegistered,

    19     JoinLobby,

    20     AddRoom(String, Option<String>),

    21     Warn(String),

    22 }

    23 

    24 use self::Action::*;

    25 

    26 pub fn run_action(server: &mut HWServer, token: usize, action: Action) {

    27     match action {

    28         SendMe(msg) =>

    29             server.send_self(token, msg),

    30         SendAllButMe(msg) => {

    31             server.send_others(token, msg)

    32         },

    33         ByeClient(msg) => {

    34             server.react(token, vec![

    35                 SendMe(Bye(msg)),

    36                 RemoveClient,

    37                 ]);

    38         },

    39         RemoveClient => {

    40             server.removed_clients.push(token);

    41             if server.clients.contains(token) {

    42                 server.clients.remove(token);

    43             }

    44         },

    45         ReactProtocolMessage(msg) =>

    46             handlers::handle(server, token, msg),

    47         CheckRegistered =>

    48             if server.clients[token].protocol_number > 0 && server.clients[token].nick != "" {

    49                 server.react(token, vec![

    50                     JoinLobby,

    51                     ]);

    52             },

    53         JoinLobby => {

    54             server.clients[token].room_id = Some(server.lobby_id);

    55 

    56             let joined_msg;

    57             {

    58                 let mut lobby_nicks = Vec::new();

    59                 for (_, c) in server.clients.iter() {

    60                     if c.room_id.is_some() {

    61                         lobby_nicks.push(c.nick.clone());

    62                     }

    63                 }

    64                 joined_msg = LobbyJoined(lobby_nicks);

    65             }

    66             let everyone_msg = LobbyJoined(vec![server.clients[token].nick.clone()]);

    67             server.react(token, vec![

    68                 SendAllButMe(everyone_msg),

    69                 SendMe(joined_msg),

    70                 ]);

    71         },

    72         AddRoom(name, password) => {

    73             let room_id = server.add_room();;

    74             {

    75                 let r = &mut server.rooms[room_id];

    76                 let c = &mut server.clients[token];

    77                 r.name = name;

    78                 r.password = password;

    79                 r.ready_players_number = 1;

    80                 r.protocol_number = c.protocol_number;

    81                 c.room_id = Some(room_id);

    82             }

    83         },

    84         Warn(msg) => {

    85             run_action(server, token,SendMe(Warning(msg)));

    86         }

    87         //_ => unimplemented!(),

    88     }

    89 }