gameServer2/src/server/network.rs
changeset 13416 cdf69667593b
parent 13415 0eedc17055a0
child 13419 81e0ed105f5d
equal deleted inserted replaced
13415:0eedc17055a0 13416:cdf69667593b
    53     pub fn read_messages(&mut self) -> NetworkResult<Vec<HWProtocolMessage>> {
    53     pub fn read_messages(&mut self) -> NetworkResult<Vec<HWProtocolMessage>> {
    54         let mut bytes_read = 0;
    54         let mut bytes_read = 0;
    55         let result = loop {
    55         let result = loop {
    56             match self.decoder.read_from(&mut self.socket) {
    56             match self.decoder.read_from(&mut self.socket) {
    57                 Ok(bytes) => {
    57                 Ok(bytes) => {
    58                     debug!("Read {} bytes", bytes);
    58                     debug!("Client {}: read {} bytes", self.id, bytes);
    59                     bytes_read += bytes;
    59                     bytes_read += bytes;
    60                     if bytes == 0 {
    60                     if bytes == 0 {
    61                         let result = if bytes_read == 0 {
    61                         let result = if bytes_read == 0 {
    62                             info!("EOF for client {} ({})", self.id, self.peer_addr);
    62                             info!("EOF for client {} ({})", self.id, self.peer_addr);
    63                             (Vec::new(), NetworkClientState::Closed)
    63                             (Vec::new(), NetworkClientState::Closed)
   165     }
   165     }
   166 
   166 
   167     fn flush_server_messages(&mut self) {
   167     fn flush_server_messages(&mut self) {
   168         debug!("{} pending server messages", self.server.output.len());
   168         debug!("{} pending server messages", self.server.output.len());
   169         for PendingMessage(destination, msg) in self.server.output.drain(..) {
   169         for PendingMessage(destination, msg) in self.server.output.drain(..) {
       
   170             debug!("Message {:?} to {:?}", msg, destination);
   170             match destination {
   171             match destination {
       
   172                 Destination::ToAll => {
       
   173                     let msg_string = msg.to_raw_protocol();
       
   174                     for (client_id, client) in self.clients.iter_mut() {
       
   175                         client.send_string(&msg_string);
       
   176                         self.pending.insert((client_id, NetworkClientState::NeedsWrite));
       
   177                     }
       
   178                 },
   171                 Destination::ToSelf(id)  => {
   179                 Destination::ToSelf(id)  => {
   172                     if let Some(ref mut client) = self.clients.get_mut(id) {
   180                     if let Some(client) = self.clients.get_mut(id) {
   173                         client.send_msg(msg);
   181                         client.send_msg(msg);
   174                         self.pending.insert((id, NetworkClientState::NeedsWrite));
   182                         self.pending.insert((id, NetworkClientState::NeedsWrite));
   175                     }
   183                     }
   176                 }
   184                 }
   177                 Destination::ToOthers(id) => {
   185                 Destination::ToOthers(id) => {
   178                     let msg_string = msg.to_raw_protocol();
   186                     let msg_string = msg.to_raw_protocol();
   179                     for (client_id, client) in self.clients.iter_mut() {
   187                     for (client_id, client) in self.clients.iter_mut() {
   180                         if client_id != id {
   188                         if client_id != id {
   181                             client.send_string(&msg_string);
   189                             client.send_string(&msg_string);
   182                             self.pending.insert((client_id, NetworkClientState::NeedsWrite));
   190                             self.pending.insert((client_id, NetworkClientState::NeedsWrite));
       
   191                         }
       
   192                     }
       
   193                 },
       
   194                 Destination::ToSelected(client_ids) => {
       
   195                     let msg_string = msg.to_raw_protocol();
       
   196                     for id in client_ids {
       
   197                         if let Some(client) = self.clients.get_mut(id) {
       
   198                             client.send_string(&msg_string);
       
   199                             self.pending.insert((id, NetworkClientState::NeedsWrite));
   183                         }
   200                         }
   184                     }
   201                     }
   185                 }
   202                 }
   186             }
   203             }
   187         }
   204         }