rust/hedgewars-server/src/core/server.rs
author alfadur
Mon, 12 Feb 2024 21:26:35 +0300
changeset 16017 0b2e0a7d0431
parent 16015 cd8392e52165
child 16018 fb389df02e3e
permissions -rw-r--r--
fix server build
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
13416
cdf69667593b partial room implementation
alfadur
parents: 13119
diff changeset
     1
use super::{
15542
fd3a20e9d095 move the anteroom out of the server
alfadur <mail@none>
parents: 15541
diff changeset
     2
    anteroom::HwAnteroomClient,
15096
e935b1ad23f3 normalize type names
alfadur
parents: 15095
diff changeset
     3
    client::HwClient,
14714
6a2e13e36b7f add server anteroom
alfadur <mail@none>
parents: 14707
diff changeset
     4
    indexslab::IndexSlab,
15096
e935b1ad23f3 normalize type names
alfadur
parents: 15095
diff changeset
     5
    room::HwRoom,
15904
f185e7367dd3 Add some work towards having checker work with the new server
unC0Rr
parents: 15870
diff changeset
     6
    types::{CheckerId, ClientId, RoomId, Voting},
13416
cdf69667593b partial room implementation
alfadur
parents: 13119
diff changeset
     7
};
15555
0606f89698e7 check the room passwords
alfadur <mail@none>
parents: 15554
diff changeset
     8
use crate::utils;
15826
747278149393 Extract network protocol into a separate crate
unc0rr
parents: 15719
diff changeset
     9
use hedgewars_network_protocol::types::{GameCfg, ServerVar, TeamInfo, Vote, VoteType};
14714
6a2e13e36b7f add server anteroom
alfadur <mail@none>
parents: 14707
diff changeset
    10
15904
f185e7367dd3 Add some work towards having checker work with the new server
unC0Rr
parents: 15870
diff changeset
    11
use crate::server::replaystorage::ReplayStorage;
f185e7367dd3 Add some work towards having checker work with the new server
unC0Rr
parents: 15870
diff changeset
    12
14807
8ecdb5c6bb2a implement info, registered only & super power messages
alfadur
parents: 14804
diff changeset
    13
use bitflags::*;
13810
0463a4221327 cleanup crate imports
alfadur
parents: 13771
diff changeset
    14
use log::*;
16015
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
    15
use rand::{self, seq::SliceRandom, thread_rng, Rng};
15539
abd5eb807166 add ip ban check
alfadur <mail@none>
parents: 15538
diff changeset
    16
use slab::Slab;
15545
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
    17
use std::{borrow::BorrowMut, cmp::min, collections::HashSet, iter, mem::replace};
12126
4348997e502b Refactor code to add more structure to it
unc0rr
parents:
diff changeset
    18
15465
61a0bd0bb021 refactor root handler
alfadur
parents: 15463
diff changeset
    19
#[derive(Debug)]
15463
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
    20
pub enum CreateRoomError {
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
    21
    InvalidName,
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
    22
    AlreadyExists,
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
    23
}
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
    24
15465
61a0bd0bb021 refactor root handler
alfadur
parents: 15463
diff changeset
    25
#[derive(Debug)]
15463
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
    26
pub enum JoinRoomError {
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
    27
    DoesntExist,
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
    28
    WrongProtocol,
15555
0606f89698e7 check the room passwords
alfadur <mail@none>
parents: 15554
diff changeset
    29
    WrongPassword,
15463
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
    30
    Full,
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
    31
    Restricted,
15556
bb93e9642b5b send cleared flags on room join
alfadur <mail@none>
parents: 15555
diff changeset
    32
    RegistrationRequired,
15463
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
    33
}
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
    34
15540
e705d30e0f10 some more room handler cleanup
alfadur <mail@none>
parents: 15539
diff changeset
    35
#[derive(Debug)]
15504
4cc9ec732392 refactor some of the room handler
alfadur
parents: 15465
diff changeset
    36
pub enum LeaveRoomResult {
4cc9ec732392 refactor some of the room handler
alfadur
parents: 15465
diff changeset
    37
    RoomRemoved,
4cc9ec732392 refactor some of the room handler
alfadur
parents: 15465
diff changeset
    38
    RoomRemains {
4cc9ec732392 refactor some of the room handler
alfadur
parents: 15465
diff changeset
    39
        is_empty: bool,
4cc9ec732392 refactor some of the room handler
alfadur
parents: 15465
diff changeset
    40
        was_master: bool,
4cc9ec732392 refactor some of the room handler
alfadur
parents: 15465
diff changeset
    41
        was_in_game: bool,
4cc9ec732392 refactor some of the room handler
alfadur
parents: 15465
diff changeset
    42
        new_master: Option<ClientId>,
4cc9ec732392 refactor some of the room handler
alfadur
parents: 15465
diff changeset
    43
        removed_teams: Vec<String>,
4cc9ec732392 refactor some of the room handler
alfadur
parents: 15465
diff changeset
    44
    },
4cc9ec732392 refactor some of the room handler
alfadur
parents: 15465
diff changeset
    45
}
4cc9ec732392 refactor some of the room handler
alfadur
parents: 15465
diff changeset
    46
4cc9ec732392 refactor some of the room handler
alfadur
parents: 15465
diff changeset
    47
#[derive(Debug)]
15509
91f0c5ec37b5 move change_master into the server
alfadur
parents: 15504
diff changeset
    48
pub struct ChangeMasterResult {
91f0c5ec37b5 move change_master into the server
alfadur
parents: 15504
diff changeset
    49
    pub old_master_id: Option<ClientId>,
91f0c5ec37b5 move change_master into the server
alfadur
parents: 15504
diff changeset
    50
    pub new_master_id: ClientId,
91f0c5ec37b5 move change_master into the server
alfadur
parents: 15504
diff changeset
    51
}
91f0c5ec37b5 move change_master into the server
alfadur
parents: 15504
diff changeset
    52
91f0c5ec37b5 move change_master into the server
alfadur
parents: 15504
diff changeset
    53
#[derive(Debug)]
91f0c5ec37b5 move change_master into the server
alfadur
parents: 15504
diff changeset
    54
pub enum ChangeMasterError {
91f0c5ec37b5 move change_master into the server
alfadur
parents: 15504
diff changeset
    55
    NoAccess,
91f0c5ec37b5 move change_master into the server
alfadur
parents: 15504
diff changeset
    56
    AlreadyMaster,
91f0c5ec37b5 move change_master into the server
alfadur
parents: 15504
diff changeset
    57
    NoClient,
91f0c5ec37b5 move change_master into the server
alfadur
parents: 15504
diff changeset
    58
    ClientNotInRoom,
91f0c5ec37b5 move change_master into the server
alfadur
parents: 15504
diff changeset
    59
}
91f0c5ec37b5 move change_master into the server
alfadur
parents: 15504
diff changeset
    60
91f0c5ec37b5 move change_master into the server
alfadur
parents: 15504
diff changeset
    61
#[derive(Debug)]
15541
b3157d218ae2 disallow mutable clients to leave the server
alfadur <mail@none>
parents: 15540
diff changeset
    62
pub enum AddTeamError {
b3157d218ae2 disallow mutable clients to leave the server
alfadur <mail@none>
parents: 15540
diff changeset
    63
    TooManyTeams,
b3157d218ae2 disallow mutable clients to leave the server
alfadur <mail@none>
parents: 15540
diff changeset
    64
    TooManyHedgehogs,
b3157d218ae2 disallow mutable clients to leave the server
alfadur <mail@none>
parents: 15540
diff changeset
    65
    TeamAlreadyExists,
b3157d218ae2 disallow mutable clients to leave the server
alfadur <mail@none>
parents: 15540
diff changeset
    66
    Restricted,
b3157d218ae2 disallow mutable clients to leave the server
alfadur <mail@none>
parents: 15540
diff changeset
    67
}
b3157d218ae2 disallow mutable clients to leave the server
alfadur <mail@none>
parents: 15540
diff changeset
    68
b3157d218ae2 disallow mutable clients to leave the server
alfadur <mail@none>
parents: 15540
diff changeset
    69
#[derive(Debug)]
b3157d218ae2 disallow mutable clients to leave the server
alfadur <mail@none>
parents: 15540
diff changeset
    70
pub enum RemoveTeamError {
b3157d218ae2 disallow mutable clients to leave the server
alfadur <mail@none>
parents: 15540
diff changeset
    71
    NoTeam,
b3157d218ae2 disallow mutable clients to leave the server
alfadur <mail@none>
parents: 15540
diff changeset
    72
    TeamNotOwned,
b3157d218ae2 disallow mutable clients to leave the server
alfadur <mail@none>
parents: 15540
diff changeset
    73
}
b3157d218ae2 disallow mutable clients to leave the server
alfadur <mail@none>
parents: 15540
diff changeset
    74
b3157d218ae2 disallow mutable clients to leave the server
alfadur <mail@none>
parents: 15540
diff changeset
    75
#[derive(Debug)]
15540
e705d30e0f10 some more room handler cleanup
alfadur <mail@none>
parents: 15539
diff changeset
    76
pub enum ModifyTeamError {
e705d30e0f10 some more room handler cleanup
alfadur <mail@none>
parents: 15539
diff changeset
    77
    NoTeam,
e705d30e0f10 some more room handler cleanup
alfadur <mail@none>
parents: 15539
diff changeset
    78
    NotMaster,
e705d30e0f10 some more room handler cleanup
alfadur <mail@none>
parents: 15539
diff changeset
    79
}
e705d30e0f10 some more room handler cleanup
alfadur <mail@none>
parents: 15539
diff changeset
    80
e705d30e0f10 some more room handler cleanup
alfadur <mail@none>
parents: 15539
diff changeset
    81
#[derive(Debug)]
15545
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
    82
pub enum SetTeamCountError {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
    83
    InvalidNumber,
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
    84
    NotMaster,
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
    85
}
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
    86
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
    87
#[derive(Debug)]
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
    88
pub enum SetHedgehogsError {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
    89
    NoTeam,
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
    90
    InvalidNumber(u8),
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
    91
    NotMaster,
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
    92
}
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
    93
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
    94
#[derive(Debug)]
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
    95
pub enum SetConfigError {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
    96
    NotMaster,
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
    97
    RoomFixed,
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
    98
}
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
    99
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   100
#[derive(Debug)]
15540
e705d30e0f10 some more room handler cleanup
alfadur <mail@none>
parents: 15539
diff changeset
   101
pub enum ModifyRoomNameError {
e705d30e0f10 some more room handler cleanup
alfadur <mail@none>
parents: 15539
diff changeset
   102
    AccessDenied,
e705d30e0f10 some more room handler cleanup
alfadur <mail@none>
parents: 15539
diff changeset
   103
    InvalidName,
e705d30e0f10 some more room handler cleanup
alfadur <mail@none>
parents: 15539
diff changeset
   104
    DuplicateName,
e705d30e0f10 some more room handler cleanup
alfadur <mail@none>
parents: 15539
diff changeset
   105
}
e705d30e0f10 some more room handler cleanup
alfadur <mail@none>
parents: 15539
diff changeset
   106
e705d30e0f10 some more room handler cleanup
alfadur <mail@none>
parents: 15539
diff changeset
   107
#[derive(Debug)]
15547
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   108
pub enum StartVoteError {
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   109
    VotingInProgress,
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   110
}
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   111
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   112
#[derive(Debug)]
16015
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   113
pub enum VoteEffect {
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   114
    Kicked(ClientId, LeaveRoomResult),
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   115
    Map(String),
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   116
    Pause,
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   117
    NewSeed(GameCfg),
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   118
    HedgehogsPerTeam(u8, Vec<String>),
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   119
}
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   120
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   121
#[derive(Debug)]
15547
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   122
pub enum VoteResult {
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   123
    Submitted,
16015
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   124
    Succeeded(VoteEffect),
15547
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   125
    Failed,
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   126
}
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   127
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   128
#[derive(Debug)]
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   129
pub enum VoteError {
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   130
    NoVoting,
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   131
    AlreadyVoted,
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   132
}
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   133
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   134
#[derive(Debug)]
15514
395be40faa51 move start_game into the server
alfadur
parents: 15509
diff changeset
   135
pub enum StartGameError {
395be40faa51 move start_game into the server
alfadur
parents: 15509
diff changeset
   136
    NotEnoughClans,
395be40faa51 move start_game into the server
alfadur
parents: 15509
diff changeset
   137
    NotReady,
395be40faa51 move start_game into the server
alfadur
parents: 15509
diff changeset
   138
    AlreadyInGame,
395be40faa51 move start_game into the server
alfadur
parents: 15509
diff changeset
   139
}
395be40faa51 move start_game into the server
alfadur
parents: 15509
diff changeset
   140
395be40faa51 move start_game into the server
alfadur
parents: 15509
diff changeset
   141
#[derive(Debug)]
15538
b907b9071ec5 move end_game into server
alfadur
parents: 15514
diff changeset
   142
pub struct EndGameResult {
b907b9071ec5 move end_game into server
alfadur
parents: 15514
diff changeset
   143
    pub left_teams: Vec<String>,
b907b9071ec5 move end_game into server
alfadur
parents: 15514
diff changeset
   144
    pub unreadied_nicks: Vec<String>,
b907b9071ec5 move end_game into server
alfadur
parents: 15514
diff changeset
   145
}
b907b9071ec5 move end_game into server
alfadur
parents: 15514
diff changeset
   146
b907b9071ec5 move end_game into server
alfadur
parents: 15514
diff changeset
   147
#[derive(Debug)]
15465
61a0bd0bb021 refactor root handler
alfadur
parents: 15463
diff changeset
   148
pub struct UninitializedError();
61a0bd0bb021 refactor root handler
alfadur
parents: 15463
diff changeset
   149
#[derive(Debug)]
15463
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   150
pub struct AccessError();
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   151
14804
b3adc030104b implement server vars
alfadur
parents: 14802
diff changeset
   152
pub struct ServerGreetings {
b3adc030104b implement server vars
alfadur
parents: 14802
diff changeset
   153
    pub for_latest_protocol: String,
b3adc030104b implement server vars
alfadur
parents: 14802
diff changeset
   154
    pub for_old_protocols: String,
b3adc030104b implement server vars
alfadur
parents: 14802
diff changeset
   155
}
b3adc030104b implement server vars
alfadur
parents: 14802
diff changeset
   156
b3adc030104b implement server vars
alfadur
parents: 14802
diff changeset
   157
impl ServerGreetings {
b3adc030104b implement server vars
alfadur
parents: 14802
diff changeset
   158
    fn new() -> Self {
b3adc030104b implement server vars
alfadur
parents: 14802
diff changeset
   159
        Self {
b3adc030104b implement server vars
alfadur
parents: 14802
diff changeset
   160
            for_latest_protocol: "\u{1f994} is watching".to_string(),
b3adc030104b implement server vars
alfadur
parents: 14802
diff changeset
   161
            for_old_protocols: "\u{1f994} is watching".to_string(),
b3adc030104b implement server vars
alfadur
parents: 14802
diff changeset
   162
        }
b3adc030104b implement server vars
alfadur
parents: 14802
diff changeset
   163
    }
b3adc030104b implement server vars
alfadur
parents: 14802
diff changeset
   164
}
b3adc030104b implement server vars
alfadur
parents: 14802
diff changeset
   165
14807
8ecdb5c6bb2a implement info, registered only & super power messages
alfadur
parents: 14804
diff changeset
   166
bitflags! {
8ecdb5c6bb2a implement info, registered only & super power messages
alfadur
parents: 14804
diff changeset
   167
    pub struct ServerFlags: u8 {
8ecdb5c6bb2a implement info, registered only & super power messages
alfadur
parents: 14804
diff changeset
   168
        const REGISTERED_ONLY = 0b0000_1000;
8ecdb5c6bb2a implement info, registered only & super power messages
alfadur
parents: 14804
diff changeset
   169
    }
8ecdb5c6bb2a implement info, registered only & super power messages
alfadur
parents: 14804
diff changeset
   170
}
8ecdb5c6bb2a implement info, registered only & super power messages
alfadur
parents: 14804
diff changeset
   171
15904
f185e7367dd3 Add some work towards having checker work with the new server
unC0Rr
parents: 15870
diff changeset
   172
pub struct HwChecker {
15554
f1205f33bf5b complete checker login handling
alfadur <mail@none>
parents: 15553
diff changeset
   173
    pub id: ClientId,
f1205f33bf5b complete checker login handling
alfadur <mail@none>
parents: 15553
diff changeset
   174
    pub is_ready: bool,
f1205f33bf5b complete checker login handling
alfadur <mail@none>
parents: 15553
diff changeset
   175
}
f1205f33bf5b complete checker login handling
alfadur <mail@none>
parents: 15553
diff changeset
   176
f1205f33bf5b complete checker login handling
alfadur <mail@none>
parents: 15553
diff changeset
   177
impl HwChecker {
f1205f33bf5b complete checker login handling
alfadur <mail@none>
parents: 15553
diff changeset
   178
    pub fn new(id: ClientId) -> Self {
f1205f33bf5b complete checker login handling
alfadur <mail@none>
parents: 15553
diff changeset
   179
        Self {
f1205f33bf5b complete checker login handling
alfadur <mail@none>
parents: 15553
diff changeset
   180
            id,
f1205f33bf5b complete checker login handling
alfadur <mail@none>
parents: 15553
diff changeset
   181
            is_ready: false,
f1205f33bf5b complete checker login handling
alfadur <mail@none>
parents: 15553
diff changeset
   182
        }
f1205f33bf5b complete checker login handling
alfadur <mail@none>
parents: 15553
diff changeset
   183
    }
15904
f185e7367dd3 Add some work towards having checker work with the new server
unC0Rr
parents: 15870
diff changeset
   184
f185e7367dd3 Add some work towards having checker work with the new server
unC0Rr
parents: 15870
diff changeset
   185
    pub fn set_is_ready(&mut self, ready: bool) {
f185e7367dd3 Add some work towards having checker work with the new server
unC0Rr
parents: 15870
diff changeset
   186
        self.is_ready = ready
f185e7367dd3 Add some work towards having checker work with the new server
unC0Rr
parents: 15870
diff changeset
   187
    }
15554
f1205f33bf5b complete checker login handling
alfadur <mail@none>
parents: 15553
diff changeset
   188
}
f1205f33bf5b complete checker login handling
alfadur <mail@none>
parents: 15553
diff changeset
   189
15096
e935b1ad23f3 normalize type names
alfadur
parents: 15095
diff changeset
   190
pub struct HwServer {
15542
fd3a20e9d095 move the anteroom out of the server
alfadur <mail@none>
parents: 15541
diff changeset
   191
    clients: IndexSlab<HwClient>,
15544
4a0b06b03199 make rooms field private
alfadur <mail@none>
parents: 15542
diff changeset
   192
    rooms: Slab<HwRoom>,
15554
f1205f33bf5b complete checker login handling
alfadur <mail@none>
parents: 15553
diff changeset
   193
    checkers: IndexSlab<HwChecker>,
15548
24f692e791d3 disallow mutable rooms outside the server
alfadur <mail@none>
parents: 15547
diff changeset
   194
    latest_protocol: u16,
24f692e791d3 disallow mutable rooms outside the server
alfadur <mail@none>
parents: 15547
diff changeset
   195
    flags: ServerFlags,
24f692e791d3 disallow mutable rooms outside the server
alfadur <mail@none>
parents: 15547
diff changeset
   196
    greetings: ServerGreetings,
15904
f185e7367dd3 Add some work towards having checker work with the new server
unC0Rr
parents: 15870
diff changeset
   197
    replay_storage: Option<ReplayStorage>,
12126
4348997e502b Refactor code to add more structure to it
unc0rr
parents:
diff changeset
   198
}
4348997e502b Refactor code to add more structure to it
unc0rr
parents:
diff changeset
   199
15096
e935b1ad23f3 normalize type names
alfadur
parents: 15095
diff changeset
   200
impl HwServer {
14801
65861ba8b4e8 move room saves to IO thread
alfadur
parents: 14800
diff changeset
   201
    pub fn new(clients_limit: usize, rooms_limit: usize) -> Self {
15968
ce47259d5c86 add some server todos
alfadur
parents: 15904
diff changeset
   202
        todo!("add reconnection IDs");
13119
1e39b8749072 separated the server logic from all the async io mess.
alfadur
parents: 12852
diff changeset
   203
        let rooms = Slab::with_capacity(rooms_limit);
14714
6a2e13e36b7f add server anteroom
alfadur <mail@none>
parents: 14707
diff changeset
   204
        let clients = IndexSlab::with_capacity(clients_limit);
15554
f1205f33bf5b complete checker login handling
alfadur <mail@none>
parents: 15553
diff changeset
   205
        let checkers = IndexSlab::new();
14715
25c564f77b7d remove lobby room
alfadur <mail@none>
parents: 14714
diff changeset
   206
        Self {
14478
98ef2913ec73 Apply rustfmt to all files
unc0rr
parents: 14436
diff changeset
   207
            clients,
98ef2913ec73 Apply rustfmt to all files
unc0rr
parents: 14436
diff changeset
   208
            rooms,
15554
f1205f33bf5b complete checker login handling
alfadur <mail@none>
parents: 15553
diff changeset
   209
            checkers,
14804
b3adc030104b implement server vars
alfadur
parents: 14802
diff changeset
   210
            greetings: ServerGreetings::new(),
b3adc030104b implement server vars
alfadur
parents: 14802
diff changeset
   211
            latest_protocol: 58,
14807
8ecdb5c6bb2a implement info, registered only & super power messages
alfadur
parents: 14804
diff changeset
   212
            flags: ServerFlags::empty(),
15904
f185e7367dd3 Add some work towards having checker work with the new server
unC0Rr
parents: 15870
diff changeset
   213
            replay_storage: None,
14715
25c564f77b7d remove lobby room
alfadur <mail@none>
parents: 14714
diff changeset
   214
        }
12126
4348997e502b Refactor code to add more structure to it
unc0rr
parents:
diff changeset
   215
    }
4348997e502b Refactor code to add more structure to it
unc0rr
parents:
diff changeset
   216
15465
61a0bd0bb021 refactor root handler
alfadur
parents: 15463
diff changeset
   217
    #[inline]
61a0bd0bb021 refactor root handler
alfadur
parents: 15463
diff changeset
   218
    pub fn client(&self, client_id: ClientId) -> &HwClient {
61a0bd0bb021 refactor root handler
alfadur
parents: 15463
diff changeset
   219
        &self.clients[client_id]
61a0bd0bb021 refactor root handler
alfadur
parents: 15463
diff changeset
   220
    }
61a0bd0bb021 refactor root handler
alfadur
parents: 15463
diff changeset
   221
61a0bd0bb021 refactor root handler
alfadur
parents: 15463
diff changeset
   222
    #[inline]
15904
f185e7367dd3 Add some work towards having checker work with the new server
unC0Rr
parents: 15870
diff changeset
   223
    pub fn get_checker_mut(&mut self, checker_id: CheckerId) -> Option<&mut HwChecker> {
f185e7367dd3 Add some work towards having checker work with the new server
unC0Rr
parents: 15870
diff changeset
   224
        self.checkers.get_mut(checker_id)
f185e7367dd3 Add some work towards having checker work with the new server
unC0Rr
parents: 15870
diff changeset
   225
    }
f185e7367dd3 Add some work towards having checker work with the new server
unC0Rr
parents: 15870
diff changeset
   226
f185e7367dd3 Add some work towards having checker work with the new server
unC0Rr
parents: 15870
diff changeset
   227
    #[inline]
15541
b3157d218ae2 disallow mutable clients to leave the server
alfadur <mail@none>
parents: 15540
diff changeset
   228
    pub fn has_client(&self, client_id: ClientId) -> bool {
b3157d218ae2 disallow mutable clients to leave the server
alfadur <mail@none>
parents: 15540
diff changeset
   229
        self.clients.contains(client_id)
b3157d218ae2 disallow mutable clients to leave the server
alfadur <mail@none>
parents: 15540
diff changeset
   230
    }
b3157d218ae2 disallow mutable clients to leave the server
alfadur <mail@none>
parents: 15540
diff changeset
   231
b3157d218ae2 disallow mutable clients to leave the server
alfadur <mail@none>
parents: 15540
diff changeset
   232
    #[inline]
15556
bb93e9642b5b send cleared flags on room join
alfadur <mail@none>
parents: 15555
diff changeset
   233
    pub fn iter_clients(&self) -> impl Iterator<Item = &HwClient> + Clone {
15541
b3157d218ae2 disallow mutable clients to leave the server
alfadur <mail@none>
parents: 15540
diff changeset
   234
        self.clients.iter().map(|(_, c)| c)
b3157d218ae2 disallow mutable clients to leave the server
alfadur <mail@none>
parents: 15540
diff changeset
   235
    }
b3157d218ae2 disallow mutable clients to leave the server
alfadur <mail@none>
parents: 15540
diff changeset
   236
b3157d218ae2 disallow mutable clients to leave the server
alfadur <mail@none>
parents: 15540
diff changeset
   237
    #[inline]
15465
61a0bd0bb021 refactor root handler
alfadur
parents: 15463
diff changeset
   238
    pub fn room(&self, room_id: RoomId) -> &HwRoom {
61a0bd0bb021 refactor root handler
alfadur
parents: 15463
diff changeset
   239
        &self.rooms[room_id]
61a0bd0bb021 refactor root handler
alfadur
parents: 15463
diff changeset
   240
    }
61a0bd0bb021 refactor root handler
alfadur
parents: 15463
diff changeset
   241
61a0bd0bb021 refactor root handler
alfadur
parents: 15463
diff changeset
   242
    #[inline]
15544
4a0b06b03199 make rooms field private
alfadur <mail@none>
parents: 15542
diff changeset
   243
    pub fn get_room(&self, room_id: RoomId) -> Option<&HwRoom> {
4a0b06b03199 make rooms field private
alfadur <mail@none>
parents: 15542
diff changeset
   244
        self.rooms.get(room_id)
4a0b06b03199 make rooms field private
alfadur <mail@none>
parents: 15542
diff changeset
   245
    }
4a0b06b03199 make rooms field private
alfadur <mail@none>
parents: 15542
diff changeset
   246
4a0b06b03199 make rooms field private
alfadur <mail@none>
parents: 15542
diff changeset
   247
    #[inline]
15548
24f692e791d3 disallow mutable rooms outside the server
alfadur <mail@none>
parents: 15547
diff changeset
   248
    fn get_room_mut(&mut self, room_id: RoomId) -> Option<&mut HwRoom> {
15544
4a0b06b03199 make rooms field private
alfadur <mail@none>
parents: 15542
diff changeset
   249
        self.rooms.get_mut(room_id)
4a0b06b03199 make rooms field private
alfadur <mail@none>
parents: 15542
diff changeset
   250
    }
4a0b06b03199 make rooms field private
alfadur <mail@none>
parents: 15542
diff changeset
   251
4a0b06b03199 make rooms field private
alfadur <mail@none>
parents: 15542
diff changeset
   252
    #[inline]
4a0b06b03199 make rooms field private
alfadur <mail@none>
parents: 15542
diff changeset
   253
    pub fn iter_rooms(&self) -> impl Iterator<Item = &HwRoom> {
4a0b06b03199 make rooms field private
alfadur <mail@none>
parents: 15542
diff changeset
   254
        self.rooms.iter().map(|(_, r)| r)
4a0b06b03199 make rooms field private
alfadur <mail@none>
parents: 15542
diff changeset
   255
    }
4a0b06b03199 make rooms field private
alfadur <mail@none>
parents: 15542
diff changeset
   256
4a0b06b03199 make rooms field private
alfadur <mail@none>
parents: 15542
diff changeset
   257
    #[inline]
15504
4cc9ec732392 refactor some of the room handler
alfadur
parents: 15465
diff changeset
   258
    pub fn client_and_room(&self, client_id: ClientId, room_id: RoomId) -> (&HwClient, &HwRoom) {
4cc9ec732392 refactor some of the room handler
alfadur
parents: 15465
diff changeset
   259
        (&self.clients[client_id], &self.rooms[room_id])
4cc9ec732392 refactor some of the room handler
alfadur
parents: 15465
diff changeset
   260
    }
4cc9ec732392 refactor some of the room handler
alfadur
parents: 15465
diff changeset
   261
4cc9ec732392 refactor some of the room handler
alfadur
parents: 15465
diff changeset
   262
    #[inline]
15545
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   263
    fn client_and_room_mut(&mut self, client_id: ClientId) -> Option<(&mut HwClient, &mut HwRoom)> {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   264
        let client = &mut self.clients[client_id];
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   265
        if let Some(room_id) = client.room_id {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   266
            Some((client, &mut self.rooms[room_id]))
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   267
        } else {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   268
            None
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   269
        }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   270
    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   271
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   272
    #[inline]
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   273
    pub fn get_room_control(&mut self, client_id: ClientId) -> Option<HwRoomControl> {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   274
        HwRoomControl::new(self, client_id)
15504
4cc9ec732392 refactor some of the room handler
alfadur
parents: 15465
diff changeset
   275
    }
4cc9ec732392 refactor some of the room handler
alfadur
parents: 15465
diff changeset
   276
4cc9ec732392 refactor some of the room handler
alfadur
parents: 15465
diff changeset
   277
    #[inline]
15465
61a0bd0bb021 refactor root handler
alfadur
parents: 15463
diff changeset
   278
    pub fn is_admin(&self, client_id: ClientId) -> bool {
61a0bd0bb021 refactor root handler
alfadur
parents: 15463
diff changeset
   279
        self.clients
61a0bd0bb021 refactor root handler
alfadur
parents: 15463
diff changeset
   280
            .get(client_id)
61a0bd0bb021 refactor root handler
alfadur
parents: 15463
diff changeset
   281
            .map(|c| c.is_admin())
61a0bd0bb021 refactor root handler
alfadur
parents: 15463
diff changeset
   282
            .unwrap_or(false)
61a0bd0bb021 refactor root handler
alfadur
parents: 15463
diff changeset
   283
    }
61a0bd0bb021 refactor root handler
alfadur
parents: 15463
diff changeset
   284
15870
3d05bada4799 Implement appropriate routing of checker messages
unC0Rr
parents: 15826
diff changeset
   285
    #[inline]
3d05bada4799 Implement appropriate routing of checker messages
unC0Rr
parents: 15826
diff changeset
   286
    pub fn is_checker(&self, client_id: ClientId) -> bool {
3d05bada4799 Implement appropriate routing of checker messages
unC0Rr
parents: 15826
diff changeset
   287
        self.checkers.contains(client_id)
3d05bada4799 Implement appropriate routing of checker messages
unC0Rr
parents: 15826
diff changeset
   288
    }
3d05bada4799 Implement appropriate routing of checker messages
unC0Rr
parents: 15826
diff changeset
   289
15542
fd3a20e9d095 move the anteroom out of the server
alfadur <mail@none>
parents: 15541
diff changeset
   290
    pub fn add_client(&mut self, client_id: ClientId, data: HwAnteroomClient) {
15554
f1205f33bf5b complete checker login handling
alfadur <mail@none>
parents: 15553
diff changeset
   291
        if data.is_checker {
f1205f33bf5b complete checker login handling
alfadur <mail@none>
parents: 15553
diff changeset
   292
            self.checkers.insert(client_id, HwChecker::new(client_id));
f1205f33bf5b complete checker login handling
alfadur <mail@none>
parents: 15553
diff changeset
   293
        } else if let (Some(protocol), Some(nick)) = (data.protocol_number, data.nick) {
15096
e935b1ad23f3 normalize type names
alfadur
parents: 15095
diff changeset
   294
            let mut client = HwClient::new(client_id, protocol.get(), nick);
15197
f6115638aa92 enable local admins for non-official servers
alfadur
parents: 15096
diff changeset
   295
            #[cfg(not(feature = "official-server"))]
f6115638aa92 enable local admins for non-official servers
alfadur
parents: 15096
diff changeset
   296
            client.set_is_admin(data.is_local_admin);
f6115638aa92 enable local admins for non-official servers
alfadur
parents: 15096
diff changeset
   297
15465
61a0bd0bb021 refactor root handler
alfadur
parents: 15463
diff changeset
   298
            #[cfg(feature = "official-server")]
61a0bd0bb021 refactor root handler
alfadur
parents: 15463
diff changeset
   299
            {
15553
ede5f4ec48f3 fix official server
alfadur <mail@none>
parents: 15551
diff changeset
   300
                client.set_is_registered(data.is_registered);
ede5f4ec48f3 fix official server
alfadur <mail@none>
parents: 15551
diff changeset
   301
                client.set_is_admin(data.is_admin);
ede5f4ec48f3 fix official server
alfadur <mail@none>
parents: 15551
diff changeset
   302
                client.set_is_contributor(data.is_contributor);
15465
61a0bd0bb021 refactor root handler
alfadur
parents: 15463
diff changeset
   303
            }
61a0bd0bb021 refactor root handler
alfadur
parents: 15463
diff changeset
   304
14714
6a2e13e36b7f add server anteroom
alfadur <mail@none>
parents: 14707
diff changeset
   305
            self.clients.insert(client_id, client);
13119
1e39b8749072 separated the server logic from all the async io mess.
alfadur
parents: 12852
diff changeset
   306
        }
12126
4348997e502b Refactor code to add more structure to it
unc0rr
parents:
diff changeset
   307
    }
12127
36ac9c075d0d - Use netbuf buffers for client connection stream
unc0rr
parents: 12126
diff changeset
   308
14694
08a8605bafaf Server action refactoring part 4 of N
alfadur <mail@none>
parents: 14693
diff changeset
   309
    pub fn remove_client(&mut self, client_id: ClientId) {
14717
8a45c90f4580 fix client removal
alfadur
parents: 14716
diff changeset
   310
        self.clients.remove(client_id);
12127
36ac9c075d0d - Use netbuf buffers for client connection stream
unc0rr
parents: 12126
diff changeset
   311
    }
36ac9c075d0d - Use netbuf buffers for client connection stream
unc0rr
parents: 12126
diff changeset
   312
15465
61a0bd0bb021 refactor root handler
alfadur
parents: 15463
diff changeset
   313
    pub fn get_greetings(&self, client: &HwClient) -> &str {
61a0bd0bb021 refactor root handler
alfadur
parents: 15463
diff changeset
   314
        if client.protocol_number < self.latest_protocol {
14804
b3adc030104b implement server vars
alfadur
parents: 14802
diff changeset
   315
            &self.greetings.for_old_protocols
b3adc030104b implement server vars
alfadur
parents: 14802
diff changeset
   316
        } else {
b3adc030104b implement server vars
alfadur
parents: 14802
diff changeset
   317
            &self.greetings.for_latest_protocol
b3adc030104b implement server vars
alfadur
parents: 14802
diff changeset
   318
        }
b3adc030104b implement server vars
alfadur
parents: 14802
diff changeset
   319
    }
b3adc030104b implement server vars
alfadur
parents: 14802
diff changeset
   320
14525
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
   321
    #[inline]
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
   322
    pub fn create_room(
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
   323
        &mut self,
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
   324
        creator_id: ClientId,
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
   325
        name: String,
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
   326
        password: Option<String>,
15463
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   327
    ) -> Result<(&HwClient, &HwRoom), CreateRoomError> {
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   328
        use CreateRoomError::*;
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   329
        if utils::is_name_illegal(&name) {
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   330
            Err(InvalidName)
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   331
        } else if self.has_room(&name) {
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   332
            Err(AlreadyExists)
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   333
        } else {
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   334
            Ok(create_room(
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   335
                &mut self.clients[creator_id],
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   336
                &mut self.rooms,
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   337
                name,
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   338
                password,
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   339
            ))
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   340
        }
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   341
    }
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   342
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   343
    pub fn join_room(
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   344
        &mut self,
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   345
        client_id: ClientId,
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   346
        room_id: RoomId,
15555
0606f89698e7 check the room passwords
alfadur <mail@none>
parents: 15554
diff changeset
   347
        room_password: Option<&str>,
15463
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   348
    ) -> Result<(&HwClient, &HwRoom, impl Iterator<Item = &HwClient> + Clone), JoinRoomError> {
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   349
        use JoinRoomError::*;
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   350
        let room = &mut self.rooms[room_id];
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   351
        let client = &mut self.clients[client_id];
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   352
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   353
        if client.protocol_number != room.protocol_number {
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   354
            Err(WrongProtocol)
15556
bb93e9642b5b send cleared flags on room join
alfadur <mail@none>
parents: 15555
diff changeset
   355
        } else if room.password.is_some()
bb93e9642b5b send cleared flags on room join
alfadur <mail@none>
parents: 15555
diff changeset
   356
            && room_password != room.password.as_deref()
bb93e9642b5b send cleared flags on room join
alfadur <mail@none>
parents: 15555
diff changeset
   357
            && !client.has_super_power()
bb93e9642b5b send cleared flags on room join
alfadur <mail@none>
parents: 15555
diff changeset
   358
        {
15555
0606f89698e7 check the room passwords
alfadur <mail@none>
parents: 15554
diff changeset
   359
            Err(WrongPassword)
15463
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   360
        } else if room.is_join_restricted() {
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   361
            Err(Restricted)
15556
bb93e9642b5b send cleared flags on room join
alfadur <mail@none>
parents: 15555
diff changeset
   362
        } else if room.is_registration_required() {
bb93e9642b5b send cleared flags on room join
alfadur <mail@none>
parents: 15555
diff changeset
   363
            Err(RegistrationRequired)
15463
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   364
        } else if room.players_number == u8::max_value() {
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   365
            Err(Full)
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   366
        } else {
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   367
            move_to_room(client, room);
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   368
            let room_id = room.id;
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   369
            Ok((
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   370
                &self.clients[client_id],
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   371
                &self.rooms[room_id],
15556
bb93e9642b5b send cleared flags on room join
alfadur <mail@none>
parents: 15555
diff changeset
   372
                self.iter_clients()
bb93e9642b5b send cleared flags on room join
alfadur <mail@none>
parents: 15555
diff changeset
   373
                    .filter(move |c| c.room_id == Some(room_id)),
15463
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   374
            ))
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   375
        }
14525
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
   376
    }
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
   377
14692
455865ccd36c Server action refactoring part 2 of N
alfadur <mail@none>
parents: 14525
diff changeset
   378
    #[inline]
15463
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   379
    pub fn join_room_by_name(
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   380
        &mut self,
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   381
        client_id: ClientId,
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   382
        room_name: &str,
15555
0606f89698e7 check the room passwords
alfadur <mail@none>
parents: 15554
diff changeset
   383
        room_password: Option<&str>,
15463
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   384
    ) -> Result<(&HwClient, &HwRoom, impl Iterator<Item = &HwClient> + Clone), JoinRoomError> {
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   385
        use JoinRoomError::*;
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   386
        let room = self.rooms.iter().find(|(_, r)| r.name == room_name);
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   387
        if let Some((_, room)) = room {
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   388
            let room_id = room.id;
15555
0606f89698e7 check the room passwords
alfadur <mail@none>
parents: 15554
diff changeset
   389
            self.join_room(client_id, room_id, room_password)
15463
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   390
        } else {
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   391
            Err(DoesntExist)
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   392
        }
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   393
    }
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   394
15540
e705d30e0f10 some more room handler cleanup
alfadur <mail@none>
parents: 15539
diff changeset
   395
    pub fn enable_super_power(&mut self, client_id: ClientId) -> bool {
e705d30e0f10 some more room handler cleanup
alfadur <mail@none>
parents: 15539
diff changeset
   396
        let client = &mut self.clients[client_id];
e705d30e0f10 some more room handler cleanup
alfadur <mail@none>
parents: 15539
diff changeset
   397
        if client.is_admin() {
e705d30e0f10 some more room handler cleanup
alfadur <mail@none>
parents: 15539
diff changeset
   398
            client.set_has_super_power(true);
e705d30e0f10 some more room handler cleanup
alfadur <mail@none>
parents: 15539
diff changeset
   399
        }
e705d30e0f10 some more room handler cleanup
alfadur <mail@none>
parents: 15539
diff changeset
   400
        client.is_admin()
e705d30e0f10 some more room handler cleanup
alfadur <mail@none>
parents: 15539
diff changeset
   401
    }
e705d30e0f10 some more room handler cleanup
alfadur <mail@none>
parents: 15539
diff changeset
   402
15463
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   403
    #[inline]
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   404
    pub fn set_var(&mut self, client_id: ClientId, var: ServerVar) -> Result<(), AccessError> {
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   405
        if self.clients[client_id].is_admin() {
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   406
            match var {
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   407
                ServerVar::MOTDNew(msg) => self.greetings.for_latest_protocol = msg,
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   408
                ServerVar::MOTDOld(msg) => self.greetings.for_old_protocols = msg,
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   409
                ServerVar::LatestProto(n) => self.latest_protocol = n,
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   410
            }
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   411
            Ok(())
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   412
        } else {
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   413
            Err(AccessError())
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   414
        }
14692
455865ccd36c Server action refactoring part 2 of N
alfadur <mail@none>
parents: 14525
diff changeset
   415
    }
455865ccd36c Server action refactoring part 2 of N
alfadur <mail@none>
parents: 14525
diff changeset
   416
15463
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   417
    #[inline]
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   418
    pub fn get_vars(&self, client_id: ClientId) -> Result<[ServerVar; 3], AccessError> {
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   419
        if self.clients[client_id].is_admin() {
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   420
            Ok([
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   421
                ServerVar::MOTDNew(self.greetings.for_latest_protocol.clone()),
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   422
                ServerVar::MOTDOld(self.greetings.for_old_protocols.clone()),
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   423
                ServerVar::LatestProto(self.latest_protocol),
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   424
            ])
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   425
        } else {
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   426
            Err(AccessError())
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   427
        }
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   428
    }
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   429
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   430
    pub fn get_used_protocols(&self, client_id: ClientId) -> Result<Vec<u16>, AccessError> {
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   431
        if self.clients[client_id].is_admin() {
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   432
            let mut protocols: HashSet<_> = self
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   433
                .clients
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   434
                .iter()
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   435
                .map(|(_, c)| c.protocol_number)
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   436
                .chain(self.rooms.iter().map(|(_, r)| r.protocol_number))
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   437
                .collect();
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   438
            let mut protocols: Vec<_> = protocols.drain().collect();
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   439
            protocols.sort();
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   440
            Ok(protocols)
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   441
        } else {
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   442
            Err(AccessError())
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   443
        }
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   444
    }
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   445
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   446
    #[inline]
13416
cdf69667593b partial room implementation
alfadur
parents: 13119
diff changeset
   447
    pub fn has_room(&self, name: &str) -> bool {
14718
f64e21f164a5 fix some warnings
alfadur
parents: 14717
diff changeset
   448
        self.find_room(name).is_some()
13416
cdf69667593b partial room implementation
alfadur
parents: 13119
diff changeset
   449
    }
cdf69667593b partial room implementation
alfadur
parents: 13119
diff changeset
   450
15463
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
   451
    #[inline]
15096
e935b1ad23f3 normalize type names
alfadur
parents: 15095
diff changeset
   452
    pub fn find_room(&self, name: &str) -> Option<&HwRoom> {
14478
98ef2913ec73 Apply rustfmt to all files
unc0rr
parents: 14436
diff changeset
   453
        self.rooms
98ef2913ec73 Apply rustfmt to all files
unc0rr
parents: 14436
diff changeset
   454
            .iter()
98ef2913ec73 Apply rustfmt to all files
unc0rr
parents: 14436
diff changeset
   455
            .find_map(|(_, r)| Some(r).filter(|r| r.name == name))
13416
cdf69667593b partial room implementation
alfadur
parents: 13119
diff changeset
   456
    }
cdf69667593b partial room implementation
alfadur
parents: 13119
diff changeset
   457
15548
24f692e791d3 disallow mutable rooms outside the server
alfadur <mail@none>
parents: 15547
diff changeset
   458
    fn find_room_mut(&mut self, name: &str) -> Option<&mut HwRoom> {
14478
98ef2913ec73 Apply rustfmt to all files
unc0rr
parents: 14436
diff changeset
   459
        self.rooms
98ef2913ec73 Apply rustfmt to all files
unc0rr
parents: 14436
diff changeset
   460
            .iter_mut()
98ef2913ec73 Apply rustfmt to all files
unc0rr
parents: 14436
diff changeset
   461
            .find_map(|(_, r)| Some(r).filter(|r| r.name == name))
13416
cdf69667593b partial room implementation
alfadur
parents: 13119
diff changeset
   462
    }
cdf69667593b partial room implementation
alfadur
parents: 13119
diff changeset
   463
15096
e935b1ad23f3 normalize type names
alfadur
parents: 15095
diff changeset
   464
    pub fn find_client(&self, nick: &str) -> Option<&HwClient> {
14478
98ef2913ec73 Apply rustfmt to all files
unc0rr
parents: 14436
diff changeset
   465
        self.clients
98ef2913ec73 Apply rustfmt to all files
unc0rr
parents: 14436
diff changeset
   466
            .iter()
98ef2913ec73 Apply rustfmt to all files
unc0rr
parents: 14436
diff changeset
   467
            .find_map(|(_, c)| Some(c).filter(|c| c.nick == nick))
13450
d79795acaa73 Mostly implement voting
alfadur
parents: 13445
diff changeset
   468
    }
d79795acaa73 Mostly implement voting
alfadur
parents: 13445
diff changeset
   469
15548
24f692e791d3 disallow mutable rooms outside the server
alfadur <mail@none>
parents: 15547
diff changeset
   470
    fn find_client_mut(&mut self, nick: &str) -> Option<&mut HwClient> {
14478
98ef2913ec73 Apply rustfmt to all files
unc0rr
parents: 14436
diff changeset
   471
        self.clients
98ef2913ec73 Apply rustfmt to all files
unc0rr
parents: 14436
diff changeset
   472
            .iter_mut()
98ef2913ec73 Apply rustfmt to all files
unc0rr
parents: 14436
diff changeset
   473
            .find_map(|(_, c)| Some(c).filter(|c| c.nick == nick))
13450
d79795acaa73 Mostly implement voting
alfadur
parents: 13445
diff changeset
   474
    }
d79795acaa73 Mostly implement voting
alfadur
parents: 13445
diff changeset
   475
15548
24f692e791d3 disallow mutable rooms outside the server
alfadur <mail@none>
parents: 15547
diff changeset
   476
    pub fn iter_client_ids(&self) -> impl Iterator<Item = ClientId> + '_ {
14810
18240b308505 implement stats message
alfadur
parents: 14807
diff changeset
   477
        self.clients.iter().map(|(id, _)| id)
18240b308505 implement stats message
alfadur
parents: 14807
diff changeset
   478
    }
18240b308505 implement stats message
alfadur
parents: 14807
diff changeset
   479
18240b308505 implement stats message
alfadur
parents: 14807
diff changeset
   480
    pub fn filter_clients<'a, F>(&'a self, f: F) -> impl Iterator<Item = ClientId> + 'a
18240b308505 implement stats message
alfadur
parents: 14807
diff changeset
   481
    where
15096
e935b1ad23f3 normalize type names
alfadur
parents: 15095
diff changeset
   482
        F: Fn(&(usize, &HwClient)) -> bool + 'a,
14810
18240b308505 implement stats message
alfadur
parents: 14807
diff changeset
   483
    {
18240b308505 implement stats message
alfadur
parents: 14807
diff changeset
   484
        self.clients.iter().filter(f).map(|(_, c)| c.id)
18240b308505 implement stats message
alfadur
parents: 14807
diff changeset
   485
    }
18240b308505 implement stats message
alfadur
parents: 14807
diff changeset
   486
18240b308505 implement stats message
alfadur
parents: 14807
diff changeset
   487
    pub fn filter_rooms<'a, F>(&'a self, f: F) -> impl Iterator<Item = RoomId> + 'a
18240b308505 implement stats message
alfadur
parents: 14807
diff changeset
   488
    where
15096
e935b1ad23f3 normalize type names
alfadur
parents: 15095
diff changeset
   489
        F: Fn(&(usize, &HwRoom)) -> bool + 'a,
14810
18240b308505 implement stats message
alfadur
parents: 14807
diff changeset
   490
    {
18240b308505 implement stats message
alfadur
parents: 14807
diff changeset
   491
        self.rooms.iter().filter(f).map(|(_, c)| c.id)
18240b308505 implement stats message
alfadur
parents: 14807
diff changeset
   492
    }
18240b308505 implement stats message
alfadur
parents: 14807
diff changeset
   493
15548
24f692e791d3 disallow mutable rooms outside the server
alfadur <mail@none>
parents: 15547
diff changeset
   494
    pub fn collect_client_ids<F>(&self, f: F) -> Vec<ClientId>
14478
98ef2913ec73 Apply rustfmt to all files
unc0rr
parents: 14436
diff changeset
   495
    where
15096
e935b1ad23f3 normalize type names
alfadur
parents: 15095
diff changeset
   496
        F: Fn(&(usize, &HwClient)) -> bool,
14478
98ef2913ec73 Apply rustfmt to all files
unc0rr
parents: 14436
diff changeset
   497
    {
14810
18240b308505 implement stats message
alfadur
parents: 14807
diff changeset
   498
        self.filter_clients(f).collect()
13416
cdf69667593b partial room implementation
alfadur
parents: 13119
diff changeset
   499
    }
cdf69667593b partial room implementation
alfadur
parents: 13119
diff changeset
   500
14802
01f8ab45f806 fix lobby joining
alfadur
parents: 14801
diff changeset
   501
    pub fn collect_nicks<F>(&self, f: F) -> Vec<String>
01f8ab45f806 fix lobby joining
alfadur
parents: 14801
diff changeset
   502
    where
15096
e935b1ad23f3 normalize type names
alfadur
parents: 15095
diff changeset
   503
        F: Fn(&(usize, &HwClient)) -> bool,
14802
01f8ab45f806 fix lobby joining
alfadur
parents: 14801
diff changeset
   504
    {
01f8ab45f806 fix lobby joining
alfadur
parents: 14801
diff changeset
   505
        self.clients
01f8ab45f806 fix lobby joining
alfadur
parents: 14801
diff changeset
   506
            .iter()
01f8ab45f806 fix lobby joining
alfadur
parents: 14801
diff changeset
   507
            .filter(f)
01f8ab45f806 fix lobby joining
alfadur
parents: 14801
diff changeset
   508
            .map(|(_, c)| c.nick.clone())
01f8ab45f806 fix lobby joining
alfadur
parents: 14801
diff changeset
   509
            .collect()
14715
25c564f77b7d remove lobby room
alfadur <mail@none>
parents: 14714
diff changeset
   510
    }
25c564f77b7d remove lobby room
alfadur <mail@none>
parents: 14714
diff changeset
   511
15548
24f692e791d3 disallow mutable rooms outside the server
alfadur <mail@none>
parents: 15547
diff changeset
   512
    pub fn lobby_client_ids(&self) -> impl Iterator<Item = ClientId> + '_ {
14810
18240b308505 implement stats message
alfadur
parents: 14807
diff changeset
   513
        self.filter_clients(|(_, c)| c.room_id == None)
14802
01f8ab45f806 fix lobby joining
alfadur
parents: 14801
diff changeset
   514
    }
01f8ab45f806 fix lobby joining
alfadur
parents: 14801
diff changeset
   515
15548
24f692e791d3 disallow mutable rooms outside the server
alfadur <mail@none>
parents: 15547
diff changeset
   516
    pub fn room_client_ids(&self, room_id: RoomId) -> impl Iterator<Item = ClientId> + '_ {
14810
18240b308505 implement stats message
alfadur
parents: 14807
diff changeset
   517
        self.filter_clients(move |(_, c)| c.room_id == Some(room_id))
13416
cdf69667593b partial room implementation
alfadur
parents: 13119
diff changeset
   518
    }
cdf69667593b partial room implementation
alfadur
parents: 13119
diff changeset
   519
15548
24f692e791d3 disallow mutable rooms outside the server
alfadur <mail@none>
parents: 15547
diff changeset
   520
    pub fn protocol_client_ids(&self, protocol: u16) -> impl Iterator<Item = ClientId> + '_ {
14810
18240b308505 implement stats message
alfadur
parents: 14807
diff changeset
   521
        self.filter_clients(move |(_, c)| c.protocol_number == protocol)
18240b308505 implement stats message
alfadur
parents: 14807
diff changeset
   522
    }
18240b308505 implement stats message
alfadur
parents: 14807
diff changeset
   523
15548
24f692e791d3 disallow mutable rooms outside the server
alfadur <mail@none>
parents: 15547
diff changeset
   524
    pub fn protocol_room_ids(&self, protocol: u16) -> impl Iterator<Item = RoomId> + '_ {
14810
18240b308505 implement stats message
alfadur
parents: 14807
diff changeset
   525
        self.filter_rooms(move |(_, r)| r.protocol_number == protocol)
13416
cdf69667593b partial room implementation
alfadur
parents: 13119
diff changeset
   526
    }
cdf69667593b partial room implementation
alfadur
parents: 13119
diff changeset
   527
15548
24f692e791d3 disallow mutable rooms outside the server
alfadur <mail@none>
parents: 15547
diff changeset
   528
    pub fn other_client_ids_in_room(&self, self_id: ClientId) -> Vec<ClientId> {
13416
cdf69667593b partial room implementation
alfadur
parents: 13119
diff changeset
   529
        let room_id = self.clients[self_id].room_id;
15548
24f692e791d3 disallow mutable rooms outside the server
alfadur <mail@none>
parents: 15547
diff changeset
   530
        self.collect_client_ids(|(id, c)| *id != self_id && c.room_id == room_id)
13416
cdf69667593b partial room implementation
alfadur
parents: 13119
diff changeset
   531
    }
14807
8ecdb5c6bb2a implement info, registered only & super power messages
alfadur
parents: 14804
diff changeset
   532
8ecdb5c6bb2a implement info, registered only & super power messages
alfadur
parents: 14804
diff changeset
   533
    pub fn is_registered_only(&self) -> bool {
8ecdb5c6bb2a implement info, registered only & super power messages
alfadur
parents: 14804
diff changeset
   534
        self.flags.contains(ServerFlags::REGISTERED_ONLY)
8ecdb5c6bb2a implement info, registered only & super power messages
alfadur
parents: 14804
diff changeset
   535
    }
8ecdb5c6bb2a implement info, registered only & super power messages
alfadur
parents: 14804
diff changeset
   536
8ecdb5c6bb2a implement info, registered only & super power messages
alfadur
parents: 14804
diff changeset
   537
    pub fn set_is_registered_only(&mut self, value: bool) {
8ecdb5c6bb2a implement info, registered only & super power messages
alfadur
parents: 14804
diff changeset
   538
        self.flags.set(ServerFlags::REGISTERED_ONLY, value)
8ecdb5c6bb2a implement info, registered only & super power messages
alfadur
parents: 14804
diff changeset
   539
    }
15548
24f692e791d3 disallow mutable rooms outside the server
alfadur <mail@none>
parents: 15547
diff changeset
   540
24f692e791d3 disallow mutable rooms outside the server
alfadur <mail@none>
parents: 15547
diff changeset
   541
    pub fn set_room_saves(&mut self, room_id: RoomId, text: &str) -> Result<(), serde_yaml::Error> {
24f692e791d3 disallow mutable rooms outside the server
alfadur <mail@none>
parents: 15547
diff changeset
   542
        if let Some(room) = self.rooms.get_mut(room_id) {
24f692e791d3 disallow mutable rooms outside the server
alfadur <mail@none>
parents: 15547
diff changeset
   543
            room.set_saves(text)
24f692e791d3 disallow mutable rooms outside the server
alfadur <mail@none>
parents: 15547
diff changeset
   544
        } else {
24f692e791d3 disallow mutable rooms outside the server
alfadur <mail@none>
parents: 15547
diff changeset
   545
            Ok(())
24f692e791d3 disallow mutable rooms outside the server
alfadur <mail@none>
parents: 15547
diff changeset
   546
        }
24f692e791d3 disallow mutable rooms outside the server
alfadur <mail@none>
parents: 15547
diff changeset
   547
    }
13445
d3c86ade3d4d Send the rnd reply to the room only.
Marcin Mielniczuk <marmistrz.dev@zoho.eu>
parents: 13442
diff changeset
   548
}
14525
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
   549
15545
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   550
pub struct HwRoomControl<'a> {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   551
    server: &'a mut HwServer,
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   552
    client_id: ClientId,
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   553
    room_id: RoomId,
15574
0031683bfa76 don't apply voted 🦔 to the in-game teams
alfadur
parents: 15573
diff changeset
   554
    is_room_removed: bool,
15545
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   555
}
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   556
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   557
impl<'a> HwRoomControl<'a> {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   558
    #[inline]
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   559
    pub fn new(server: &'a mut HwServer, client_id: ClientId) -> Option<Self> {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   560
        if let Some(room_id) = server.clients[client_id].room_id {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   561
            Some(Self {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   562
                server,
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   563
                client_id,
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   564
                room_id,
15574
0031683bfa76 don't apply voted 🦔 to the in-game teams
alfadur
parents: 15573
diff changeset
   565
                is_room_removed: false,
15545
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   566
            })
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   567
        } else {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   568
            None
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   569
        }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   570
    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   571
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   572
    #[inline]
15573
7478568cffbe fix phantom rooms
alfadur
parents: 15563
diff changeset
   573
    pub fn cleanup_room(self) {
7478568cffbe fix phantom rooms
alfadur
parents: 15563
diff changeset
   574
        if self.is_room_removed {
7478568cffbe fix phantom rooms
alfadur
parents: 15563
diff changeset
   575
            self.server.rooms.remove(self.room_id);
7478568cffbe fix phantom rooms
alfadur
parents: 15563
diff changeset
   576
        }
7478568cffbe fix phantom rooms
alfadur
parents: 15563
diff changeset
   577
    }
7478568cffbe fix phantom rooms
alfadur
parents: 15563
diff changeset
   578
7478568cffbe fix phantom rooms
alfadur
parents: 15563
diff changeset
   579
    #[inline]
15545
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   580
    pub fn server(&self) -> &HwServer {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   581
        self.server
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   582
    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   583
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   584
    #[inline]
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   585
    pub fn client(&self) -> &HwClient {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   586
        &self.server.clients[self.client_id]
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   587
    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   588
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   589
    #[inline]
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   590
    fn client_mut(&mut self) -> &mut HwClient {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   591
        &mut self.server.clients[self.client_id]
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   592
    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   593
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   594
    #[inline]
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   595
    pub fn room(&self) -> &HwRoom {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   596
        &self.server.rooms[self.room_id]
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   597
    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   598
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   599
    #[inline]
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   600
    fn room_mut(&mut self) -> &mut HwRoom {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   601
        &mut self.server.rooms[self.room_id]
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   602
    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   603
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   604
    #[inline]
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   605
    pub fn get(&self) -> (&HwClient, &HwRoom) {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   606
        (self.client(), self.room())
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   607
    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   608
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   609
    #[inline]
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   610
    fn get_mut(&mut self) -> (&mut HwClient, &mut HwRoom) {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   611
        (
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   612
            &mut self.server.clients[self.client_id],
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   613
            &mut self.server.rooms[self.room_id],
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   614
        )
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   615
    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   616
15547
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   617
    pub fn change_client<'b: 'a>(self, client_id: ClientId) -> Option<HwRoomControl<'a>> {
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   618
        let room_id = self.room_id;
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   619
        HwRoomControl::new(self.server, client_id).filter(|c| c.room_id == room_id)
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   620
    }
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   621
16015
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   622
    fn remove_from_room(&mut self, client_id: ClientId) -> LeaveRoomResult {
16017
0b2e0a7d0431 fix server build
alfadur
parents: 16015
diff changeset
   623
        let (client, room) = self.server.client_and_room_mut(client_id).expect("Caller should have ensured the client is in this room");
15545
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   624
        room.players_number -= 1;
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   625
        client.room_id = None;
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   626
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   627
        let is_empty = room.players_number == 0;
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   628
        let is_fixed = room.is_fixed();
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   629
        let was_master = room.master_id == Some(client.id);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   630
        let was_in_game = client.is_in_game();
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   631
        let mut removed_teams = vec![];
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   632
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   633
        if is_empty && !is_fixed {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   634
            if client.is_ready() && room.ready_players_number > 0 {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   635
                room.ready_players_number -= 1;
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   636
            }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   637
15591
4b2f3228f13b fix editing teams while a game is in progress
alfadur
parents: 15575
diff changeset
   638
            if let Some(ref mut info) = room.game_info {
4b2f3228f13b fix editing teams while a game is in progress
alfadur
parents: 15575
diff changeset
   639
                removed_teams = info
4b2f3228f13b fix editing teams while a game is in progress
alfadur
parents: 15575
diff changeset
   640
                    .client_teams(client.id)
4b2f3228f13b fix editing teams while a game is in progress
alfadur
parents: 15575
diff changeset
   641
                    .map(|t| t.name.clone())
4b2f3228f13b fix editing teams while a game is in progress
alfadur
parents: 15575
diff changeset
   642
                    .collect();
4b2f3228f13b fix editing teams while a game is in progress
alfadur
parents: 15575
diff changeset
   643
                info.mark_left_teams(removed_teams.iter());
4b2f3228f13b fix editing teams while a game is in progress
alfadur
parents: 15575
diff changeset
   644
            } else {
4b2f3228f13b fix editing teams while a game is in progress
alfadur
parents: 15575
diff changeset
   645
                removed_teams = room
4b2f3228f13b fix editing teams while a game is in progress
alfadur
parents: 15575
diff changeset
   646
                    .client_teams(client.id)
4b2f3228f13b fix editing teams while a game is in progress
alfadur
parents: 15575
diff changeset
   647
                    .map(|t| t.name.clone())
4b2f3228f13b fix editing teams while a game is in progress
alfadur
parents: 15575
diff changeset
   648
                    .collect();
4b2f3228f13b fix editing teams while a game is in progress
alfadur
parents: 15575
diff changeset
   649
                for team_name in &removed_teams {
4b2f3228f13b fix editing teams while a game is in progress
alfadur
parents: 15575
diff changeset
   650
                    room.remove_team(team_name);
4b2f3228f13b fix editing teams while a game is in progress
alfadur
parents: 15575
diff changeset
   651
                }
15545
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   652
            }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   653
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   654
            if client.is_master() && !is_fixed {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   655
                client.set_is_master(false);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   656
                room.master_id = None;
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   657
            }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   658
        }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   659
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   660
        client.set_is_ready(false);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   661
        client.set_is_in_game(false);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   662
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   663
        if !is_fixed {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   664
            if room.players_number == 0 {
15573
7478568cffbe fix phantom rooms
alfadur
parents: 15563
diff changeset
   665
                self.is_room_removed = true
15545
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   666
            } else if room.master_id == None {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   667
                let protocol_number = room.protocol_number;
15548
24f692e791d3 disallow mutable rooms outside the server
alfadur <mail@none>
parents: 15547
diff changeset
   668
                let new_master_id = self.server.room_client_ids(self.room_id).next();
15545
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   669
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   670
                if let Some(new_master_id) = new_master_id {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   671
                    let room = self.room_mut();
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   672
                    room.master_id = Some(new_master_id);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   673
                    let new_master = &mut self.server.clients[new_master_id];
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   674
                    new_master.set_is_master(true);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   675
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   676
                    if protocol_number < 42 {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   677
                        let nick = new_master.nick.clone();
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   678
                        self.room_mut().name = nick;
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   679
                    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   680
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   681
                    let room = self.room_mut();
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   682
                    room.set_join_restriction(false);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   683
                    room.set_team_add_restriction(false);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   684
                    room.set_unregistered_players_restriction(true);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   685
                }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   686
            }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   687
        }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   688
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   689
        if is_empty && !is_fixed {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   690
            LeaveRoomResult::RoomRemoved
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   691
        } else {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   692
            LeaveRoomResult::RoomRemains {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   693
                is_empty,
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   694
                was_master,
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   695
                was_in_game,
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   696
                new_master: self.room().master_id,
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   697
                removed_teams,
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   698
            }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   699
        }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   700
    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   701
16015
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   702
    pub fn leave_room(&mut self) -> LeaveRoomResult {
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   703
        self.remove_from_room(self.client_id)
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   704
    }
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   705
15545
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   706
    pub fn change_master(
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   707
        &mut self,
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   708
        new_master_nick: String,
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   709
    ) -> Result<ChangeMasterResult, ChangeMasterError> {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   710
        use ChangeMasterError::*;
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   711
        let (client, room) = self.get_mut();
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   712
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   713
        if client.is_admin() || room.master_id == Some(client.id) {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   714
            let new_master_id = self
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   715
                .server
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   716
                .clients
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   717
                .iter()
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   718
                .find(|(_, c)| c.nick == new_master_nick)
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   719
                .map(|(id, _)| id);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   720
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   721
            match new_master_id {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   722
                Some(new_master_id) if new_master_id == self.client_id => Err(AlreadyMaster),
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   723
                Some(new_master_id) => {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   724
                    let new_master = &mut self.server.clients[new_master_id];
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   725
                    if new_master.room_id == Some(self.room_id) {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   726
                        self.server.clients[new_master_id].set_is_master(true);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   727
                        let old_master_id = self.room().master_id;
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   728
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   729
                        if let Some(master_id) = old_master_id {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   730
                            self.server.clients[master_id].set_is_master(false);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   731
                        }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   732
                        self.room_mut().master_id = Some(new_master_id);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   733
                        Ok(ChangeMasterResult {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   734
                            old_master_id,
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   735
                            new_master_id,
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   736
                        })
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   737
                    } else {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   738
                        Err(ClientNotInRoom)
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   739
                    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   740
                }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   741
                None => Err(NoClient),
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   742
            }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   743
        } else {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   744
            Err(NoAccess)
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   745
        }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   746
    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   747
15547
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   748
    pub fn start_vote(&mut self, kind: VoteType) -> Result<(), StartVoteError> {
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   749
        use StartVoteError::*;
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   750
        match self.room().voting {
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   751
            Some(_) => Err(VotingInProgress),
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   752
            None => {
15548
24f692e791d3 disallow mutable rooms outside the server
alfadur <mail@none>
parents: 15547
diff changeset
   753
                let voting = Voting::new(kind, self.server.room_client_ids(self.room_id).collect());
15547
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   754
                self.room_mut().voting = Some(voting);
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   755
                Ok(())
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   756
            }
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   757
        }
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   758
    }
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   759
16015
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   760
    fn apply_vote(&mut self, kind: VoteType) -> Option<VoteEffect> {
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   761
        match kind {
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   762
            VoteType::Kick(nick) => {
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   763
                if let Some(kicked_id) = self
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   764
                    .server
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   765
                    .find_client(&nick)
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   766
                    .filter(|c| c.room_id == Some(self.room_id))
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   767
                    .map(|c| c.id)
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   768
                {
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   769
                    let leave_result = self.remove_from_room(kicked_id);
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   770
                    Some(VoteEffect::Kicked(kicked_id, leave_result))
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   771
                } else {
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   772
                    None
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   773
                }
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   774
            }
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   775
            VoteType::Map(None) => None,
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   776
            VoteType::Map(Some(name)) => self
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   777
                .load_config(&name)
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   778
                .map(|s| VoteEffect::Map(s.to_string())),
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   779
            VoteType::Pause => Some(VoteEffect::Pause).filter(|_| self.toggle_pause()),
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   780
            VoteType::NewSeed => {
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   781
                let seed = thread_rng().gen_range(0..1_000_000_000).to_string();
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   782
                let cfg = GameCfg::Seed(seed);
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   783
                todo!("Protocol backwards compatibility");
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   784
                self.room_mut().set_config(cfg.clone());
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   785
                Some(VoteEffect::NewSeed(cfg))
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   786
            }
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   787
            VoteType::HedgehogsPerTeam(number) => {
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   788
                let nicks = self.set_hedgehogs_number(number);
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   789
                Some(VoteEffect::HedgehogsPerTeam(number, nicks))
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   790
            }
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   791
        }
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   792
    }
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   793
15547
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   794
    pub fn vote(&mut self, vote: Vote) -> Result<VoteResult, VoteError> {
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   795
        use self::{VoteError::*, VoteResult::*};
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   796
        let client_id = self.client_id;
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   797
        if let Some(ref mut voting) = self.room_mut().voting {
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   798
            if vote.is_forced || voting.votes.iter().all(|(id, _)| client_id != *id) {
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   799
                voting.votes.push((client_id, vote.is_pro));
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   800
                let i = voting.votes.iter();
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   801
                let pro = i.clone().filter(|(_, v)| *v).count();
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   802
                let contra = i.filter(|(_, v)| !*v).count();
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   803
                let success_quota = voting.voters.len() / 2 + 1;
16017
0b2e0a7d0431 fix server build
alfadur
parents: 16015
diff changeset
   804
15547
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   805
                if vote.is_forced && vote.is_pro || pro >= success_quota {
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   806
                    let voting = self.room_mut().voting.take().unwrap();
16015
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   807
                    if let Some(effect) = self.apply_vote(voting.kind) {
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   808
                        Ok(Succeeded(effect))
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   809
                    } else {
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   810
                        Ok(Failed)
cd8392e52165 fix voting rights
alfadur
parents: 15968
diff changeset
   811
                    }
15547
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   812
                } else if vote.is_forced && !vote.is_pro
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   813
                    || contra > voting.voters.len() - success_quota
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   814
                {
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   815
                    Ok(Failed)
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   816
                } else {
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   817
                    Ok(Submitted)
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   818
                }
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   819
            } else {
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   820
                Err(AlreadyVoted)
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   821
            }
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   822
        } else {
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   823
            Err(NoVoting)
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   824
        }
15545
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   825
    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   826
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   827
    pub fn toggle_flag(&mut self, flags: super::room::RoomFlags) -> bool {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   828
        let (client, room) = self.get_mut();
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   829
        if client.is_master() {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   830
            room.flags.toggle(flags);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   831
        }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   832
        client.is_master()
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   833
    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   834
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   835
    pub fn fix_room(&mut self) -> Result<(), AccessError> {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   836
        let (client, room) = self.get_mut();
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   837
        if client.is_admin() {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   838
            room.set_is_fixed(true);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   839
            room.set_join_restriction(false);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   840
            room.set_team_add_restriction(false);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   841
            room.set_unregistered_players_restriction(true);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   842
            Ok(())
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   843
        } else {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   844
            Err(AccessError())
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   845
        }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   846
    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   847
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   848
    pub fn unfix_room(&mut self) -> Result<(), AccessError> {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   849
        let (client, room) = self.get_mut();
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   850
        if client.is_admin() {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   851
            room.set_is_fixed(false);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   852
            Ok(())
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   853
        } else {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   854
            Err(AccessError())
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   855
        }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   856
    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   857
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   858
    pub fn set_room_name(&mut self, mut name: String) -> Result<String, ModifyRoomNameError> {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   859
        use ModifyRoomNameError::*;
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   860
        let room_exists = self.server.has_room(&name);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   861
        let (client, room) = self.get_mut();
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   862
        if room.is_fixed() || room.master_id != Some(client.id) {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   863
            Err(AccessDenied)
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   864
        } else if utils::is_name_illegal(&name) {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   865
            Err(InvalidName)
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   866
        } else if room_exists {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   867
            Err(DuplicateName)
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   868
        } else {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   869
            std::mem::swap(&mut room.name, &mut name);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   870
            Ok(name)
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   871
        }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   872
    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   873
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   874
    pub fn set_room_greeting(&mut self, greeting: Option<String>) -> Result<(), AccessError> {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   875
        let (client, room) = self.get_mut();
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   876
        if client.is_admin() {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   877
            room.greeting = greeting.unwrap_or(String::new());
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   878
            Ok(())
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   879
        } else {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   880
            Err(AccessError())
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   881
        }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   882
    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   883
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   884
    pub fn set_room_max_teams(&mut self, count: u8) -> Result<(), SetTeamCountError> {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   885
        use SetTeamCountError::*;
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   886
        let (client, room) = self.get_mut();
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   887
        if !client.is_master() {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   888
            Err(NotMaster)
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   889
        } else if !(2..=super::room::MAX_TEAMS_IN_ROOM).contains(&count) {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   890
            Err(InvalidNumber)
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   891
        } else {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   892
            room.max_teams = count;
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   893
            Ok(())
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   894
        }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   895
    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   896
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   897
    pub fn set_team_hedgehogs_number(
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   898
        &mut self,
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   899
        team_name: &str,
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   900
        number: u8,
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   901
    ) -> Result<(), SetHedgehogsError> {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   902
        use SetHedgehogsError::*;
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   903
        let (client, room) = self.get_mut();
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   904
        let addable_hedgehogs = room.addable_hedgehogs();
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   905
        if let Some((_, team)) = room.find_team_and_owner_mut(|t| t.name == team_name) {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   906
            let max_hedgehogs = min(
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   907
                super::room::MAX_HEDGEHOGS_IN_ROOM,
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   908
                addable_hedgehogs + team.hedgehogs_number,
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   909
            );
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   910
            if !client.is_master() {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   911
                Err(NotMaster)
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   912
            } else if !(1..=max_hedgehogs).contains(&number) {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   913
                Err(InvalidNumber(team.hedgehogs_number))
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   914
            } else {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   915
                team.hedgehogs_number = number;
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   916
                Ok(())
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   917
            }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   918
        } else {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   919
            Err(NoTeam)
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   920
        }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   921
    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   922
15547
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   923
    pub fn set_hedgehogs_number(&mut self, number: u8) -> Vec<String> {
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   924
        self.room_mut().set_hedgehogs_number(number)
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   925
    }
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
   926
15545
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   927
    pub fn add_team(&mut self, mut info: Box<TeamInfo>) -> Result<&TeamInfo, AddTeamError> {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   928
        use AddTeamError::*;
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   929
        let (client, room) = self.get_mut();
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   930
        if room.teams.len() >= room.max_teams as usize {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   931
            Err(TooManyTeams)
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   932
        } else if room.addable_hedgehogs() == 0 {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   933
            Err(TooManyHedgehogs)
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   934
        } else if room.find_team(|t| t.name == info.name) != None {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   935
            Err(TeamAlreadyExists)
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   936
        } else if room.is_team_add_restricted() {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   937
            Err(Restricted)
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   938
        } else {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   939
            info.owner = client.nick.clone();
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   940
            let team = room.add_team(client.id, *info, client.protocol_number < 42);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   941
            client.teams_in_game += 1;
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   942
            client.clan = Some(team.color);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   943
            Ok(team)
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   944
        }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   945
    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   946
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   947
    pub fn remove_team(&mut self, team_name: &str) -> Result<(), RemoveTeamError> {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   948
        use RemoveTeamError::*;
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   949
        let (client, room) = self.get_mut();
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   950
        match room.find_team_owner(team_name) {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   951
            None => Err(NoTeam),
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   952
            Some((id, _)) if id != client.id => Err(RemoveTeamError::TeamNotOwned),
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   953
            Some(_) => {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   954
                client.teams_in_game -= 1;
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   955
                client.clan = room.find_team_color(client.id);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   956
                room.remove_team(team_name);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   957
                Ok(())
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   958
            }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   959
        }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   960
    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   961
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   962
    pub fn set_team_color(&mut self, team_name: &str, color: u8) -> Result<(), ModifyTeamError> {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   963
        use ModifyTeamError::*;
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   964
        let (client, room) = self.get_mut();
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   965
        if let Some((owner, team)) = room.find_team_and_owner_mut(|t| t.name == team_name) {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   966
            if !client.is_master() {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   967
                Err(NotMaster)
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   968
            } else {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   969
                team.color = color;
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   970
                self.server.clients[owner].clan = Some(color);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   971
                Ok(())
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   972
            }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   973
        } else {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   974
            Err(NoTeam)
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   975
        }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   976
    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   977
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   978
    pub fn set_config(&mut self, cfg: GameCfg) -> Result<(), SetConfigError> {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   979
        use SetConfigError::*;
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   980
        let (client, room) = self.get_mut();
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   981
        if room.is_fixed() {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   982
            Err(RoomFixed)
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   983
        } else if !client.is_master() {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   984
            Err(NotMaster)
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   985
        } else {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   986
            let cfg = match cfg {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   987
                GameCfg::Scheme(name, mut values) => {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   988
                    if client.protocol_number == 49 && values.len() >= 2 {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   989
                        let mut s = "X".repeat(50);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   990
                        s.push_str(&values.pop().unwrap());
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   991
                        values.push(s);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   992
                    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   993
                    GameCfg::Scheme(name, values)
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   994
                }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   995
                cfg => cfg,
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   996
            };
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   997
            room.set_config(cfg);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   998
            Ok(())
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
   999
        }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1000
    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1001
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1002
    pub fn save_config(&mut self, name: String, location: String) {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1003
        self.room_mut().save_config(name, location);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1004
    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1005
15547
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
  1006
    pub fn load_config(&mut self, name: &str) -> Option<&str> {
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
  1007
        self.room_mut().load_config(name)
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
  1008
    }
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
  1009
15545
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1010
    pub fn delete_config(&mut self, name: &str) -> bool {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1011
        self.room_mut().delete_config(name)
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1012
    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1013
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1014
    pub fn toggle_ready(&mut self) -> bool {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1015
        let (client, room) = self.get_mut();
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1016
        client.set_is_ready(!client.is_ready());
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1017
        if client.is_ready() {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1018
            room.ready_players_number += 1;
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1019
        } else {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1020
            room.ready_players_number -= 1;
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1021
        }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1022
        client.is_ready()
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1023
    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1024
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1025
    pub fn start_game(&mut self) -> Result<Vec<String>, StartGameError> {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1026
        use StartGameError::*;
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1027
        let (room_clients, room_nicks): (Vec<_>, Vec<_>) = self
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1028
            .server
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1029
            .clients
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1030
            .iter()
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1031
            .map(|(id, c)| (id, c.nick.clone()))
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1032
            .unzip();
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1033
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1034
        let room = self.room_mut();
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1035
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1036
        if !room.has_multiple_clans() {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1037
            Err(NotEnoughClans)
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1038
        } else if room.protocol_number <= 43 && room.players_number != room.ready_players_number {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1039
            Err(NotReady)
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1040
        } else if room.game_info.is_some() {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1041
            Err(AlreadyInGame)
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1042
        } else {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1043
            room.start_round();
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1044
            for id in room_clients {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1045
                let team_indices = self.room().client_team_indices(id);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1046
                let c = &mut self.server.clients[id];
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1047
                c.set_is_in_game(true);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1048
                c.team_indices = team_indices;
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1049
            }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1050
            Ok(room_nicks)
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1051
        }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1052
    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1053
15547
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
  1054
    pub fn toggle_pause(&mut self) -> bool {
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
  1055
        if let Some(ref mut info) = self.room_mut().game_info {
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
  1056
            info.is_paused = !info.is_paused;
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
  1057
        }
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
  1058
        self.room_mut().game_info.is_some()
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
  1059
    }
16d3c9acd715 restore voting
alfadur <mail@none>
parents: 15545
diff changeset
  1060
15545
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1061
    pub fn leave_game(&mut self) -> Option<Vec<String>> {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1062
        let (client, room) = self.get_mut();
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1063
        let client_left = client.is_in_game();
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1064
        if client_left {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1065
            client.set_is_in_game(false);
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1066
15575
852682c2003f fix in-game team handling
alfadur
parents: 15574
diff changeset
  1067
            if let Some(ref mut info) = room.game_info {
852682c2003f fix in-game team handling
alfadur
parents: 15574
diff changeset
  1068
                let team_names: Vec<_> = info
852682c2003f fix in-game team handling
alfadur
parents: 15574
diff changeset
  1069
                    .client_teams(client.id)
852682c2003f fix in-game team handling
alfadur
parents: 15574
diff changeset
  1070
                    .map(|t| t.name.clone())
852682c2003f fix in-game team handling
alfadur
parents: 15574
diff changeset
  1071
                    .collect();
15545
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1072
15591
4b2f3228f13b fix editing teams while a game is in progress
alfadur
parents: 15575
diff changeset
  1073
                info.mark_left_teams(team_names.iter());
15575
852682c2003f fix in-game team handling
alfadur
parents: 15574
diff changeset
  1074
15545
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1075
                Some(team_names)
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1076
            } else {
15575
852682c2003f fix in-game team handling
alfadur
parents: 15574
diff changeset
  1077
                None
15545
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1078
            }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1079
        } else {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1080
            None
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1081
        }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1082
    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1083
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1084
    pub fn end_game(&mut self) -> Option<EndGameResult> {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1085
        let room = self.room_mut();
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1086
        room.ready_players_number = room.master_id.is_some() as u8;
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1087
15563
d122b65bdf6f reapply some simplifications
alfadur <mail@none>
parents: 15562
diff changeset
  1088
        if let Some(mut info) = replace(&mut room.game_info, None) {
15545
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1089
            let room_id = room.id;
15563
d122b65bdf6f reapply some simplifications
alfadur <mail@none>
parents: 15562
diff changeset
  1090
            for team_name in &info.left_teams {
d122b65bdf6f reapply some simplifications
alfadur <mail@none>
parents: 15562
diff changeset
  1091
                room.remove_team(team_name);
d122b65bdf6f reapply some simplifications
alfadur <mail@none>
parents: 15562
diff changeset
  1092
            }
d122b65bdf6f reapply some simplifications
alfadur <mail@none>
parents: 15562
diff changeset
  1093
15545
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1094
            let unreadied_nicks: Vec<_> = self
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1095
                .server
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1096
                .clients
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1097
                .iter_mut()
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1098
                .filter(|(_, c)| c.room_id == Some(room_id))
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1099
                .map(|(_, c)| {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1100
                    c.set_is_ready(c.is_master());
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1101
                    c
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1102
                })
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1103
                .filter_map(|c| {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1104
                    if !c.is_master() {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1105
                        Some(c.nick.clone())
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1106
                    } else {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1107
                        None
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1108
                    }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1109
                })
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1110
                .collect();
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1111
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1112
            Some(EndGameResult {
15563
d122b65bdf6f reapply some simplifications
alfadur <mail@none>
parents: 15562
diff changeset
  1113
                left_teams: replace(&mut info.left_teams, vec![]),
15545
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1114
                unreadied_nicks,
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1115
            })
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1116
        } else {
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1117
            None
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1118
        }
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1119
    }
15549
428a0e7da27b restore engine message handler
alfadur <mail@none>
parents: 15548
diff changeset
  1120
428a0e7da27b restore engine message handler
alfadur <mail@none>
parents: 15548
diff changeset
  1121
    pub fn log_engine_msg(&mut self, log_msg: String, sync_msg: Option<Option<String>>) {
428a0e7da27b restore engine message handler
alfadur <mail@none>
parents: 15548
diff changeset
  1122
        if let Some(ref mut info) = self.room_mut().game_info {
428a0e7da27b restore engine message handler
alfadur <mail@none>
parents: 15548
diff changeset
  1123
            if !log_msg.is_empty() {
428a0e7da27b restore engine message handler
alfadur <mail@none>
parents: 15548
diff changeset
  1124
                info.msg_log.push(log_msg);
428a0e7da27b restore engine message handler
alfadur <mail@none>
parents: 15548
diff changeset
  1125
            }
428a0e7da27b restore engine message handler
alfadur <mail@none>
parents: 15548
diff changeset
  1126
            if let Some(msg) = sync_msg {
428a0e7da27b restore engine message handler
alfadur <mail@none>
parents: 15548
diff changeset
  1127
                info.sync_msg = msg;
428a0e7da27b restore engine message handler
alfadur <mail@none>
parents: 15548
diff changeset
  1128
            }
428a0e7da27b restore engine message handler
alfadur <mail@none>
parents: 15548
diff changeset
  1129
        }
428a0e7da27b restore engine message handler
alfadur <mail@none>
parents: 15548
diff changeset
  1130
    }
15545
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1131
}
f4f6060b536c add a separate interface for modifying room state
alfadur <mail@none>
parents: 15544
diff changeset
  1132
15096
e935b1ad23f3 normalize type names
alfadur
parents: 15095
diff changeset
  1133
fn allocate_room(rooms: &mut Slab<HwRoom>) -> &mut HwRoom {
14525
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1134
    let entry = rooms.vacant_entry();
15096
e935b1ad23f3 normalize type names
alfadur
parents: 15095
diff changeset
  1135
    let room = HwRoom::new(entry.key());
14525
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1136
    entry.insert(room)
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1137
}
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1138
15463
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
  1139
fn create_room<'a, 'b>(
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
  1140
    client: &'a mut HwClient,
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
  1141
    rooms: &'b mut Slab<HwRoom>,
14525
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1142
    name: String,
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1143
    password: Option<String>,
15463
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
  1144
) -> (&'a HwClient, &'b HwRoom) {
14525
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1145
    let room = allocate_room(rooms);
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1146
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1147
    room.master_id = Some(client.id);
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1148
    room.name = name;
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1149
    room.password = password;
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1150
    room.protocol_number = client.protocol_number;
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1151
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1152
    room.players_number = 1;
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1153
    room.ready_players_number = 1;
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1154
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1155
    client.room_id = Some(room.id);
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1156
    client.set_is_master(true);
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1157
    client.set_is_ready(true);
15555
0606f89698e7 check the room passwords
alfadur <mail@none>
parents: 15554
diff changeset
  1158
    client.set_is_in_game(false);
0606f89698e7 check the room passwords
alfadur <mail@none>
parents: 15554
diff changeset
  1159
    client.clan = None;
0606f89698e7 check the room passwords
alfadur <mail@none>
parents: 15554
diff changeset
  1160
    client.teams_in_game = 0;
0606f89698e7 check the room passwords
alfadur <mail@none>
parents: 15554
diff changeset
  1161
    client.team_indices = vec![];
14525
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1162
15463
a158ff8f84ef refactor the lobby handler
alfadur
parents: 15197
diff changeset
  1163
    (client, room)
14525
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1164
}
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1165
15096
e935b1ad23f3 normalize type names
alfadur
parents: 15095
diff changeset
  1166
fn move_to_room(client: &mut HwClient, room: &mut HwRoom) {
14525
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1167
    debug_assert!(client.room_id != Some(room.id));
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1168
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1169
    room.players_number += 1;
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1170
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1171
    client.room_id = Some(room.id);
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1172
    client.set_is_in_game(room.game_info.is_some());
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1173
15562
479911540e17 backout a798e6441a36
alfadur <mail@none>
parents: 15558
diff changeset
  1174
    if let Some(ref mut info) = room.game_info {
479911540e17 backout a798e6441a36
alfadur <mail@none>
parents: 15558
diff changeset
  1175
        let teams = info.client_teams(client.id);
479911540e17 backout a798e6441a36
alfadur <mail@none>
parents: 15558
diff changeset
  1176
        client.teams_in_game = teams.clone().count() as u8;
479911540e17 backout a798e6441a36
alfadur <mail@none>
parents: 15558
diff changeset
  1177
        client.clan = teams.clone().next().map(|t| t.color);
479911540e17 backout a798e6441a36
alfadur <mail@none>
parents: 15558
diff changeset
  1178
        let team_names: Vec<_> = teams.map(|t| t.name.clone()).collect();
14525
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1179
15562
479911540e17 backout a798e6441a36
alfadur <mail@none>
parents: 15558
diff changeset
  1180
        if !team_names.is_empty() {
479911540e17 backout a798e6441a36
alfadur <mail@none>
parents: 15558
diff changeset
  1181
            info.left_teams.retain(|name| !team_names.contains(&name));
14525
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1182
        }
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1183
    }
6cc0fce249f9 Server action refactoring part 1 of N
alfadur <mail@none>
parents: 14478
diff changeset
  1184
}