hedgewars: comparison rust/hedgewars-server/src/handlers/common.rs

equal deleted inserted replaced

-:c5a6e8566425
+:e935b1ad23f3
 use crate::{
+core::{
+client::HwClient,
+room::HwRoom,
+server::HwServer,
+types::{ClientId, GameCfg, RoomId, TeamInfo, Vote, VoteType},
+},
 protocol::messages::{
-server_chat,
+add_flags, remove_flags, server_chat,
-add_flags, remove_flags,
+HwProtocolMessage::{self, Rnd},
-HWProtocolMessage::{self, Rnd},
+HwServerMessage::{self, *},
-HWServerMessage::{self, *},
 ProtocolFlags as Flags,
-},
-core::{
-client::HWClient,
-server::HWServer,
-types::{ClientId, GameCfg, RoomId, TeamInfo, Vote, VoteType},
-room::HWRoom,
 },
 utils::to_engine_msg,
 };
 use super::Response;
 use crate::core::types::RoomConfig;
 use rand::{self, seq::SliceRandom, thread_rng, Rng};
 use std::{iter::once, mem::replace};
-pub fn rnd_reply(options: &[String]) -> HWServerMessage {
+pub fn rnd_reply(options: &[String]) -> HwServerMessage {
 let mut rng = thread_rng();
 let reply = if options.is_empty() {
 (*&["heads", "tails"].choose(&mut rng).unwrap()).to_string()
 } else {
 nick: "[random]".to_string(),
 msg: reply,
 }
 }
-pub fn join_lobby(server: &mut HWServer, response: &mut Response) {
+pub fn join_lobby(server: &mut HwServer, response: &mut Response) {
 let client_id = response.client_id();
 let client = &server.clients[client_id];
 let nick = vec![client.nick.clone()];
 let mut flags = vec![];
 response.add(server_msg.send_self());
 response.add(rooms_msg.send_self());
 }
 pub fn remove_teams(
-room: &mut HWRoom,
+room: &mut HwRoom,
 team_names: Vec<String>,
 is_in_game: bool,
 response: &mut Response,
 ) {
 if let Some(ref mut info) = room.game_info {
 response.add(TeamRemove(team_name).send_all().in_room(room.id));
 }
 }
 fn remove_client_from_room(
-client: &mut HWClient,
+client: &mut HwClient,
-room: &mut HWRoom,
+room: &mut HwRoom,
 response: &mut Response,
 msg: &str,
 ) {
 room.players_number -= 1;
 if room.players_number > 0 || room.is_fixed() {
 response.add(ClientFlags(remove_flags(&[Flags::InRoom]), vec![client.nick.clone()]).send_all());
 }
 pub fn change_master(
-server: &mut HWServer,
+server: &mut HwServer,
 room_id: RoomId,
 new_master_id: ClientId,
 response: &mut Response,
 ) {
 let room = &mut server.rooms[room_id];
 .in_room(room_id),
 );
 }
 pub fn enter_room(
-server: &mut HWServer,
+server: &mut HwServer,
 client_id: ClientId,
 room_id: RoomId,
 response: &mut Response,
 ) {
 let nick = server.clients[client_id].nick.clone();
 .send_self(),
 );
 }
 }
-pub fn exit_room(server: &mut HWServer, client_id: ClientId, response: &mut Response, msg: &str) {
+pub fn exit_room(server: &mut HwServer, client_id: ClientId, response: &mut Response, msg: &str) {
 let client = &mut server.clients[client_id];
 if let Some(room_id) = client.room_id {
 let room = &mut server.rooms[room_id];
 }
 }
 }
 }
-pub fn remove_client(server: &mut HWServer, response: &mut Response, msg: String) {
+pub fn remove_client(server: &mut HwServer, response: &mut Response, msg: String) {
 let client_id = response.client_id();
 let client = &mut server.clients[client_id];
 let nick = client.nick.clone();
 exit_room(server, client_id, response, &msg);
 response.remove_client(client_id);
 }
 pub fn get_room_update(
 room_name: Option<String>,
-room: &HWRoom,
+room: &HwRoom,
-master: Option<&HWClient>,
+master: Option<&HwClient>,
 response: &mut Response,
 ) {
 let update_msg = RoomUpdated(room_name.unwrap_or(room.name.clone()), room.info(master));
 response.add(update_msg.send_all().with_protocol(room.protocol_number));
 }
 for cfg in config.to_game_config() {
 response.add(cfg.to_server_msg().send(to_client));
 }
 }
-pub fn get_room_config(room: &HWRoom, to_client: ClientId, response: &mut Response) {
+pub fn get_room_config(room: &HwRoom, to_client: ClientId, response: &mut Response) {
 get_room_config_impl(room.active_config(), to_client, response);
 }
 pub fn get_teams<'a, I>(teams: I, to_client: ClientId, response: &mut Response)
 where
 response.add(HedgehogsNumber(team.name.clone(), team.hedgehogs_number).send(to_client));
 }
 }
 pub fn get_room_teams(
-server: &HWServer,
+server: &HwServer,
 room_id: RoomId,
 to_client: ClientId,
 response: &mut Response,
 ) {
 let room = &server.rooms[room_id];
 get_teams(current_teams.iter().map(|(_, t)| t), to_client, response);
 }
 pub fn get_room_flags(
-server: &HWServer,
+server: &HwServer,
 room_id: RoomId,
 to_client: ClientId,
 response: &mut Response,
 ) {
 let room = &server.rooms[room_id];
 response.add(ClientFlags(add_flags(&[Flags::Ready]), nicks).send(to_client));
 }
 }
 pub fn apply_voting_result(
-server: &mut HWServer,
+server: &mut HwServer,
 room_id: RoomId,
 response: &mut Response,
 kind: VoteType,
 ) {
 match kind {
 );
 }
 }
 }
-fn add_vote(room: &mut HWRoom, response: &mut Response, vote: Vote) -> Option<bool> {
+fn add_vote(room: &mut HwRoom, response: &mut Response, vote: Vote) -> Option<bool> {
 let client_id = response.client_id;
 let mut result = None;
 if let Some(ref mut voting) = room.voting {
 if vote.is_forced || voting.votes.iter().all(|(id, _)| client_id != *id) {
 }
 result
 }
-pub fn submit_vote(server: &mut HWServer, vote: Vote, response: &mut Response) {
+pub fn submit_vote(server: &mut HwServer, vote: Vote, response: &mut Response) {
 let client_id = response.client_id;
 let client = &server.clients[client_id];
 if let Some(room_id) = client.room_id {
 let room = &mut server.rooms[room_id];
 }
 }
 }
 }
-pub fn start_game(server: &mut HWServer, room_id: RoomId, response: &mut Response) {
+pub fn start_game(server: &mut HwServer, room_id: RoomId, response: &mut Response) {
 let (room_clients, room_nicks): (Vec<_>, Vec<_>) = server
 .clients
 .iter()
 .map(|(id, c)| (id, c.nick.clone()))
 .unzip();
 };
 get_room_update(None, room, room_master, response);
 }
 }
-pub fn end_game(server: &mut HWServer, room_id: RoomId, response: &mut Response) {
+pub fn end_game(server: &mut HwServer, room_id: RoomId, response: &mut Response) {
 let room = &mut server.rooms[room_id];
 room.ready_players_number = 1;
 let room_master = if let Some(id) = room.master_id {
 Some(&server.clients[id])
 } else {
 }
 #[cfg(test)]
 mod tests {
 use super::*;
-use crate::protocol::messages::HWServerMessage::ChatMsg;
+use crate::protocol::messages::HwServerMessage::ChatMsg;
 use crate::server::actions::PendingMessage;
-fn reply2string(r: HWServerMessage) -> String {
+fn reply2string(r: HwServerMessage) -> String {
 match r {
 ChatMsg { msg: p, .. } => String::from(p),
 _ => panic!("expected a ChatMsg"),
 }
 }

changeset 15075	e935b1ad23f3
parent 15074	c5a6e8566425
child 15111	1e45db229f9f