gameServer2/src/main.rs
changeset 12126 4348997e502b
parent 12125 858bf4d04c54
child 12127 36ac9c075d0d
equal deleted inserted replaced
12125:858bf4d04c54 12126:4348997e502b
     1 extern crate rand;
     1 extern crate rand;
     2 extern crate mio;
     2 extern crate mio;
       
     3 extern crate slab;
     3 
     4 
     4 use std::io::*;
     5 //use std::io::*;
     5 //use rand::Rng;
     6 //use rand::Rng;
     6 //use std::cmp::Ordering;
     7 //use std::cmp::Ordering;
     7 use mio::tcp::*;
     8 use mio::tcp::*;
     8 use mio::*;
     9 use mio::*;
     9 
    10 
    10 mod utils;
    11 mod utils;
    11 
    12 mod server;
    12 const SERVER: mio::Token = mio::Token(0);
       
    13 
       
    14 
       
    15 
    13 
    16 fn main() {
    14 fn main() {
    17     println!("Hedgewars game server, protocol {}", utils::PROTOCOL_VERSION);
    15     println!("Hedgewars game server, protocol {}", utils::PROTOCOL_VERSION);
    18 
    16 
    19     let address = "0.0.0.0:46631".parse().unwrap();
    17     let address = "0.0.0.0:46631".parse().unwrap();
    20     let server = TcpListener::bind(&address).unwrap();
    18     let listener = TcpListener::bind(&address).unwrap();
       
    19     let mut server = server::HWServer::new(listener, 1024, 512);
    21 
    20 
    22     let poll = Poll::new().unwrap();
    21     let poll = Poll::new().unwrap();
    23     poll.register(&server, SERVER, Ready::readable(),
    22     server.register(&poll).unwrap();
    24                PollOpt::edge()).unwrap();
       
    25 
    23 
    26     let mut events = Events::with_capacity(1024);
    24     let mut events = Events::with_capacity(1024);
    27 
    25 
    28     loop {
    26     loop {
    29         poll.poll(&mut events, None).unwrap();
    27         poll.poll(&mut events, None).unwrap();
    30 
    28 
    31         for event in events.iter() {
    29         for event in events.iter() {
    32             match event.token() {
    30             match event.token() {
    33                 SERVER => match server.accept() {
    31                 utils::SERVER => server.accept(&poll).unwrap(),
    34                     Ok((mut client_stream, addr)) => {
       
    35                         println!("Connected: {}", addr);
       
    36                         client_stream.write_all(
       
    37                             format!("CONNECTED\nHedgewars server http://www.hedgewars.org/\n{}\n\n"
       
    38                                     , utils::PROTOCOL_VERSION).as_bytes()
       
    39                         );
       
    40                     },
       
    41                     _ => unreachable!()
       
    42                 },
       
    43 
       
    44                 _ => unreachable!(),
    32                 _ => unreachable!(),
    45             }
    33             }
    46         }
    34         }
    47     }
    35     }
    48 }
    36 }