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

equal deleted inserted replaced

-:c5a6e8566425
+:e935b1ad23f3
 use mio;
 use std::{collections::HashMap, io, io::Write};
 use self::{
 actions::{Destination, DestinationGroup, PendingMessage},
-inanteroom::LoginResult
+inanteroom::LoginResult,
 };
 use crate::{
 core::{
-server::HWServer,
+room::RoomSave,
-types::{ClientId, Replay, RoomId, GameCfg, TeamInfo},
+server::HwServer,
-room::RoomSave
+types::{ClientId, GameCfg, Replay, RoomId, TeamInfo},
 },
 protocol::messages::{
-server_chat,
+global_chat, server_chat, HwProtocolMessage, HwProtocolMessage::EngineMessage,
-HWProtocolMessage,
+HwServerMessage, HwServerMessage::*,
-HWServerMessage,
-HWServerMessage::*,
-global_chat,
-HWProtocolMessage::EngineMessage
 },
 utils,
 };
 use base64::encode;
 use log::*;
 use rand::{thread_rng, RngCore};
 mod actions;
 mod checker;
 mod common;
+mod inanteroom;
+mod inlobby;
 mod inroom;
-mod inlobby;
-mod inanteroom;
 use std::fmt::{Formatter, LowerHex};
 #[derive(PartialEq)]
 pub struct Sha1Digest([u8; 20]);
 self.io_tasks.push(task)
 }
 pub fn extract_messages<'a, 'b: 'a>(
 &'b mut self,
-server: &'a HWServer,
+server: &'a HwServer,
-) -> impl Iterator<Item = (Vec<ClientId>, HWServerMessage)> + 'a {
+) -> impl Iterator<Item = (Vec<ClientId>, HwServerMessage)> + 'a {
 let client_id = self.client_id;
 self.messages.drain(..).map(move |m| {
 let ids = get_recipients(server, client_id, m.destination);
 (ids, m.message)
 })
 }
 }
 }
 fn get_recipients(
-server: &HWServer,
+server: &HwServer,
 client_id: ClientId,
 destination: Destination,
 ) -> Vec<ClientId> {
 match destination {
 Destination::ToSelf => vec![client_id],
 }
 }
 }
 pub fn handle(
-server: &mut HWServer,
+server: &mut HwServer,
 client_id: ClientId,
 response: &mut Response,
-message: HWProtocolMessage,
+message: HwProtocolMessage,
 ) {
 match message {
-HWProtocolMessage::Ping => response.add(Pong.send_self()),
+HwProtocolMessage::Ping => response.add(Pong.send_self()),
 _ => {
 if server.anteroom.clients.contains(client_id) {
 match inanteroom::handle(server, client_id, response, message) {
 LoginResult::Unchanged => (),
 LoginResult::Complete => {
 response.remove_client(client_id);
 }
 }
 } else if server.clients.contains(client_id) {
 match message {
-HWProtocolMessage::Quit(Some(msg)) => {
+HwProtocolMessage::Quit(Some(msg)) => {
 common::remove_client(server, response, "User quit: ".to_string() + &msg);
 }
-HWProtocolMessage::Quit(None) => {
+HwProtocolMessage::Quit(None) => {
 common::remove_client(server, response, "User quit".to_string());
 }
-HWProtocolMessage::Info(nick) => {
+HwProtocolMessage::Info(nick) => {
 if let Some(client) = server.find_client(&nick) {
 let admin_sign = if client.is_admin() { "@" } else { "" };
 let master_sign = if client.is_master() { "+" } else { "" };
 let room_info = match client.room_id {
 Some(room_id) => {
 } else {
 response
 .add(server_chat("Player is not online.".to_string()).send_self())
 }
 }
-HWProtocolMessage::ToggleServerRegisteredOnly => {
+HwProtocolMessage::ToggleServerRegisteredOnly => {
 if !server.clients[client_id].is_admin() {
 response.add(Warning("Access denied.".to_string()).send_self());
 } else {
 server.set_is_registered_only(server.is_registered_only());
 let msg = if server.is_registered_only() {
 "This server now allows unregistered players to join."
 };
 response.add(server_chat(msg.to_string()).send_all());
 }
 }
-HWProtocolMessage::Global(msg) => {
+HwProtocolMessage::Global(msg) => {
 if !server.clients[client_id].is_admin() {
 response.add(Warning("Access denied.".to_string()).send_self());
 } else {
 response.add(global_chat(msg).send_all())
 }
 }
-HWProtocolMessage::SuperPower => {
+HwProtocolMessage::SuperPower => {
 if !server.clients[client_id].is_admin() {
 response.add(Warning("Access denied.".to_string()).send_self());
 } else {
 server.clients[client_id].set_has_super_power(true);
 response
 .add(server_chat("Super power activated.".to_string()).send_self())
 }
 }
-HWProtocolMessage::Watch(id) => {
+HwProtocolMessage::Watch(id) => {
 #[cfg(feature = "official-server")]
 {
 response.request_io(IoTask::GetReplay { id })
 }
 }
 }
 }
 }
-pub fn handle_client_accept(server: &mut HWServer, client_id: ClientId, response: &mut Response) {
+pub fn handle_client_accept(server: &mut HwServer, client_id: ClientId, response: &mut Response) {
 let mut salt = [0u8; 18];
 thread_rng().fill_bytes(&mut salt);
 server.anteroom.add_client(client_id, encode(&salt));
-response.add(HWServerMessage::Connected(utils::SERVER_VERSION).send_self());
+response.add(HwServerMessage::Connected(utils::SERVER_VERSION).send_self());
 }
-pub fn handle_client_loss(server: &mut HWServer, client_id: ClientId, response: &mut Response) {
+pub fn handle_client_loss(server: &mut HwServer, client_id: ClientId, response: &mut Response) {
 if server.anteroom.remove_client(client_id).is_none() {
 common::remove_client(server, response, "Connection reset".to_string());
 }
 }
 pub fn handle_io_result(
-server: &mut HWServer,
+server: &mut HwServer,
 client_id: ClientId,
 response: &mut Response,
 io_result: IoResult,
 ) {
 match io_result {

changeset 15075	e935b1ad23f3
parent 15074	c5a6e8566425
child 15102	80ff12edf5e6