rust/hedgewars-server/src/server/room.rs
changeset 14788 6dea1ca64992
parent 14785 a1077e8d26f4
equal deleted inserted replaced
14787:0e64acbc3f8b 14788:6dea1ca64992
     8 use serde::{Deserialize, Serialize};
     8 use serde::{Deserialize, Serialize};
     9 use serde_derive::{Deserialize, Serialize};
     9 use serde_derive::{Deserialize, Serialize};
    10 use serde_yaml;
    10 use serde_yaml;
    11 use std::{collections::HashMap, iter};
    11 use std::{collections::HashMap, iter};
    12 
    12 
    13 const MAX_TEAMS_IN_ROOM: u8 = 8;
    13 pub const MAX_TEAMS_IN_ROOM: u8 = 8;
    14 const MAX_HEDGEHOGS_IN_ROOM: u8 = MAX_HEDGEHOGS_PER_TEAM * MAX_HEDGEHOGS_PER_TEAM;
    14 pub const MAX_HEDGEHOGS_IN_ROOM: u8 = MAX_HEDGEHOGS_PER_TEAM * MAX_HEDGEHOGS_PER_TEAM;
    15 
    15 
    16 fn client_teams_impl(
    16 fn client_teams_impl(
    17     teams: &[(ClientId, TeamInfo)],
    17     teams: &[(ClientId, TeamInfo)],
    18     client_id: ClientId,
    18     client_id: ClientId,
    19 ) -> impl Iterator<Item = &TeamInfo> + Clone {
    19 ) -> impl Iterator<Item = &TeamInfo> + Clone {
    75     pub protocol_number: u16,
    75     pub protocol_number: u16,
    76     pub flags: RoomFlags,
    76     pub flags: RoomFlags,
    77 
    77 
    78     pub players_number: u8,
    78     pub players_number: u8,
    79     pub default_hedgehog_number: u8,
    79     pub default_hedgehog_number: u8,
    80     pub team_limit: u8,
    80     pub max_teams: u8,
    81     pub ready_players_number: u8,
    81     pub ready_players_number: u8,
    82     pub teams: Vec<(ClientId, TeamInfo)>,
    82     pub teams: Vec<(ClientId, TeamInfo)>,
    83     config: RoomConfig,
    83     config: RoomConfig,
    84     pub voting: Option<Voting>,
    84     pub voting: Option<Voting>,
    85     pub saves: HashMap<String, RoomSave>,
    85     pub saves: HashMap<String, RoomSave>,
    96             greeting: "".to_string(),
    96             greeting: "".to_string(),
    97             flags: RoomFlags::empty(),
    97             flags: RoomFlags::empty(),
    98             protocol_number: 0,
    98             protocol_number: 0,
    99             players_number: 0,
    99             players_number: 0,
   100             default_hedgehog_number: 4,
   100             default_hedgehog_number: 4,
   101             team_limit: MAX_TEAMS_IN_ROOM,
   101             max_teams: MAX_TEAMS_IN_ROOM,
   102             ready_players_number: 0,
   102             ready_players_number: 0,
   103             teams: Vec::new(),
   103             teams: Vec::new(),
   104             config: RoomConfig::new(),
   104             config: RoomConfig::new(),
   105             voting: None,
   105             voting: None,
   106             saves: HashMap::new(),
   106             saves: HashMap::new(),
   195             .filter(move |(_, (id, _))| *id == client_id)
   195             .filter(move |(_, (id, _))| *id == client_id)
   196             .map(|(i, _)| i as u8)
   196             .map(|(i, _)| i as u8)
   197             .collect()
   197             .collect()
   198     }
   198     }
   199 
   199 
       
   200     pub fn clan_team_owners(&self, color: u8) -> impl Iterator<Item = ClientId> + '_ {
       
   201         self.teams
       
   202             .iter()
       
   203             .filter(move |(_, t)| t.color == color)
       
   204             .map(|(id, _)| *id)
       
   205     }
       
   206 
   200     pub fn find_team_owner(&self, team_name: &str) -> Option<(ClientId, &str)> {
   207     pub fn find_team_owner(&self, team_name: &str) -> Option<(ClientId, &str)> {
   201         self.teams
   208         self.teams
   202             .iter()
   209             .iter()
   203             .find(|(_, t)| t.name == team_name)
   210             .find(|(_, t)| t.name == team_name)
   204             .map(|(id, t)| (*id, &t.name[..]))
   211             .map(|(id, t)| (*id, &t.name[..]))