rust/hedgewars-server/src/handlers/common.rs
changeset 16015 cd8392e52165
parent 15968 ce47259d5c86
child 16029 d9f1b239b6d7
equal deleted inserted replaced
16014:e42d1819b150 16015:cd8392e52165
     7     core::{
     7     core::{
     8         client::HwClient,
     8         client::HwClient,
     9         room::HwRoom,
     9         room::HwRoom,
    10         server::{
    10         server::{
    11             EndGameResult, HwRoomControl, HwServer, JoinRoomError, LeaveRoomResult, StartGameError,
    11             EndGameResult, HwRoomControl, HwServer, JoinRoomError, LeaveRoomResult, StartGameError,
    12             VoteError, VoteResult,
    12             VoteEffect, VoteError, VoteResult,
    13         },
    13         },
    14         types::{ClientId, RoomId},
    14         types::{ClientId, RoomId},
    15     },
    15     },
    16     utils::to_engine_msg,
    16     utils::to_engine_msg,
    17 };
    17 };
   508         }
   508         }
   509     }
   509     }
   510 }
   510 }
   511 
   511 
   512 pub fn handle_vote(
   512 pub fn handle_vote(
   513     mut room_control: HwRoomControl,
   513     room_control: HwRoomControl,
   514     result: Result<VoteResult, VoteError>,
   514     result: Result<VoteResult, VoteError>,
   515     response: &mut super::Response,
   515     response: &mut super::Response,
   516 ) {
   516 ) {
   517     todo!("voting result needs to be processed with raised privileges");
       
   518     let room_id = room_control.room().id;
   517     let room_id = room_control.room().id;
   519     super::common::get_vote_data(room_control.room().id, &result, response);
   518     get_vote_data(room_control.room().id, &result, response);
   520 
   519 
   521     if let Ok(VoteResult::Succeeded(kind)) = result {
   520     if let Ok(VoteResult::Succeeded(effect)) = result {
   522         match kind {
   521         match effect {
   523             VoteType::Kick(nick) => {
   522             VoteEffect::Kicked(kicked_id, leave_result) => {
   524                 if let Some(kicked_client) = room_control.server().find_client(&nick) {
   523                 response.add(Kicked.send(kicked_id));
   525                     let kicked_id = kicked_client.id;
   524                 get_room_leave_result(
   526                     if let Some(mut room_control) = room_control.change_client(kicked_id) {
   525                     room_control.server(),
   527                         response.add(Kicked.send(kicked_id));
   526                     room_control.room(),
   528                         let result = room_control.leave_room();
   527                     "kicked",
   529                         super::common::get_room_leave_result(
   528                     leave_result,
   530                             room_control.server(),
   529                     response,
   531                             room_control.room(),
   530                 );
   532                             "kicked",
   531             }
   533                             result,
   532             VoteEffect::Map(location) => {
   534                             response,
   533                 let msg = server_chat(location.to_string());
   535                         );
   534                 let room = room_control.room();
   536                     }
   535                 response.add(msg.send_all().in_room(room.id));
   537                 }
   536 
   538             }
   537                 let room_master = room.master_id.map(|id| room_control.server().client(id));
   539             VoteType::Map(None) => (),
   538 
   540             VoteType::Map(Some(name)) => {
   539                 get_room_update(None, room, room_master, response);
   541                 if let Some(location) = room_control.load_config(&name) {
   540 
   542                     let msg = server_chat(location.to_string());
   541                 let room_destination = Destination::ToAll {
   543                     let room = room_control.room();
   542                     group: DestinationGroup::Room(room.id),
   544                     response.add(msg.send_all().in_room(room.id));
   543                     skip_self: false,
   545 
   544                 };
   546                     let room_master = room.master_id.map(|id| room_control.server().client(id));
   545                 get_active_room_config(room, room_destination, response);
   547 
   546             }
   548                     super::common::get_room_update(None, room, room_master, response);
   547             VoteEffect::Pause => {
   549 
   548                 response.add(
   550                     let room_destination = Destination::ToAll {
   549                     server_chat("Pause toggled.".to_string())
   551                         group: DestinationGroup::Room(room.id),
   550                         .send_all()
   552                         skip_self: false,
   551                         .in_room(room_id),
   553                     };
   552                 );
   554                     super::common::get_active_room_config(room, room_destination, response);
   553                 response.add(
   555                 }
   554                     ForwardEngineMessage(vec![to_engine_msg(once(b'I'))])
   556             }
   555                         .send_all()
   557             VoteType::Pause => {
   556                         .in_room(room_id),
   558                 if room_control.toggle_pause() {
   557                 );
   559                     response.add(
   558             }
   560                         server_chat("Pause toggled.".to_string())
   559             VoteEffect::NewSeed(cfg) => {
   561                             .send_all()
       
   562                             .in_room(room_id),
       
   563                     );
       
   564                     response.add(
       
   565                         ForwardEngineMessage(vec![to_engine_msg(once(b'I'))])
       
   566                             .send_all()
       
   567                             .in_room(room_id),
       
   568                     );
       
   569                 }
       
   570             }
       
   571             VoteType::NewSeed => {
       
   572                 let seed = thread_rng().gen_range(0..1_000_000_000).to_string();
       
   573                 let cfg = GameCfg::Seed(seed);
       
   574                 response.add(cfg.to_server_msg().send_all().in_room(room_id));
   560                 response.add(cfg.to_server_msg().send_all().in_room(room_id));
   575                 room_control
   561             }
   576                     .set_config(cfg)
   562             VoteEffect::HedgehogsPerTeam(number, team_names) => {
   577                     .expect("Apparently, you cannot just set room config");
       
   578             }
       
   579             VoteType::HedgehogsPerTeam(number) => {
       
   580                 let nicks = room_control.set_hedgehogs_number(number);
       
   581                 response.extend(
   563                 response.extend(
   582                     nicks
   564                     team_names
   583                         .into_iter()
   565                         .into_iter()
   584                         .map(|n| HedgehogsNumber(n, number).send_all().in_room(room_id)),
   566                         .map(|n| HedgehogsNumber(n, number).send_all().in_room(room_id)),
   585                 );
   567                 );
   586             }
   568             }
   587         }
   569         }