1 use crate::{

     2     core::{

     3         client::HWClient,

     4         server::HWServer,

     5         types::{ClientId, GameCfg, RoomId, VoteType},

     6         room::HWRoom,

     7         room::{GameInfo, RoomFlags}

     8     },

     9     protocol::messages::{server_chat, HWProtocolMessage, HWServerMessage, HWServerMessage::*},

    10     utils::to_engine_msg,

    11 };

    12 use rand::{distributions::Uniform, thread_rng, Rng};

    13 use std::{io, io::Write, iter::once, mem::replace};

    14 

    15 pub enum DestinationGroup {

    16     All,

    17     Lobby,

    18     Room(RoomId),

    19     Protocol(u16),

    20 }

    21 

    22 pub enum Destination {

    23     ToId(ClientId),

    24     ToIds(Vec<ClientId>),

    25     ToSelf,

    26     ToAll {

    27         group: DestinationGroup,

    28         skip_self: bool,

    29     },

    30 }

    31 

    32 pub struct PendingMessage {

    33     pub destination: Destination,

    34     pub message: HWServerMessage,

    35 }

    36 

    37 impl PendingMessage {

    38     pub fn send(message: HWServerMessage, client_id: ClientId) -> PendingMessage {

    39         PendingMessage {

    40             destination: Destination::ToId(client_id),

    41             message,

    42         }

    43     }

    44 

    45     pub fn send_many(message: HWServerMessage, client_ids: Vec<ClientId>) -> PendingMessage {

    46         PendingMessage {

    47             destination: Destination::ToIds(client_ids),

    48             message,

    49         }

    50     }

    51 

    52     pub fn send_self(message: HWServerMessage) -> PendingMessage {

    53         PendingMessage {

    54             destination: Destination::ToSelf,

    55             message,

    56         }

    57     }

    58 

    59     pub fn send_all(message: HWServerMessage) -> PendingMessage {

    60         let destination = Destination::ToAll {

    61             group: DestinationGroup::All,

    62             skip_self: false,

    63         };

    64         PendingMessage {

    65             destination,

    66             message,

    67         }

    68     }

    69 

    70     pub fn in_room(mut self, clients_room_id: RoomId) -> PendingMessage {

    71         if let Destination::ToAll { ref mut group, .. } = self.destination {

    72             *group = DestinationGroup::Room(clients_room_id)

    73         }

    74         self

    75     }

    76 

    77     pub fn in_lobby(mut self) -> PendingMessage {

    78         if let Destination::ToAll { ref mut group, .. } = self.destination {

    79             *group = DestinationGroup::Lobby

    80         }

    81         self

    82     }

    83 

    84     pub fn with_protocol(mut self, protocol_number: u16) -> PendingMessage {

    85         if let Destination::ToAll { ref mut group, .. } = self.destination {

    86             *group = DestinationGroup::Protocol(protocol_number)

    87         }

    88         self

    89     }

    90 

    91     pub fn but_self(mut self) -> PendingMessage {

    92         if let Destination::ToAll {

    93             ref mut skip_self, ..

    94         } = self.destination

    95         {

    96             *skip_self = true

    97         }

    98         self

    99     }

   100 }

   101 

   102 impl HWServerMessage {

   103     pub fn send(self, client_id: ClientId) -> PendingMessage {

   104         PendingMessage::send(self, client_id)

   105     }

   106     pub fn send_many(self, client_ids: Vec<ClientId>) -> PendingMessage {

   107         PendingMessage::send_many(self, client_ids)

   108     }

   109     pub fn send_self(self) -> PendingMessage {

   110         PendingMessage::send_self(self)

   111     }

   112     pub fn send_all(self) -> PendingMessage {

   113         PendingMessage::send_all(self)

   114     }

   115 }