gameServer2/src/server/actions.rs
changeset 13119 1e39b8749072
parent 12853 a9d105dc5c95
child 13416 cdf69667593b
equal deleted inserted replaced
13118:1ddb8aac5e30 13119:1e39b8749072
     1 use mio;
     1 use mio;
     2 use std::io::Write;
     2 use std::io::Write;
     3 use std::io;
     3 use std::io;
     4 
     4 
     5 use super::server::HWServer;
     5 use super::server::HWServer;
     6 use super::server::HWRoom;
     6 use super::room::HWRoom;
     7 use protocol::messages::HWProtocolMessage;
     7 use protocol::messages::HWProtocolMessage;
       
     8 use protocol::messages::HWServerMessage;
     8 use protocol::messages::HWServerMessage::*;
     9 use protocol::messages::HWServerMessage::*;
     9 use super::handlers;
    10 use super::handlers;
    10 
    11 
    11 pub enum Action {
    12 pub enum Action {
    12     SendMe(String),
    13     SendMe(HWServerMessage),
    13     SendAllButMe(String),
    14     SendAllButMe(HWServerMessage),
    14     RemoveClient,
    15     RemoveClient,
    15     ByeClient(String),
    16     ByeClient(String),
    16     ReactProtocolMessage(HWProtocolMessage),
    17     ReactProtocolMessage(HWProtocolMessage),
    17     CheckRegistered,
    18     CheckRegistered,
    18     JoinLobby,
    19     JoinLobby,
    20     Warn(String),
    21     Warn(String),
    21 }
    22 }
    22 
    23 
    23 use self::Action::*;
    24 use self::Action::*;
    24 
    25 
    25 pub fn run_action(server: &mut HWServer, token: usize, poll: &mio::Poll, action: Action) {
    26 pub fn run_action(server: &mut HWServer, token: usize, action: Action) {
    26     match action {
    27     match action {
    27         SendMe(msg) =>
    28         SendMe(msg) =>
    28             server.send(token, &msg),
    29             server.send_self(token, msg),
    29         SendAllButMe(msg) => {
    30         SendAllButMe(msg) => {
    30             for (_i, c) in server.clients.iter_mut() {
    31             server.send_others(token, msg)
    31                 if c.id != token {
       
    32                     c.send_string(&msg)
       
    33                 }
       
    34             }
       
    35         },
    32         },
    36         ByeClient(msg) => {
    33         ByeClient(msg) => {
    37             server.react(token, poll, vec![
    34             server.react(token, vec![
    38                 SendMe(Bye(&msg).to_raw_protocol()),
    35                 SendMe(Bye(msg)),
    39                 RemoveClient,
    36                 RemoveClient,
    40                 ]);
    37                 ]);
    41         },
    38         },
    42         RemoveClient => {
    39         RemoveClient => {
    43             server.clients[token].deregister(poll);
    40             server.removed_clients.push(token);
    44             server.clients.remove(token);
    41             if server.clients.contains(token) {
       
    42                 server.clients.remove(token);
       
    43             }
    45         },
    44         },
    46         ReactProtocolMessage(msg) =>
    45         ReactProtocolMessage(msg) =>
    47             handlers::handle(server, token, poll, msg),
    46             handlers::handle(server, token, msg),
    48         CheckRegistered =>
    47         CheckRegistered =>
    49             if server.clients[token].protocol_number > 0 && server.clients[token].nick != "" {
    48             if server.clients[token].protocol_number > 0 && server.clients[token].nick != "" {
    50                 server.react(token, poll, vec![
    49                 server.react(token, vec![
    51                     JoinLobby,
    50                     JoinLobby,
    52                     ]);
    51                     ]);
    53             },
    52             },
    54         JoinLobby => {
    53         JoinLobby => {
    55             server.clients[token].room_id = Some(server.lobby_id);
    54             server.clients[token].room_id = Some(server.lobby_id);
    56 
    55 
    57             let joined_msg;
    56             let joined_msg;
    58             {
    57             {
    59                 let mut lobby_nicks: Vec<&str> = Vec::new();
    58                 let mut lobby_nicks = Vec::new();
    60                 for (_, c) in server.clients.iter() {
    59                 for (_, c) in server.clients.iter() {
    61                     if c.room_id.is_some() {
    60                     if c.room_id.is_some() {
    62                         lobby_nicks.push(&c.nick);
    61                         lobby_nicks.push(c.nick.clone());
    63                     }
    62                     }
    64                 }
    63                 }
    65                 joined_msg = LobbyJoined(&lobby_nicks).to_raw_protocol();
    64                 joined_msg = LobbyJoined(lobby_nicks);
    66             }
    65             }
    67             let everyone_msg = LobbyJoined(&[&server.clients[token].nick]).to_raw_protocol();
    66             let everyone_msg = LobbyJoined(vec![server.clients[token].nick.clone()]);
    68             server.react(token, poll, vec![
    67             server.react(token, vec![
    69                 SendAllButMe(everyone_msg),
    68                 SendAllButMe(everyone_msg),
    70                 SendMe(joined_msg),
    69                 SendMe(joined_msg),
    71                 ]);
    70                 ]);
    72         },
    71         },
    73         AddRoom(name, password) => {
    72         AddRoom(name, password) => {
    74             let room_id = server.rooms.insert(HWRoom::new());
    73             let room_id = server.add_room();;
    75             {
    74             {
    76                 let r = &mut server.rooms[room_id];
    75                 let r = &mut server.rooms[room_id];
    77                 let c = &mut server.clients[token];
    76                 let c = &mut server.clients[token];
    78                 r.name = name;
    77                 r.name = name;
    79                 r.password = password;
    78                 r.password = password;
    80                 r.id = room_id.clone();
       
    81                 r.ready_players_number = 1;
    79                 r.ready_players_number = 1;
    82                 r.protocol_number = c.protocol_number;
    80                 r.protocol_number = c.protocol_number;
    83                 c.room_id = Some(room_id);
    81                 c.room_id = Some(room_id);
    84             }
    82             }
    85 
       
    86         },
    83         },
    87         Warn(msg) => {
    84         Warn(msg) => {
    88             run_action(server, token, poll, SendMe(Warning(&msg).to_raw_protocol()));
    85             run_action(server, token,SendMe(Warning(msg)));
    89         }
    86         }
    90         //_ => unimplemented!(),
    87         //_ => unimplemented!(),
    91     }
    88     }
    92 }
    89 }