gameServer2/src/main.rs
changeset 14420 06672690d71b
parent 14419 6843c4551cde
child 14421 96624a6cdb93
equal deleted inserted replaced
14419:6843c4551cde 14420:06672690d71b
     1 #![allow(unused_imports)]
       
     2 #![deny(bare_trait_objects)]
       
     3 
       
     4 //use std::io::*;
       
     5 //use rand::Rng;
       
     6 //use std::cmp::Ordering;
       
     7 use mio::net::*;
       
     8 use mio::*;
       
     9 use log::*;
       
    10 
       
    11 mod utils;
       
    12 mod server;
       
    13 mod protocol;
       
    14 
       
    15 use crate::server::network::NetworkLayer;
       
    16 use std::time::Duration;
       
    17 
       
    18 fn main() {
       
    19     env_logger::init();
       
    20 
       
    21     info!("Hedgewars game server, protocol {}", utils::PROTOCOL_VERSION);
       
    22 
       
    23     let address = "0.0.0.0:46631".parse().unwrap();
       
    24     let listener = TcpListener::bind(&address).unwrap();
       
    25 
       
    26     let poll = Poll::new().unwrap();
       
    27     let mut hw_network = NetworkLayer::new(listener, 1024, 512);
       
    28     hw_network.register_server(&poll).unwrap();
       
    29 
       
    30     let mut events = Events::with_capacity(1024);
       
    31 
       
    32     loop {
       
    33         let timeout = if hw_network.has_pending_operations() {
       
    34             Some(Duration::from_millis(1))
       
    35         } else {
       
    36             None
       
    37         };
       
    38         poll.poll(&mut events, timeout).unwrap();
       
    39 
       
    40         for event in events.iter() {
       
    41             if event.readiness() & Ready::readable() == Ready::readable() {
       
    42                 match event.token() {
       
    43                     utils::SERVER => hw_network.accept_client(&poll).unwrap(),
       
    44                     Token(tok) => hw_network.client_readable(&poll, tok).unwrap(),
       
    45                 }
       
    46             }
       
    47             if event.readiness() & Ready::writable() == Ready::writable() {
       
    48                 match event.token() {
       
    49                     utils::SERVER => unreachable!(),
       
    50                     Token(tok) => hw_network.client_writable(&poll, tok).unwrap(),
       
    51                 }
       
    52             }
       
    53 //            if event.kind().is_hup() || event.kind().is_error() {
       
    54 //                match event.token() {
       
    55 //                    utils::SERVER => unreachable!(),
       
    56 //                    Token(tok) => server.client_error(&poll, tok).unwrap(),
       
    57 //                }
       
    58 //            }
       
    59         }
       
    60         hw_network.on_idle(&poll).unwrap();
       
    61     }
       
    62 }