hedgewars: comparison rust/hedgewars-server/src/core/server.rs

equal deleted inserted replaced

-:e42d1819b150
+:cd8392e52165
 use crate::server::replaystorage::ReplayStorage;
 use bitflags::*;
 use log::*;
+use rand::{self, seq::SliceRandom, thread_rng, Rng};
 use slab::Slab;
 use std::{borrow::BorrowMut, cmp::min, collections::HashSet, iter, mem::replace};
 #[derive(Debug)]
 pub enum CreateRoomError {
 pub enum StartVoteError {
 VotingInProgress,
 }
 #[derive(Debug)]
+pub enum VoteEffect {
+Kicked(ClientId, LeaveRoomResult),
+Map(String),
+Pause,
+NewSeed(GameCfg),
+HedgehogsPerTeam(u8, Vec<String>),
+}
+#[derive(Debug)]
 pub enum VoteResult {
 Submitted,
-Succeeded(VoteType),
+Succeeded(VoteEffect),
 Failed,
 }
 #[derive(Debug)]
 pub enum VoteError {
 pub fn change_client<'b: 'a>(self, client_id: ClientId) -> Option<HwRoomControl<'a>> {
 let room_id = self.room_id;
 HwRoomControl::new(self.server, client_id).filter(|c| c.room_id == room_id)
 }
-pub fn leave_room(&mut self) -> LeaveRoomResult {
+fn remove_from_room(&mut self, client_id: ClientId) -> LeaveRoomResult {
-let (client, room) = self.get_mut();
+let Some((client, room)) = self.server.client_and_room_mut(client_id);
 room.players_number -= 1;
 client.room_id = None;
 let is_empty = room.players_number == 0;
 let is_fixed = room.is_fixed();
 removed_teams,
 }
 }
 }
+pub fn leave_room(&mut self) -> LeaveRoomResult {
+self.remove_from_room(self.client_id)
+}
 pub fn change_master(
 &mut self,
 new_master_nick: String,
 ) -> Result<ChangeMasterResult, ChangeMasterError> {
 use ChangeMasterError::*;
 Ok(())
 }
 }
 }
+fn apply_vote(&mut self, kind: VoteType) -> Option<VoteEffect> {
+match kind {
+VoteType::Kick(nick) => {
+if let Some(kicked_id) = self
+.server
+.find_client(&nick)
+.filter(|c| c.room_id == Some(self.room_id))
+.map(|c| c.id)
+{
+let leave_result = self.remove_from_room(kicked_id);
+Some(VoteEffect::Kicked(kicked_id, leave_result))
+} else {
+None
+}
+}
+VoteType::Map(None) => None,
+VoteType::Map(Some(name)) => self
+.load_config(&name)
+.map(|s| VoteEffect::Map(s.to_string())),
+VoteType::Pause => Some(VoteEffect::Pause).filter(|_| self.toggle_pause()),
+VoteType::NewSeed => {
+let seed = thread_rng().gen_range(0..1_000_000_000).to_string();
+let cfg = GameCfg::Seed(seed);
+todo!("Protocol backwards compatibility");
+self.room_mut().set_config(cfg.clone());
+Some(VoteEffect::NewSeed(cfg))
+}
+VoteType::HedgehogsPerTeam(number) => {
+let nicks = self.set_hedgehogs_number(number);
+Some(VoteEffect::HedgehogsPerTeam(number, nicks))
+}
+}
+}
 pub fn vote(&mut self, vote: Vote) -> Result<VoteResult, VoteError> {
 use self::{VoteError::*, VoteResult::*};
 let client_id = self.client_id;
 if let Some(ref mut voting) = self.room_mut().voting {
 if vote.is_forced || voting.votes.iter().all(|(id, _)| client_id != *id) {
 voting.votes.push((client_id, vote.is_pro));
 let i = voting.votes.iter();
 let pro = i.clone().filter(|(_, v)| *v).count();
 let contra = i.filter(|(_, v)| !*v).count();
 let success_quota = voting.voters.len() / 2 + 1;
 if vote.is_forced && vote.is_pro || pro >= success_quota {
 let voting = self.room_mut().voting.take().unwrap();
-Ok(Succeeded(voting.kind))
+if let Some(effect) = self.apply_vote(voting.kind) {
+Ok(Succeeded(effect))
+} else {
+Ok(Failed)
+}
 } else if vote.is_forced && !vote.is_pro
 || contra > voting.voters.len() - success_quota
 {
 Ok(Failed)
 } else {
 }
 GameCfg::Scheme(name, values)
 }
 cfg => cfg,
 };
 room.set_config(cfg);
 Ok(())
 }
 }

changeset 15986	cd8392e52165
parent 15938	ce47259d5c86
child 15988	0b2e0a7d0431