normalize type names
authoralfadur
Tue, 28 May 2019 21:28:32 +0300
changeset 15096 e935b1ad23f3
parent 15095 c5a6e8566425
child 15097 527a7414bb44
normalize type names
rust/hedgewars-server/src/core.rs
rust/hedgewars-server/src/core/client.rs
rust/hedgewars-server/src/core/room.rs
rust/hedgewars-server/src/core/server.rs
rust/hedgewars-server/src/handlers.rs
rust/hedgewars-server/src/handlers/actions.rs
rust/hedgewars-server/src/handlers/checker.rs
rust/hedgewars-server/src/handlers/common.rs
rust/hedgewars-server/src/handlers/inanteroom.rs
rust/hedgewars-server/src/handlers/inlobby.rs
rust/hedgewars-server/src/handlers/inroom.rs
rust/hedgewars-server/src/main.rs
rust/hedgewars-server/src/protocol.rs
rust/hedgewars-server/src/protocol/messages.rs
rust/hedgewars-server/src/protocol/parser.rs
rust/hedgewars-server/src/protocol/test.rs
rust/hedgewars-server/src/server.rs
rust/hedgewars-server/src/server/database.rs
rust/hedgewars-server/src/server/io.rs
rust/hedgewars-server/src/server/network.rs
--- a/rust/hedgewars-server/src/core.rs	Tue May 28 19:04:18 2019 +0300
+++ b/rust/hedgewars-server/src/core.rs	Tue May 28 21:28:32 2019 +0300
@@ -1,5 +1,5 @@
-pub mod types;
+pub mod client;
 pub mod indexslab;
-pub mod client;
 pub mod room;
-pub mod server;
\ No newline at end of file
+pub mod server;
+pub mod types;
--- a/rust/hedgewars-server/src/core/client.rs	Tue May 28 19:04:18 2019 +0300
+++ b/rust/hedgewars-server/src/core/client.rs	Tue May 28 21:28:32 2019 +0300
@@ -18,7 +18,7 @@
     }
 }
 
-pub struct HWClient {
+pub struct HwClient {
     pub id: ClientId,
     pub room_id: Option<usize>,
     pub nick: String,
@@ -29,9 +29,9 @@
     pub clan: Option<u8>,
 }
 
-impl HWClient {
-    pub fn new(id: ClientId, protocol_number: u16, nick: String) -> HWClient {
-        HWClient {
+impl HwClient {
+    pub fn new(id: ClientId, protocol_number: u16, nick: String) -> HwClient {
+        HwClient {
             id,
             nick,
             protocol_number,
--- a/rust/hedgewars-server/src/core/room.rs	Tue May 28 19:04:18 2019 +0300
+++ b/rust/hedgewars-server/src/core/room.rs	Tue May 28 21:28:32 2019 +0300
@@ -1,5 +1,5 @@
 use super::{
-    client::HWClient,
+    client::HwClient,
     types::{
         ClientId, GameCfg, GameCfg::*, RoomConfig, RoomId, TeamInfo, Voting, MAX_HEDGEHOGS_PER_TEAM,
     },
@@ -66,7 +66,7 @@
     }
 }
 
-pub struct HWRoom {
+pub struct HwRoom {
     pub id: RoomId,
     pub master_id: Option<ClientId>,
     pub name: String,
@@ -86,9 +86,9 @@
     pub game_info: Option<GameInfo>,
 }
 
-impl HWRoom {
-    pub fn new(id: RoomId) -> HWRoom {
-        HWRoom {
+impl HwRoom {
+    pub fn new(id: RoomId) -> HwRoom {
+        HwRoom {
             id,
             master_id: None,
             name: String::new(),
@@ -275,7 +275,7 @@
         result
     }
 
-    pub fn info(&self, master: Option<&HWClient>) -> Vec<String> {
+    pub fn info(&self, master: Option<&HwClient>) -> Vec<String> {
         let c = &self.config;
         vec![
             self.flags_string(),
--- a/rust/hedgewars-server/src/core/server.rs	Tue May 28 19:04:18 2019 +0300
+++ b/rust/hedgewars-server/src/core/server.rs	Tue May 28 21:28:32 2019 +0300
@@ -1,13 +1,10 @@
 use super::{
-    client::HWClient,
-    types::{ClientId, RoomId},
+    client::HwClient,
     indexslab::IndexSlab,
-    room::HWRoom,
+    room::HwRoom,
+    types::{ClientId, RoomId},
 };
-use crate::{
-    utils,
-    protocol::messages::HWProtocolMessage::Greeting
-};
+use crate::{protocol::messages::HwProtocolMessage::Greeting, utils};
 
 use bitflags::*;
 use log::*;
@@ -16,25 +13,25 @@
 
 type Slab<T> = slab::Slab<T>;
 
-pub struct HWAnteClient {
+pub struct HwAnteClient {
     pub nick: Option<String>,
     pub protocol_number: Option<NonZeroU16>,
     pub server_salt: String,
     pub is_checker: bool,
 }
 
-pub struct HWAnteroom {
-    pub clients: IndexSlab<HWAnteClient>,
+pub struct HwAnteroom {
+    pub clients: IndexSlab<HwAnteClient>,
 }
 
-impl HWAnteroom {
+impl HwAnteroom {
     pub fn new(clients_limit: usize) -> Self {
         let clients = IndexSlab::with_capacity(clients_limit);
-        HWAnteroom { clients }
+        HwAnteroom { clients }
     }
 
     pub fn add_client(&mut self, client_id: ClientId, salt: String) {
-        let client = HWAnteClient {
+        let client = HwAnteClient {
             nick: None,
             protocol_number: None,
             server_salt: salt,
@@ -43,7 +40,7 @@
         self.clients.insert(client_id, client);
     }
 
-    pub fn remove_client(&mut self, client_id: ClientId) -> Option<HWAnteClient> {
+    pub fn remove_client(&mut self, client_id: ClientId) -> Option<HwAnteClient> {
         let mut client = self.clients.remove(client_id);
         client
     }
@@ -69,32 +66,32 @@
     }
 }
 
-pub struct HWServer {
-    pub clients: IndexSlab<HWClient>,
-    pub rooms: Slab<HWRoom>,
-    pub anteroom: HWAnteroom,
+pub struct HwServer {
+    pub clients: IndexSlab<HwClient>,
+    pub rooms: Slab<HwRoom>,
+    pub anteroom: HwAnteroom,
     pub latest_protocol: u16,
     pub flags: ServerFlags,
     pub greetings: ServerGreetings,
 }
 
-impl HWServer {
+impl HwServer {
     pub fn new(clients_limit: usize, rooms_limit: usize) -> Self {
         let rooms = Slab::with_capacity(rooms_limit);
         let clients = IndexSlab::with_capacity(clients_limit);
         Self {
             clients,
             rooms,
-            anteroom: HWAnteroom::new(clients_limit),
+            anteroom: HwAnteroom::new(clients_limit),
             greetings: ServerGreetings::new(),
             latest_protocol: 58,
             flags: ServerFlags::empty(),
         }
     }
 
-    pub fn add_client(&mut self, client_id: ClientId, data: HWAnteClient) {
+    pub fn add_client(&mut self, client_id: ClientId, data: HwAnteClient) {
         if let (Some(protocol), Some(nick)) = (data.protocol_number, data.nick) {
-            let mut client = HWClient::new(client_id, protocol.get(), nick);
+            let mut client = HwClient::new(client_id, protocol.get(), nick);
             client.set_is_checker(data.is_checker);
             self.clients.insert(client_id, client);
         }
@@ -136,25 +133,25 @@
         self.find_room(name).is_some()
     }
 
-    pub fn find_room(&self, name: &str) -> Option<&HWRoom> {
+    pub fn find_room(&self, name: &str) -> Option<&HwRoom> {
         self.rooms
             .iter()
             .find_map(|(_, r)| Some(r).filter(|r| r.name == name))
     }
 
-    pub fn find_room_mut(&mut self, name: &str) -> Option<&mut HWRoom> {
+    pub fn find_room_mut(&mut self, name: &str) -> Option<&mut HwRoom> {
         self.rooms
             .iter_mut()
             .find_map(|(_, r)| Some(r).filter(|r| r.name == name))
     }
 
-    pub fn find_client(&self, nick: &str) -> Option<&HWClient> {
+    pub fn find_client(&self, nick: &str) -> Option<&HwClient> {
         self.clients
             .iter()
             .find_map(|(_, c)| Some(c).filter(|c| c.nick == nick))
     }
 
-    pub fn find_client_mut(&mut self, nick: &str) -> Option<&mut HWClient> {
+    pub fn find_client_mut(&mut self, nick: &str) -> Option<&mut HwClient> {
         self.clients
             .iter_mut()
             .find_map(|(_, c)| Some(c).filter(|c| c.nick == nick))
@@ -166,28 +163,28 @@
 
     pub fn filter_clients<'a, F>(&'a self, f: F) -> impl Iterator<Item = ClientId> + 'a
     where
-        F: Fn(&(usize, &HWClient)) -> bool + 'a,
+        F: Fn(&(usize, &HwClient)) -> bool + 'a,
     {
         self.clients.iter().filter(f).map(|(_, c)| c.id)
     }
 
     pub fn filter_rooms<'a, F>(&'a self, f: F) -> impl Iterator<Item = RoomId> + 'a
     where
-        F: Fn(&(usize, &HWRoom)) -> bool + 'a,
+        F: Fn(&(usize, &HwRoom)) -> bool + 'a,
     {
         self.rooms.iter().filter(f).map(|(_, c)| c.id)
     }
 
     pub fn collect_clients<F>(&self, f: F) -> Vec<ClientId>
     where
-        F: Fn(&(usize, &HWClient)) -> bool,
+        F: Fn(&(usize, &HwClient)) -> bool,
     {
         self.filter_clients(f).collect()
     }
 
     pub fn collect_nicks<F>(&self, f: F) -> Vec<String>
     where
-        F: Fn(&(usize, &HWClient)) -> bool,
+        F: Fn(&(usize, &HwClient)) -> bool,
     {
         self.clients
             .iter()
@@ -226,15 +223,15 @@
     }
 }
 
-fn allocate_room(rooms: &mut Slab<HWRoom>) -> &mut HWRoom {
+fn allocate_room(rooms: &mut Slab<HwRoom>) -> &mut HwRoom {
     let entry = rooms.vacant_entry();
-    let room = HWRoom::new(entry.key());
+    let room = HwRoom::new(entry.key());
     entry.insert(room)
 }
 
 fn create_room(
-    client: &mut HWClient,
-    rooms: &mut Slab<HWRoom>,
+    client: &mut HwClient,
+    rooms: &mut Slab<HwRoom>,
     name: String,
     password: Option<String>,
 ) -> RoomId {
@@ -256,7 +253,7 @@
     room.id
 }
 
-fn move_to_room(client: &mut HWClient, room: &mut HWRoom) {
+fn move_to_room(client: &mut HwClient, room: &mut HwRoom) {
     debug_assert!(client.room_id != Some(room.id));
 
     room.players_number += 1;
--- a/rust/hedgewars-server/src/handlers.rs	Tue May 28 19:04:18 2019 +0300
+++ b/rust/hedgewars-server/src/handlers.rs	Tue May 28 21:28:32 2019 +0300
@@ -3,21 +3,17 @@
 
 use self::{
     actions::{Destination, DestinationGroup, PendingMessage},
-    inanteroom::LoginResult
+    inanteroom::LoginResult,
 };
 use crate::{
     core::{
-        server::HWServer,
-        types::{ClientId, Replay, RoomId, GameCfg, TeamInfo},
-        room::RoomSave
+        room::RoomSave,
+        server::HwServer,
+        types::{ClientId, GameCfg, Replay, RoomId, TeamInfo},
     },
     protocol::messages::{
-        server_chat,
-        HWProtocolMessage,
-        HWServerMessage,
-        HWServerMessage::*,
-        global_chat,
-        HWProtocolMessage::EngineMessage
+        global_chat, server_chat, HwProtocolMessage, HwProtocolMessage::EngineMessage,
+        HwServerMessage, HwServerMessage::*,
     },
     utils,
 };
@@ -28,9 +24,9 @@
 mod actions;
 mod checker;
 mod common;
-mod inroom;
+mod inanteroom;
 mod inlobby;
-mod inanteroom;
+mod inroom;
 
 use std::fmt::{Formatter, LowerHex};
 
@@ -132,8 +128,8 @@
 
     pub fn extract_messages<'a, 'b: 'a>(
         &'b mut self,
-        server: &'a HWServer,
-    ) -> impl Iterator<Item = (Vec<ClientId>, HWServerMessage)> + 'a {
+        server: &'a HwServer,
+    ) -> 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);
@@ -163,7 +159,7 @@
 }
 
 fn get_recipients(
-    server: &HWServer,
+    server: &HwServer,
     client_id: ClientId,
     destination: Destination,
 ) -> Vec<ClientId> {
@@ -191,13 +187,13 @@
 }
 
 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) {
@@ -215,13 +211,13 @@
                 }
             } 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 { "" };
@@ -253,7 +249,7 @@
                                 .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 {
@@ -266,14 +262,14 @@
                             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 {
@@ -282,7 +278,7 @@
                                 .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 })
@@ -308,23 +304,23 @@
     }
 }
 
-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,
--- a/rust/hedgewars-server/src/handlers/actions.rs	Tue May 28 19:04:18 2019 +0300
+++ b/rust/hedgewars-server/src/handlers/actions.rs	Tue May 28 21:28:32 2019 +0300
@@ -1,12 +1,12 @@
 use crate::{
     core::{
-        client::HWClient,
-        server::HWServer,
+        client::HwClient,
+        room::HwRoom,
+        room::{GameInfo, RoomFlags},
+        server::HwServer,
         types::{ClientId, GameCfg, RoomId, VoteType},
-        room::HWRoom,
-        room::{GameInfo, RoomFlags}
     },
-    protocol::messages::{server_chat, HWProtocolMessage, HWServerMessage, HWServerMessage::*},
+    protocol::messages::{server_chat, HwProtocolMessage, HwServerMessage, HwServerMessage::*},
     utils::to_engine_msg,
 };
 use rand::{distributions::Uniform, thread_rng, Rng};
@@ -31,32 +31,32 @@
 
 pub struct PendingMessage {
     pub destination: Destination,
-    pub message: HWServerMessage,
+    pub message: HwServerMessage,
 }
 
 impl PendingMessage {
-    pub fn send(message: HWServerMessage, client_id: ClientId) -> PendingMessage {
+    pub fn send(message: HwServerMessage, client_id: ClientId) -> PendingMessage {
         PendingMessage {
             destination: Destination::ToId(client_id),
             message,
         }
     }
 
-    pub fn send_many(message: HWServerMessage, client_ids: Vec<ClientId>) -> PendingMessage {
+    pub fn send_many(message: HwServerMessage, client_ids: Vec<ClientId>) -> PendingMessage {
         PendingMessage {
             destination: Destination::ToIds(client_ids),
             message,
         }
     }
 
-    pub fn send_self(message: HWServerMessage) -> PendingMessage {
+    pub fn send_self(message: HwServerMessage) -> PendingMessage {
         PendingMessage {
             destination: Destination::ToSelf,
             message,
         }
     }
 
-    pub fn send_all(message: HWServerMessage) -> PendingMessage {
+    pub fn send_all(message: HwServerMessage) -> PendingMessage {
         let destination = Destination::ToAll {
             group: DestinationGroup::All,
             skip_self: false,
@@ -99,7 +99,7 @@
     }
 }
 
-impl HWServerMessage {
+impl HwServerMessage {
     pub fn send(self, client_id: ClientId) -> PendingMessage {
         PendingMessage::send(self, client_id)
     }
--- a/rust/hedgewars-server/src/handlers/checker.rs	Tue May 28 19:04:18 2019 +0300
+++ b/rust/hedgewars-server/src/handlers/checker.rs	Tue May 28 21:28:32 2019 +0300
@@ -2,11 +2,11 @@
 use mio;
 
 use crate::{
-    protocol::messages::HWProtocolMessage,
-    core::{server::HWServer, types::ClientId},
+    core::{server::HwServer, types::ClientId},
+    protocol::messages::HwProtocolMessage,
 };
 
-pub fn handle(_server: &mut HWServer, _client_id: ClientId, message: HWProtocolMessage) {
+pub fn handle(_server: &mut HwServer, _client_id: ClientId, message: HwProtocolMessage) {
     match message {
         _ => warn!("Unknown command"),
     }
--- a/rust/hedgewars-server/src/handlers/common.rs	Tue May 28 19:04:18 2019 +0300
+++ b/rust/hedgewars-server/src/handlers/common.rs	Tue May 28 21:28:32 2019 +0300
@@ -1,17 +1,16 @@
 use crate::{
+    core::{
+        client::HwClient,
+        room::HwRoom,
+        server::HwServer,
+        types::{ClientId, GameCfg, RoomId, TeamInfo, Vote, VoteType},
+    },
     protocol::messages::{
-        server_chat,
-        add_flags, remove_flags,
-        HWProtocolMessage::{self, Rnd},
-        HWServerMessage::{self, *},
+        add_flags, remove_flags, server_chat,
+        HwProtocolMessage::{self, Rnd},
+        HwServerMessage::{self, *},
         ProtocolFlags as Flags,
     },
-    core::{
-        client::HWClient,
-        server::HWServer,
-        types::{ClientId, GameCfg, RoomId, TeamInfo, Vote, VoteType},
-        room::HWRoom,
-    },
     utils::to_engine_msg,
 };
 
@@ -21,7 +20,7 @@
 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() {
@@ -36,7 +35,7 @@
     }
 }
 
-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];
@@ -100,7 +99,7 @@
 }
 
 pub fn remove_teams(
-    room: &mut HWRoom,
+    room: &mut HwRoom,
     team_names: Vec<String>,
     is_in_game: bool,
     response: &mut Response,
@@ -144,8 +143,8 @@
 }
 
 fn remove_client_from_room(
-    client: &mut HWClient,
-    room: &mut HWRoom,
+    client: &mut HwClient,
+    room: &mut HwRoom,
     response: &mut Response,
     msg: &str,
 ) {
@@ -197,7 +196,7 @@
 }
 
 pub fn change_master(
-    server: &mut HWServer,
+    server: &mut HwServer,
     room_id: RoomId,
     new_master_id: ClientId,
     response: &mut Response,
@@ -229,7 +228,7 @@
 }
 
 pub fn enter_room(
-    server: &mut HWServer,
+    server: &mut HwServer,
     client_id: ClientId,
     room_id: RoomId,
     response: &mut Response,
@@ -271,7 +270,7 @@
     }
 }
 
-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 {
@@ -309,7 +308,7 @@
     }
 }
 
-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();
@@ -325,8 +324,8 @@
 
 pub fn get_room_update(
     room_name: Option<String>,
-    room: &HWRoom,
-    master: Option<&HWClient>,
+    room: &HwRoom,
+    master: Option<&HwClient>,
     response: &mut Response,
 ) {
     let update_msg = RoomUpdated(room_name.unwrap_or(room.name.clone()), room.info(master));
@@ -340,7 +339,7 @@
     }
 }
 
-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);
 }
 
@@ -356,7 +355,7 @@
 }
 
 pub fn get_room_teams(
-    server: &HWServer,
+    server: &HwServer,
     room_id: RoomId,
     to_client: ClientId,
     response: &mut Response,
@@ -371,7 +370,7 @@
 }
 
 pub fn get_room_flags(
-    server: &HWServer,
+    server: &HwServer,
     room_id: RoomId,
     to_client: ClientId,
     response: &mut Response,
@@ -398,7 +397,7 @@
 }
 
 pub fn apply_voting_result(
-    server: &mut HWServer,
+    server: &mut HwServer,
     room_id: RoomId,
     response: &mut Response,
     kind: VoteType,
@@ -470,7 +469,7 @@
     }
 }
 
-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;
 
@@ -498,7 +497,7 @@
     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];
 
@@ -519,7 +518,7 @@
     }
 }
 
-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()
@@ -558,7 +557,7 @@
     }
 }
 
-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 {
@@ -613,10 +612,10 @@
 #[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"),
--- a/rust/hedgewars-server/src/handlers/inanteroom.rs	Tue May 28 19:04:18 2019 +0300
+++ b/rust/hedgewars-server/src/handlers/inanteroom.rs	Tue May 28 21:28:32 2019 +0300
@@ -1,16 +1,13 @@
 use mio;
 
 use crate::{
-    protocol::messages::{
-        HWProtocolMessage::LoadRoom,
-        HWProtocolMessage,
-        HWServerMessage::*},
     core::{
-        client::HWClient,
-        server::{HWServer, HWAnteClient, HWAnteroom},
-        types::ClientId
+        client::HwClient,
+        server::{HwAnteClient, HwAnteroom, HwServer},
+        types::ClientId,
     },
-    utils::is_name_illegal
+    protocol::messages::{HwProtocolMessage, HwProtocolMessage::LoadRoom, HwServerMessage::*},
+    utils::is_name_illegal,
 };
 
 use log::*;
@@ -29,11 +26,11 @@
 
 fn completion_result<'a, I>(
     mut other_clients: I,
-    client: &mut HWAnteClient,
+    client: &mut HwAnteClient,
     response: &mut super::Response,
 ) -> LoginResult
 where
-    I: Iterator<Item = (ClientId, &'a HWClient)>,
+    I: Iterator<Item = (ClientId, &'a HwClient)>,
 {
     let has_nick_clash =
         other_clients.any(|(_, c)| !c.is_checker() && c.nick == *client.nick.as_ref().unwrap());
@@ -62,17 +59,17 @@
 }
 
 pub fn handle(
-    server: &mut HWServer,
+    server: &mut HwServer,
     client_id: ClientId,
     response: &mut super::Response,
-    message: HWProtocolMessage,
+    message: HwProtocolMessage,
 ) -> LoginResult {
     match message {
-        HWProtocolMessage::Quit(_) => {
+        HwProtocolMessage::Quit(_) => {
             response.add(Bye("User quit".to_string()).send_self());
             LoginResult::Exit
         }
-        HWProtocolMessage::Nick(nick) => {
+        HwProtocolMessage::Nick(nick) => {
             let client = &mut server.anteroom.clients[client_id];
 
             if client.nick.is_some() {
@@ -92,7 +89,7 @@
                 }
             }
         }
-        HWProtocolMessage::Proto(proto) => {
+        HwProtocolMessage::Proto(proto) => {
             let client = &mut server.anteroom.clients[client_id];
             if client.protocol_number.is_some() {
                 response.add(Error("Protocol already known.".to_string()).send_self());
@@ -112,7 +109,7 @@
             }
         }
         #[cfg(feature = "official-server")]
-        HWProtocolMessage::Password(hash, salt) => {
+        HwProtocolMessage::Password(hash, salt) => {
             let client = &server.anteroom.clients[client_id];
 
             if let (Some(nick), Some(protocol)) = (client.nick.as_ref(), client.protocol_number) {
@@ -128,7 +125,7 @@
             LoginResult::Unchanged
         }
         #[cfg(feature = "official-server")]
-        HWProtocolMessage::Checker(protocol, nick, password) => {
+        HwProtocolMessage::Checker(protocol, nick, password) => {
             let client = &mut server.anteroom.clients[client_id];
             if protocol == 0 {
                 response.add(Error("Bad number.".to_string()).send_self());
--- a/rust/hedgewars-server/src/handlers/inlobby.rs	Tue May 28 19:04:18 2019 +0300
+++ b/rust/hedgewars-server/src/handlers/inlobby.rs	Tue May 28 21:28:32 2019 +0300
@@ -2,14 +2,14 @@
 
 use super::common::rnd_reply;
 use crate::{
-    protocol::messages::{
-        add_flags, remove_flags, server_chat, HWProtocolMessage, HWServerMessage::*,
-        ProtocolFlags as Flags,
+    core::{
+        client::HwClient,
+        server::HwServer,
+        types::{ClientId, ServerVar},
     },
-    core::{
-        client::HWClient,
-        server::HWServer,
-        types::{ClientId, ServerVar},
+    protocol::messages::{
+        add_flags, remove_flags, server_chat, HwProtocolMessage, HwServerMessage::*,
+        ProtocolFlags as Flags,
     },
     utils::is_name_illegal,
 };
@@ -17,12 +17,12 @@
 use std::{collections::HashSet, convert::identity};
 
 pub fn handle(
-    server: &mut HWServer,
+    server: &mut HwServer,
     client_id: ClientId,
     response: &mut super::Response,
-    message: HWProtocolMessage,
+    message: HwProtocolMessage,
 ) {
-    use crate::protocol::messages::HWProtocolMessage::*;
+    use crate::protocol::messages::HwProtocolMessage::*;
     match message {
         CreateRoom(name, password) => {
             if is_name_illegal(&name) {
@@ -94,7 +94,7 @@
             }
         }
         Follow(nick) => {
-            if let Some(HWClient {
+            if let Some(HwClient {
                 room_id: Some(room_id),
                 ..
             }) = server.find_client(&nick)
--- a/rust/hedgewars-server/src/handlers/inroom.rs	Tue May 28 19:04:18 2019 +0300
+++ b/rust/hedgewars-server/src/handlers/inroom.rs	Tue May 28 21:28:32 2019 +0300
@@ -3,15 +3,15 @@
 use super::common::rnd_reply;
 use crate::utils::to_engine_msg;
 use crate::{
-    protocol::messages::{
-        add_flags, remove_flags, server_chat, HWProtocolMessage, HWServerMessage::*,
-        ProtocolFlags as Flags,
-    },
     core::{
-        server::HWServer,
+        room::{HwRoom, RoomFlags, MAX_TEAMS_IN_ROOM},
+        server::HwServer,
         types,
         types::{ClientId, GameCfg, RoomId, VoteType, Voting, MAX_HEDGEHOGS_PER_TEAM},
-        room::{HWRoom, RoomFlags, MAX_TEAMS_IN_ROOM},
+    },
+    protocol::messages::{
+        add_flags, remove_flags, server_chat, HwProtocolMessage, HwServerMessage::*,
+        ProtocolFlags as Flags,
     },
     utils::is_name_illegal,
 };
@@ -93,8 +93,8 @@
     )
 }
 
-fn room_message_flag(msg: &HWProtocolMessage) -> RoomFlags {
-    use crate::protocol::messages::HWProtocolMessage::*;
+fn room_message_flag(msg: &HwProtocolMessage) -> RoomFlags {
+    use crate::protocol::messages::HwProtocolMessage::*;
     match msg {
         ToggleRestrictJoin => RoomFlags::RESTRICTED_JOIN,
         ToggleRestrictTeams => RoomFlags::RESTRICTED_TEAM_ADD,
@@ -104,16 +104,16 @@
 }
 
 pub fn handle(
-    server: &mut HWServer,
+    server: &mut HwServer,
     client_id: ClientId,
     response: &mut super::Response,
     room_id: RoomId,
-    message: HWProtocolMessage,
+    message: HwProtocolMessage,
 ) {
     let client = &mut server.clients[client_id];
     let room = &mut server.rooms[room_id];
 
-    use crate::protocol::messages::HWProtocolMessage::*;
+    use crate::protocol::messages::HwProtocolMessage::*;
     match message {
         Part(msg) => {
             let msg = match msg {
--- a/rust/hedgewars-server/src/main.rs	Tue May 28 19:04:18 2019 +0300
+++ b/rust/hedgewars-server/src/main.rs	Tue May 28 21:28:32 2019 +0300
@@ -7,8 +7,8 @@
 use std::{env, str::FromStr as _, time::Duration};
 
 mod core;
+mod handlers;
 mod protocol;
-mod handlers;
 mod server;
 mod utils;
 
--- a/rust/hedgewars-server/src/protocol.rs	Tue May 28 19:04:18 2019 +0300
+++ b/rust/hedgewars-server/src/protocol.rs	Tue May 28 21:28:32 2019 +0300
@@ -44,7 +44,7 @@
         Ok(count)
     }
 
-    pub fn extract_messages(&mut self) -> Vec<messages::HWProtocolMessage> {
+    pub fn extract_messages(&mut self) -> Vec<messages::HwProtocolMessage> {
         let mut messages = vec![];
         if !self.is_recovering {
             loop {
--- a/rust/hedgewars-server/src/protocol/messages.rs	Tue May 28 19:04:18 2019 +0300
+++ b/rust/hedgewars-server/src/protocol/messages.rs	Tue May 28 21:28:32 2019 +0300
@@ -2,7 +2,7 @@
 use std::{convert::From, iter::once, ops};
 
 #[derive(PartialEq, Eq, Clone, Debug)]
-pub enum HWProtocolMessage {
+pub enum HwProtocolMessage {
     // common messages
     Ping,
     Pong,
@@ -108,7 +108,7 @@
 }
 
 #[derive(Debug)]
-pub enum HWServerMessage {
+pub enum HwServerMessage {
     Connected(u32),
     Redirect(u16),
 
@@ -156,18 +156,18 @@
     LegacyReady(bool, Vec<String>),
 }
 
-fn special_chat(nick: &str, msg: String) -> HWServerMessage {
-    HWServerMessage::ChatMsg {
+fn special_chat(nick: &str, msg: String) -> HwServerMessage {
+    HwServerMessage::ChatMsg {
         nick: nick.to_string(),
         msg,
     }
 }
 
-pub fn server_chat(msg: String) -> HWServerMessage {
+pub fn server_chat(msg: String) -> HwServerMessage {
     special_chat("[server]", msg)
 }
 
-pub fn global_chat(msg: String) -> HWServerMessage {
+pub fn global_chat(msg: String) -> HwServerMessage {
     special_chat("(global notice)", msg)
 }
 
@@ -206,10 +206,10 @@
         }
     }
 
-    pub fn to_server_msg(&self) -> HWServerMessage {
-        use self::HWServerMessage::ConfigEntry;
+    pub fn to_server_msg(&self) -> HwServerMessage {
+        use self::HwServerMessage::ConfigEntry;
         let (name, args) = self.to_protocol();
-        HWServerMessage::ConfigEntry(name, args)
+        HwServerMessage::ConfigEntry(name, args)
     }
 }
 
@@ -251,14 +251,14 @@
     [$part: expr, $($other: expr),*] => { once($part).chain(several![$($other),*]) };
 }
 
-impl HWProtocolMessage {
+impl HwProtocolMessage {
     /** Converts the message to a raw `String`, which can be sent over the network.
      *
      * This is the inverse of the `message` parser.
      */
     #[cfg(test)]
     pub(crate) fn to_raw_protocol(&self) -> String {
-        use self::HWProtocolMessage::*;
+        use self::HwProtocolMessage::*;
         match self {
             Ping => msg!["PING"],
             Pong => msg!["PONG"],
@@ -355,9 +355,9 @@
     v.join("\n")
 }
 
-impl HWServerMessage {
+impl HwServerMessage {
     pub fn to_raw_protocol(&self) -> String {
-        use self::HWServerMessage::*;
+        use self::HwServerMessage::*;
         match self {
             Ping => msg!["PING"],
             Pong => msg!["PONG"],
--- a/rust/hedgewars-server/src/protocol/parser.rs	Tue May 28 19:04:18 2019 +0300
+++ b/rust/hedgewars-server/src/protocol/parser.rs	Tue May 28 21:28:32 2019 +0300
@@ -14,58 +14,56 @@
     str::{FromStr, Utf8Error},
 };
 
-use super::{
-    messages::{HWProtocolMessage, HWProtocolMessage::*},
-};
+use super::messages::{HwProtocolMessage, HwProtocolMessage::*};
 use crate::core::types::{
     GameCfg, HedgehogInfo, ServerVar, TeamInfo, VoteType, MAX_HEDGEHOGS_PER_TEAM,
 };
 
 #[derive(Debug, PartialEq)]
-pub struct HWProtocolError {}
+pub struct HwProtocolError {}
 
-impl HWProtocolError {
+impl HwProtocolError {
     fn new() -> Self {
-        HWProtocolError {}
+        HwProtocolError {}
     }
 }
 
-impl<I> ParseError<I> for HWProtocolError {
+impl<I> ParseError<I> for HwProtocolError {
     fn from_error_kind(input: I, kind: ErrorKind) -> Self {
-        HWProtocolError::new()
+        HwProtocolError::new()
     }
 
     fn append(input: I, kind: ErrorKind, other: Self) -> Self {
-        HWProtocolError::new()
+        HwProtocolError::new()
     }
 }
 
-impl From<Utf8Error> for HWProtocolError {
+impl From<Utf8Error> for HwProtocolError {
     fn from(_: Utf8Error) -> Self {
-        HWProtocolError::new()
+        HwProtocolError::new()
     }
 }
 
-impl From<ParseIntError> for HWProtocolError {
+impl From<ParseIntError> for HwProtocolError {
     fn from(_: ParseIntError) -> Self {
-        HWProtocolError::new()
+        HwProtocolError::new()
     }
 }
 
-pub type HWResult<'a, O> = IResult<&'a [u8], O, HWProtocolError>;
+pub type HwResult<'a, O> = IResult<&'a [u8], O, HwProtocolError>;
 
-fn end_of_message(input: &[u8]) -> HWResult<&[u8]> {
+fn end_of_message(input: &[u8]) -> HwResult<&[u8]> {
     tag("\n\n")(input)
 }
 
-fn convert_utf8(input: &[u8]) -> HWResult<&str> {
+fn convert_utf8(input: &[u8]) -> HwResult<&str> {
     match str::from_utf8(input) {
         Ok(str) => Ok((b"", str)),
         Err(utf_err) => Result::Err(Err::Failure(utf_err.into())),
     }
 }
 
-fn convert_from_str<T>(str: &str) -> HWResult<T>
+fn convert_from_str<T>(str: &str) -> HwResult<T>
 where
     T: FromStr<Err = ParseIntError>,
 {
@@ -75,72 +73,72 @@
     }
 }
 
-fn str_line(input: &[u8]) -> HWResult<&str> {
+fn str_line(input: &[u8]) -> HwResult<&str> {
     let (i, text) = not_line_ending(input)?;
     Ok((i, convert_utf8(text)?.1))
 }
 
-fn a_line(input: &[u8]) -> HWResult<String> {
+fn a_line(input: &[u8]) -> HwResult<String> {
     let (i, str) = str_line(input)?;
     Ok((i, str.to_string()))
 }
 
-fn hw_tag<'a>(tag_str: &'a str) -> impl Fn(&'a [u8]) -> HWResult<'a, ()> {
+fn hw_tag<'a>(tag_str: &'a str) -> impl Fn(&'a [u8]) -> HwResult<'a, ()> {
     move |i| tag(tag_str)(i).map(|(i, _)| (i, ()))
 }
 
-fn hw_tag_no_case<'a>(tag_str: &'a str) -> impl Fn(&'a [u8]) -> HWResult<'a, ()> {
+fn hw_tag_no_case<'a>(tag_str: &'a str) -> impl Fn(&'a [u8]) -> HwResult<'a, ()> {
     move |i| tag_no_case(tag_str)(i).map(|(i, _)| (i, ()))
 }
 
-fn cmd_arg(input: &[u8]) -> HWResult<String> {
+fn cmd_arg(input: &[u8]) -> HwResult<String> {
     let delimiters = b" \n";
     let (i, str) = take_while(move |c| !delimiters.contains(&c))(input)?;
     Ok((i, convert_utf8(str)?.1.to_string()))
 }
 
-fn u8_line(input: &[u8]) -> HWResult<u8> {
+fn u8_line(input: &[u8]) -> HwResult<u8> {
     let (i, str) = str_line(input)?;
     Ok((i, convert_from_str(str)?.1))
 }
 
-fn u16_line(input: &[u8]) -> HWResult<u16> {
+fn u16_line(input: &[u8]) -> HwResult<u16> {
     let (i, str) = str_line(input)?;
     Ok((i, convert_from_str(str)?.1))
 }
 
-fn u32_line(input: &[u8]) -> HWResult<u32> {
+fn u32_line(input: &[u8]) -> HwResult<u32> {
     let (i, str) = str_line(input)?;
     Ok((i, convert_from_str(str)?.1))
 }
 
-fn yes_no_line(input: &[u8]) -> HWResult<bool> {
+fn yes_no_line(input: &[u8]) -> HwResult<bool> {
     alt((
         |i| tag_no_case(b"YES")(i).map(|(i, _)| (i, true)),
         |i| tag_no_case(b"NO")(i).map(|(i, _)| (i, false)),
     ))(input)
 }
 
-fn opt_arg<'a>(input: &'a [u8]) -> HWResult<'a, Option<String>> {
+fn opt_arg<'a>(input: &'a [u8]) -> HwResult<'a, Option<String>> {
     alt((
         |i: &'a [u8]| peek!(i, end_of_message).map(|(i, _)| (i, None)),
         |i| precededc(i, hw_tag("\n"), a_line).map(|(i, v)| (i, Some(v))),
     ))(input)
 }
 
-fn spaces(input: &[u8]) -> HWResult<&[u8]> {
+fn spaces(input: &[u8]) -> HwResult<&[u8]> {
     precededc(input, hw_tag(" "), |i| take_while(|c| c == b' ')(i))
 }
 
-fn opt_space_arg<'a>(input: &'a [u8]) -> HWResult<'a, Option<String>> {
+fn opt_space_arg<'a>(input: &'a [u8]) -> HwResult<'a, Option<String>> {
     alt((
         |i: &'a [u8]| peek!(i, end_of_message).map(|(i, _)| (i, None)),
         |i| precededc(i, spaces, a_line).map(|(i, v)| (i, Some(v))),
     ))(input)
 }
 
-fn hedgehog_array(input: &[u8]) -> HWResult<[HedgehogInfo; 8]> {
-    fn hedgehog_line(input: &[u8]) -> HWResult<HedgehogInfo> {
+fn hedgehog_array(input: &[u8]) -> HwResult<[HedgehogInfo; 8]> {
+    fn hedgehog_line(input: &[u8]) -> HwResult<HedgehogInfo> {
         let (i, name) = terminatedc(input, a_line, eol)?;
         let (i, hat) = a_line(i)?;
         Ok((i, HedgehogInfo { name, hat }))
@@ -158,7 +156,7 @@
     Ok((i, [h1, h2, h3, h4, h5, h6, h7, h8]))
 }
 
-fn voting(input: &[u8]) -> HWResult<VoteType> {
+fn voting(input: &[u8]) -> HwResult<VoteType> {
     alt((
         |i| tag_no_case("PAUSE")(i).map(|(i, _)| (i, VoteType::Pause)),
         |i| tag_no_case("NEWSEED")(i).map(|(i, _)| (i, VoteType::NewSeed)),
@@ -178,12 +176,12 @@
     ))(input)
 }
 
-fn no_arg_message(input: &[u8]) -> HWResult<HWProtocolMessage> {
+fn no_arg_message(input: &[u8]) -> HwResult<HwProtocolMessage> {
     fn messagec<'a>(
         input: &'a [u8],
         name: &'a str,
-        msg: HWProtocolMessage,
-    ) -> HWResult<'a, HWProtocolMessage> {
+        msg: HwProtocolMessage,
+    ) -> HwResult<'a, HwProtocolMessage> {
         tag(name)(input).map(|(i, _)| (i, msg.clone()))
     }
 
@@ -201,16 +199,16 @@
     ))(input)
 }
 
-fn single_arg_message(input: &[u8]) -> HWResult<HWProtocolMessage> {
+fn single_arg_message(input: &[u8]) -> HwResult<HwProtocolMessage> {
     fn messagec<'a, T, F, G>(
         input: &'a [u8],
         name: &'a str,
         parser: F,
         constructor: G,
-    ) -> HWResult<'a, HWProtocolMessage>
+    ) -> HwResult<'a, HwProtocolMessage>
     where
-        F: Fn(&[u8]) -> HWResult<T>,
-        G: Fn(T) -> HWProtocolMessage,
+        F: Fn(&[u8]) -> HwResult<T>,
+        G: Fn(T) -> HwProtocolMessage,
     {
         precededc(input, hw_tag(name), parser).map(|(i, v)| (i, constructor(v)))
     }
@@ -233,12 +231,12 @@
     ))(input)
 }
 
-fn cmd_message<'a>(input: &'a [u8]) -> HWResult<'a, HWProtocolMessage> {
+fn cmd_message<'a>(input: &'a [u8]) -> HwResult<'a, HwProtocolMessage> {
     fn cmdc_no_arg<'a>(
         input: &'a [u8],
         name: &'a str,
-        msg: HWProtocolMessage,
-    ) -> HWResult<'a, HWProtocolMessage> {
+        msg: HwProtocolMessage,
+    ) -> HwResult<'a, HwProtocolMessage> {
         tag_no_case(name)(input).map(|(i, _)| (i, msg.clone()))
     }
 
@@ -247,16 +245,16 @@
         name: &'a str,
         parser: F,
         constructor: G,
-    ) -> HWResult<'a, HWProtocolMessage>
+    ) -> HwResult<'a, HwProtocolMessage>
     where
-        F: Fn(&'a [u8]) -> HWResult<'a, T>,
-        G: Fn(T) -> HWProtocolMessage,
+        F: Fn(&'a [u8]) -> HwResult<'a, T>,
+        G: Fn(T) -> HwProtocolMessage,
     {
         precededc(input, |i| pairc(i, hw_tag_no_case(name), spaces), parser)
             .map(|(i, v)| (i, constructor(v)))
     }
 
-    fn cmd_no_arg_message(input: &[u8]) -> HWResult<HWProtocolMessage> {
+    fn cmd_no_arg_message(input: &[u8]) -> HwResult<HwProtocolMessage> {
         alt((
             |i| cmdc_no_arg(i, "STATS", Stats),
             |i| cmdc_no_arg(i, "FIX", Fix),
@@ -266,7 +264,7 @@
         ))(input)
     }
 
-    fn cmd_single_arg_message(input: &[u8]) -> HWResult<HWProtocolMessage> {
+    fn cmd_single_arg_message(input: &[u8]) -> HwResult<HwProtocolMessage> {
         alt((
             |i| cmdc_single_arg(i, "RESTART_SERVER", |i| tag("YES")(i), |_| RestartServer),
             |i| cmdc_single_arg(i, "DELEGATE", a_line, Delegate),
@@ -312,15 +310,15 @@
     )
 }
 
-fn config_message<'a>(input: &'a [u8]) -> HWResult<'a, HWProtocolMessage> {
+fn config_message<'a>(input: &'a [u8]) -> HwResult<'a, HwProtocolMessage> {
     fn cfgc_single_arg<'a, T, F, G>(
         input: &'a [u8],
         name: &'a str,
         parser: F,
         constructor: G,
-    ) -> HWResult<'a, GameCfg>
+    ) -> HwResult<'a, GameCfg>
     where
-        F: Fn(&[u8]) -> HWResult<T>,
+        F: Fn(&[u8]) -> HwResult<T>,
         G: Fn(T) -> GameCfg,
     {
         precededc(input, |i| terminatedc(i, hw_tag(name), eol), parser)
@@ -373,7 +371,7 @@
     Ok((i, Cfg(cfg)))
 }
 
-fn server_var_message(input: &[u8]) -> HWResult<HWProtocolMessage> {
+fn server_var_message(input: &[u8]) -> HwResult<HwProtocolMessage> {
     precededc(
         input,
         hw_tag("SET_SERVER_VAR\n"),
@@ -394,7 +392,7 @@
     )
 }
 
-fn complex_message(input: &[u8]) -> HWResult<HWProtocolMessage> {
+fn complex_message(input: &[u8]) -> HwResult<HwProtocolMessage> {
     alt((
         |i| {
             precededc(
@@ -533,12 +531,12 @@
     ))(input)
 }
 
-pub fn malformed_message(input: &[u8]) -> HWResult<()> {
+pub fn malformed_message(input: &[u8]) -> HwResult<()> {
     let (i, _) = terminatedc(input, |i| take_until(&b"\n\n"[..])(i), end_of_message)?;
     Ok((i, ()))
 }
 
-pub fn message(input: &[u8]) -> HWResult<HWProtocolMessage> {
+pub fn message(input: &[u8]) -> HwResult<HwProtocolMessage> {
     precededc(
         input,
         |i| take_while(|c| c == b'\n')(i),
@@ -559,15 +557,15 @@
     )
 }
 
-fn extract_messages(input: &[u8]) -> HWResult<Vec<HWProtocolMessage>> {
+fn extract_messages(input: &[u8]) -> HwResult<Vec<HwProtocolMessage>> {
     many0(message)(input)
 }
 
 #[cfg(test)]
 mod test {
     use super::{extract_messages, message};
-    use crate::protocol::parser::HWProtocolError;
-    use crate::protocol::{messages::HWProtocolMessage::*, test::gen_proto_msg};
+    use crate::protocol::parser::HwProtocolError;
+    use crate::protocol::{messages::HwProtocolMessage::*, test::gen_proto_msg};
     use proptest::{proptest, proptest_helper};
 
     #[cfg(test)]
@@ -616,7 +614,7 @@
 
         assert_eq!(
             message(b"QUIT\n1\n2\n\n"),
-            Err(nom::Err::Error(HWProtocolError::new()))
+            Err(nom::Err::Error(HwProtocolError::new()))
         );
 
         assert_eq!(
--- a/rust/hedgewars-server/src/protocol/test.rs	Tue May 28 19:04:18 2019 +0300
+++ b/rust/hedgewars-server/src/protocol/test.rs	Tue May 28 21:28:32 2019 +0300
@@ -6,7 +6,7 @@
 
 use crate::core::types::{GameCfg, HedgehogInfo, ServerVar, ServerVar::*, TeamInfo};
 
-use super::messages::{HWProtocolMessage, HWProtocolMessage::*};
+use super::messages::{HwProtocolMessage, HwProtocolMessage::*};
 
 // Due to inability to define From between Options
 trait Into2<T>: Sized {
@@ -166,7 +166,7 @@
     type Strategy = BoxedStrategy<ServerVar>;
 }
 
-pub fn gen_proto_msg() -> BoxedStrategy<HWProtocolMessage> where {
+pub fn gen_proto_msg() -> BoxedStrategy<HwProtocolMessage> where {
     let res = (0..=55).no_shrink().prop_flat_map(|i| {
         proto_msg_match!(i, def = Ping,
             0 => Ping(),
--- a/rust/hedgewars-server/src/server.rs	Tue May 28 19:04:18 2019 +0300
+++ b/rust/hedgewars-server/src/server.rs	Tue May 28 21:28:32 2019 +0300
@@ -2,4 +2,4 @@
 mod database;
 #[cfg(feature = "official-server")]
 pub mod io;
-pub mod network;
\ No newline at end of file
+pub mod network;
--- a/rust/hedgewars-server/src/server/database.rs	Tue May 28 19:04:18 2019 +0300
+++ b/rust/hedgewars-server/src/server/database.rs	Tue May 28 21:28:32 2019 +0300
@@ -2,9 +2,7 @@
 use mysql::{error::DriverError, error::Error, from_row_opt, params};
 use openssl::sha::sha1;
 
-use crate::{
-    handlers::{Sha1Digest, AccountInfo}
-};
+use crate::handlers::{AccountInfo, Sha1Digest};
 
 const GET_ACCOUNT_QUERY: &str =
     r"SELECT CASE WHEN users.status = 1 THEN users.pass ELSE '' END,
--- a/rust/hedgewars-server/src/server/io.rs	Tue May 28 19:04:18 2019 +0300
+++ b/rust/hedgewars-server/src/server/io.rs	Tue May 28 21:28:32 2019 +0300
@@ -6,8 +6,8 @@
 };
 
 use crate::{
+    handlers::{IoResult, IoTask},
     server::database::Database,
-    handlers::{IoResult, IoTask},
 };
 use log::*;
 use mio::{Evented, Poll, PollOpt};
--- a/rust/hedgewars-server/src/server/network.rs	Tue May 28 19:04:18 2019 +0300
+++ b/rust/hedgewars-server/src/server/network.rs	Tue May 28 21:28:32 2019 +0300
@@ -18,10 +18,7 @@
 use slab::Slab;
 
 use crate::{
-    core::{
-        server::HWServer,
-        types::ClientId
-    },
+    core::{server::HwServer, types::ClientId},
     handlers,
     protocol::{messages::*, ProtocolDecoder},
     utils,
@@ -31,8 +28,8 @@
 use super::io::{IOThread, RequestId};
 
 use crate::{
-    protocol::messages::HWServerMessage::Redirect,
-    handlers::{IoResult, IoTask}
+    handlers::{IoResult, IoTask},
+    protocol::messages::HwServerMessage::Redirect,
 };
 
 #[cfg(feature = "tls-connections")]
@@ -142,7 +139,7 @@
         source: &mut R,
         id: ClientId,
         addr: &SocketAddr,
-    ) -> NetworkResult<Vec<HWProtocolMessage>> {
+    ) -> NetworkResult<Vec<HwProtocolMessage>> {
         let mut bytes_read = 0;
         let result = loop {
             match decoder.read_from(source) {
@@ -175,7 +172,7 @@
         result
     }
 
-    pub fn read(&mut self) -> NetworkResult<Vec<HWProtocolMessage>> {
+    pub fn read(&mut self) -> NetworkResult<Vec<HwProtocolMessage>> {
         match self.socket {
             ClientSocket::Plain(ref mut stream) => {
                 NetworkClient::read_impl(&mut self.decoder, stream, self.id, &self.peer_addr)
@@ -309,7 +306,7 @@
 
 pub struct NetworkLayer {
     listener: TcpListener,
-    server: HWServer,
+    server: HwServer,
     clients: Slab<NetworkClient>,
     pending: HashSet<(ClientId, NetworkClientState)>,
     pending_cache: Vec<(ClientId, NetworkClientState)>,
@@ -435,7 +432,7 @@
             match event {
                 TimeoutEvent::SendPing { probes_count } => {
                     if let Some(ref mut client) = self.clients.get_mut(client_id) {
-                        client.send_string(&HWServerMessage::Ping.to_raw_protocol());
+                        client.send_string(&HwServerMessage::Ping.to_raw_protocol());
                         client.write()?;
                         let timeout = if probes_count != 0 {
                             create_ping_timeout(&mut self.timer, probes_count - 1, client_id)
@@ -684,7 +681,7 @@
     }
 
     pub fn build(self) -> NetworkLayer {
-        let server = HWServer::new(self.clients_capacity, self.rooms_capacity);
+        let server = HwServer::new(self.clients_capacity, self.rooms_capacity);
         let clients = Slab::with_capacity(self.clients_capacity);
         let pending = HashSet::with_capacity(2 * self.clients_capacity);
         let pending_cache = Vec::with_capacity(2 * self.clients_capacity);