gameServer2/src/server/handlers/inroom.rs
changeset 13478 d79795acaa73
parent 13477 f748a72432f2
child 13480 fb37745c5bca
equal deleted inserted replaced
13477:f748a72432f2 13478:d79795acaa73
     1 use mio;
     1 use mio;
     2 
     2 
     3 use protocol::messages::{
     3 use protocol::messages::{
     4     HWProtocolMessage,
     4     HWProtocolMessage,
     5     HWServerMessage::*
     5     HWServerMessage::*,
       
     6     server_chat
     6 };
     7 };
     7 use server::{
     8 use server::{
       
     9     coretypes::{ClientId, Voting, VoteType},
     8     server::HWServer,
    10     server::HWServer,
     9     client::ClientId,
       
    10     room::HWRoom,
    11     room::HWRoom,
    11     actions::{Action, Action::*}
    12     actions::{Action, Action::*}
    12 };
    13 };
    13 use utils::is_name_illegal;
    14 use utils::is_name_illegal;
    14 use std::mem::swap;
    15 use std::mem::swap;
   260             } else {
   261             } else {
   261                 Vec::new()
   262                 Vec::new()
   262             };
   263             };
   263             server.react(client_id, actions);
   264             server.react(client_id, actions);
   264         }
   265         }
       
   266         CallVote(None) => {
       
   267             server.react(client_id, vec![
       
   268                 server_chat("Available callvote commands: kick <nickname>, map <name>, pause, newseed, hedgehogs <number>")
       
   269                     .send_self().action()])
       
   270         }
       
   271         CallVote(Some(kind)) => {
       
   272             let (room_id, is_in_game) = server.room(client_id)
       
   273                 .map(|r| (r.id, r.game_info.is_some())).unwrap();
       
   274             let error = match &kind {
       
   275                 VoteType::Kick(nick) => {
       
   276                     if server.find_client(&nick).filter(|c| c.room_id == Some(room_id)).is_some() {
       
   277                         None
       
   278                     } else {
       
   279                         Some("/callvote kick: No such user!")
       
   280                     }
       
   281                 },
       
   282                 VoteType::Map(None) => {
       
   283                     Some("/callvote map: Not implemented")
       
   284                 },
       
   285                 VoteType::Map(Some(name)) => {
       
   286                     Some("/callvote map: Not implemented")
       
   287                 },
       
   288                 VoteType::Pause => {
       
   289                     if is_in_game {
       
   290                         None
       
   291                     } else {
       
   292                         Some("/callvote pause: No game in progress!")
       
   293                     }
       
   294                 },
       
   295                 VoteType::NewSeed => {
       
   296                     None
       
   297                 },
       
   298                 VoteType::HedgehogsPerTeam(number) => {
       
   299                     match number {
       
   300                         1...8 => None,
       
   301                         _ => Some("/callvote hedgehogs: Specify number from 1 to 8.")
       
   302                     }
       
   303                 },
       
   304             };
       
   305             match error {
       
   306                 None => {
       
   307                     let voting = Voting::new(kind, server.room_clients(client_id));
       
   308                     server.room(client_id).unwrap().voting = Some(voting);
       
   309                     server.react(client_id, vec![
       
   310                         server_chat("New voting started: ")
       
   311                             .send_all().in_room(room_id).action(),
       
   312                         AddVote{ vote: true, is_forced: false}]);
       
   313                 }
       
   314                 Some(msg) => {
       
   315                     server.react(client_id, vec![
       
   316                         server_chat(msg).send_self().action()])
       
   317                 }
       
   318             }
       
   319         }
       
   320         Vote(vote) => {
       
   321             let actions = if let (c, Some(r)) = server.client_and_room(client_id) {
       
   322                 vec![AddVote{ vote, is_forced: false }]
       
   323             } else {
       
   324                 Vec::new()
       
   325             };
       
   326             server.react(client_id, actions);
       
   327         }
       
   328         ForceVote(vote) => {
       
   329             let actions = if let (c, Some(r)) = server.client_and_room(client_id) {
       
   330                 vec![AddVote{ vote, is_forced: c.is_admin} ]
       
   331             } else {
       
   332                 Vec::new()
       
   333             };
       
   334             server.react(client_id, actions);
       
   335         }
   265         StartGame => {
   336         StartGame => {
   266             let actions = if let (_, Some(r)) = server.client_and_room(client_id) {
   337             let actions = if let (_, Some(r)) = server.client_and_room(client_id) {
   267                 vec![StartRoomGame(r.id)]
   338                 vec![StartRoomGame(r.id)]
   268             } else {
   339             } else {
   269                 Vec::new()
   340                 Vec::new()