Mercurial Mercurial > hedgewars-draft / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
rust/hedgewars-server/src/server/handlers/common.rs
changeset 14803 50fcef24003f
parent 14802 01f8ab45f806
child 14804 b3adc030104b
equal deleted inserted replaced
14802:01f8ab45f806 14803:50fcef24003f 
     1 use crate::{
 
     1 use crate::{
 
     2     protocol::messages::server_chat,
 
     2     protocol::messages::server_chat,
 
     3     protocol::messages::{
 
     3     protocol::messages::{
 
       
     4         add_flags, remove_flags,
 
     4         HWProtocolMessage::{self, Rnd},
 
     5         HWProtocolMessage::{self, Rnd},
 
     5         HWServerMessage::{self, *},
 
     6         HWServerMessage::{self, *},
 
       
     7         ProtocolFlags as Flags,
 
     6     },
 
     8     },
 
     7     server::{
 
     9     server::{
 
     8         client::HWClient,
 
    10         client::HWClient,
 
     9         core::HWServer,
 
    11         core::HWServer,
 
    10         coretypes::{ClientId, GameCfg, RoomId, Vote, VoteType},
 
    12         coretypes::{ClientId, GameCfg, RoomId, Vote, VoteType},
 
    40 
    42 
    41     let joined_msg = LobbyJoined(lobby_nicks);
 
    43     let joined_msg = LobbyJoined(lobby_nicks);
 
    42 
    44 
    43     let everyone_msg = LobbyJoined(vec![server.clients[client_id].nick.clone()]);
 
    45     let everyone_msg = LobbyJoined(vec![server.clients[client_id].nick.clone()]);
 
    44     let flags_msg = ClientFlags(
 
    46     let flags_msg = ClientFlags(
 
    45         "+i".to_string(),
 
    47         add_flags(&[Flags::InRoom]),
 
    46         server.collect_nicks(|(_, c)| c.room_id.is_some()),
 
    48         server.collect_nicks(|(_, c)| c.room_id.is_some()),
 
    47     );
 
    49     );
 
    48     let server_msg = ServerMessage("\u{1f994} is watching".to_string());
 
    50     let server_msg = ServerMessage("\u{1f994} is watching".to_string());
 
    49 
    51 
    50     let rooms_msg = Rooms(
 
    52     let rooms_msg = Rooms(
 
   134         }
 
   136         }
 
   135 
   137 
   136         if client.is_master() && !room.is_fixed() {
 
   138         if client.is_master() && !room.is_fixed() {
 
   137             client.set_is_master(false);
 
   139             client.set_is_master(false);
 
   138             response.add(
 
   140             response.add(
 
   139                 ClientFlags("-h".to_string(), vec![client.nick.clone()])
 
   141                 ClientFlags(remove_flags(&[Flags::RoomMaster]), vec![client.nick.clone()])
 
   140                     .send_all()
 
   142                     .send_all()
 
   141                     .in_room(room.id),
 
   143                     .in_room(room.id),
 
   142             );
 
   144             );
 
   143             room.master_id = None;
 
   145             room.master_id = None;
 
   144         }
 
   146         }
 
   151     } else {
 
   153     } else {
 
   152         RoomUpdated(room.name.clone(), room.info(Some(&client)))
 
   154         RoomUpdated(room.name.clone(), room.info(Some(&client)))
 
   153     };
 
   155     };
 
   154     response.add(update_msg.send_all().with_protocol(room.protocol_number));
 
   156     response.add(update_msg.send_all().with_protocol(room.protocol_number));
 
   155 
   157 
   156     response.add(ClientFlags("-i".to_string(), vec![client.nick.clone()]).send_all());
 
   158     response.add(ClientFlags(remove_flags(&[Flags::InRoom]), vec![client.nick.clone()]).send_all());
 
   157 }
 
   159 }
 
   158 
   160 
   159 pub fn exit_room(server: &mut HWServer, client_id: ClientId, response: &mut Response, msg: &str) {
 
   161 pub fn exit_room(server: &mut HWServer, client_id: ClientId, response: &mut Response, msg: &str) {
 
   160     let client = &mut server.clients[client_id];
 
   162     let client = &mut server.clients[client_id];
 
   161 
   163 
   178                 room.set_join_restriction(false);
 
   180                 room.set_join_restriction(false);
 
   179                 room.set_team_add_restriction(false);
 
   181                 room.set_team_add_restriction(false);
 
   180                 room.set_unregistered_players_restriction(true);
 
   182                 room.set_unregistered_players_restriction(true);
 
   181 
   183 
   182                 response.add(
 
   184                 response.add(
 
   183                     ClientFlags("+h".to_string(), vec![new_master_nick])
 
   185                     ClientFlags(add_flags(&[Flags::RoomMaster]), vec![new_master_nick])
 
   184                         .send_all()
 
   186                         .send_all()
 
   185                         .in_room(room.id),
 
   187                         .in_room(room.id),
 
   186                 );
 
   188                 );
 
   187             }
 
   189             }
 
   188         }
 
   190         }
 
   246     response: &mut Response,
 
   248     response: &mut Response,
 
   247 ) {
 
   249 ) {
 
   248     let room = &server.rooms[room_id];
 
   250     let room = &server.rooms[room_id];
 
   249     if let Some(id) = room.master_id {
 
   251     if let Some(id) = room.master_id {
 
   250         response.add(
 
   252         response.add(
 
   251             ClientFlags("+h".to_string(), vec![server.clients[id].nick.clone()]).send(to_client),
 
   253             ClientFlags(
 
       
   254                 add_flags(&[Flags::RoomMaster]),
 
       
   255                 vec![server.clients[id].nick.clone()],
 
       
   256             )
 
       
   257             .send(to_client),
 
   252         );
 
   258         );
 
   253     }
 
   259     }
 
   254     let nicks: Vec<_> = server
 
   260     let nicks: Vec<_> = server
 
   255         .clients
 
   261         .clients
 
   256         .iter()
 
   262         .iter()
 
   257         .filter(|(_, c)| c.room_id == Some(room_id) && c.is_ready())
 
   263         .filter(|(_, c)| c.room_id == Some(room_id) && c.is_ready())
 
   258         .map(|(_, c)| c.nick.clone())
 
   264         .map(|(_, c)| c.nick.clone())
 
   259         .collect();
 
   265         .collect();
 
   260     if !nicks.is_empty() {
 
   266     if !nicks.is_empty() {
 
   261         response.add(ClientFlags("+r".to_string(), nicks).send(to_client));
 
   267         response.add(ClientFlags(add_flags(&[Flags::Ready]), nicks).send(to_client));
 
   262     }
 
   268     }
 
   263 }
 
   269 }
 
   264 
   270 
   265 pub fn apply_voting_result(
 
   271 pub fn apply_voting_result(
 
   266     server: &mut HWServer,
 
   272     server: &mut HWServer,
 
   407             c.set_is_in_game(false);
 
   413             c.set_is_in_game(false);
 
   408             c.team_indices = room.client_team_indices(c.id);
 
   414             c.team_indices = room.client_team_indices(c.id);
 
   409         }
 
   415         }
 
   410         response.add(RunGame.send_all().in_room(room.id));
 
   416         response.add(RunGame.send_all().in_room(room.id));
 
   411         response.add(
 
   417         response.add(
 
   412             ClientFlags("+g".to_string(), room_nicks)
 
   418             ClientFlags(add_flags(&[Flags::InGame]), room_nicks)
 
   413                 .send_all()
 
   419                 .send_all()
 
   414                 .in_room(room.id),
 
   420                 .in_room(room.id),
 
   415         );
 
   421         );
 
   416 
   422 
   417         let room_master = if let Some(id) = room.master_id {
 
   423         let room_master = if let Some(id) = room.master_id {
 
   467 
   473 
   468     if !nicks.is_empty() {
 
   474     if !nicks.is_empty() {
 
   469         let msg = if room.protocol_number < 38 {
 
   475         let msg = if room.protocol_number < 38 {
 
   470             LegacyReady(false, nicks)
 
   476             LegacyReady(false, nicks)
 
   471         } else {
 
   477         } else {
 
   472             ClientFlags("-r".to_string(), nicks)
 
   478             ClientFlags(remove_flags(&[Flags::Ready]), nicks)
 
   473         };
 
   479         };
 
   474         response.add(msg.send_all().in_room(room_id));
 
   480         response.add(msg.send_all().in_room(room_id));
 
   475     }
 
   481     }
 
   476 }
 
   482 }
 
   477 
   483
hedgewars-draft