Rename SendMode to SendTargets

Shatur · Shatur · commit 4494f2b62f25 · 2026-05-15T23:40:42.000+03:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -17,6 +17,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `ServerMessages::retain_sent` is now public, allowing users to filter outbound messages before the backend drains them.
 - `VisibilityFilter` trait and related types moved to the `shared::replication::visibility` module and no longer feature gated by the `server` feature.
 - `Replicated` is no longer automatically inserted on clients, only `Remote`. `scene::replicate_into` will serialize all entities that have either `Remote` or `Replicated`.
+- Rename `SendMode::Broadcast` into `SendTargets::All`
+- Rename `SendMode::BroadcastExcept` into `SendTargets::AllExcept`
+- Rename `SendMode::Direct` into `SendTargets::Single`
+- Rename `ToClients::mode` into `ToClients::targets`
 
 ## [0.39.5] - 2026-04-26
 
diff --git a/example_backend/tests/backend.rs b/example_backend/tests/backend.rs
@@ -66,7 +66,7 @@ fn disconnect_request() {
 
     server_app.world_mut().spawn(Replicated);
     server_app.world_mut().write_message(ToClients {
-        mode: SendMode::Broadcast,
+        targets: SendTargets::All,
         message: Test,
     });
 
@@ -117,7 +117,7 @@ fn server_stop() {
     server_app.world_mut().remove_resource::<ExampleServer>();
     server_app.world_mut().spawn(Replicated);
     server_app.world_mut().write_message(ToClients {
-        mode: SendMode::Broadcast,
+        targets: SendTargets::All,
         message: Test,
     });
 
@@ -190,7 +190,7 @@ fn server_message() {
     setup(&mut server_app, &mut client_app).unwrap();
 
     server_app.world_mut().write_message(ToClients {
-        mode: SendMode::Broadcast,
+        targets: SendTargets::All,
         message: Test,
     });
 
diff --git a/src/lib.rs b/src/lib.rs
@@ -405,7 +405,7 @@ app.add_server_message::<Pong>(Channel::Ordered)
 
 fn send(mut pongs: MessageWriter<ToClients<Pong>>) {
     pongs.write(ToClients {
-        mode: SendMode::Broadcast,
+        targets: SendTargets::All,
         message: Pong,
     });
 }
@@ -438,7 +438,7 @@ app.add_server_event::<Pong>(Channel::Ordered)
 
 fn send(mut commands: Commands) {
     commands.server_trigger(ToClients {
-        mode: SendMode::Broadcast,
+        targets: SendTargets::All,
         message: Pong,
     });
 }
@@ -736,7 +736,7 @@ pub mod prelude {
                 client_event::{ClientEventAppExt, ClientTriggerExt},
                 client_message::{ClientMessageAppExt, FromClient},
                 server_event::{ServerEventAppExt, ServerTriggerExt},
-                server_message::{SendMode, ServerMessageAppExt, ToClients},
+                server_message::{SendTargets, ServerMessageAppExt, ToClients},
             },
             protocol::{ProtocolHash, ProtocolHasher, ProtocolMismatch},
             replication::{
diff --git a/src/server.rs b/src/server.rs
@@ -255,7 +255,7 @@ fn check_protocol(
             **client_protocol, *protocol
         );
         commands.server_trigger(ToClients {
-            mode: SendMode::Direct(client_protocol.client_id),
+            targets: SendTargets::Single(client_protocol.client_id),
             message: ProtocolMismatch,
         });
         disconnects.write(DisconnectRequest { client });
diff --git a/src/shared.rs b/src/shared.rs
@@ -75,7 +75,7 @@ pub struct RepliconSharedPlugin {
             // Notify the client about the problem. No delivery
             // guarantee, since we disconnect after sending.
             commands.server_trigger(ToClients {
-                mode: SendMode::Direct(client_info.client_id),
+                targets: SendTargets::Single(client_info.client_id),
                 message: ProtocolMismatch,
             });
             disconnects.write(DisconnectRequest { client });
diff --git a/src/shared/message/server_event.rs b/src/shared/message/server_event.rs
@@ -191,7 +191,7 @@ pub trait ServerTriggerExt {
 impl ServerTriggerExt for Commands<'_, '_> {
     fn server_trigger(&mut self, event: ToClients<impl Event>) {
         self.write_message(ToClients {
-            mode: event.mode,
+            targets: event.targets,
             message: ServerTriggerEvent {
                 event: event.message,
             },
@@ -202,7 +202,7 @@ impl ServerTriggerExt for Commands<'_, '_> {
 impl ServerTriggerExt for World {
     fn server_trigger(&mut self, event: ToClients<impl Event>) {
         self.write_message(ToClients {
-            mode: event.mode,
+            targets: event.targets,
             message: ServerTriggerEvent {
                 event: event.message,
             },
diff --git a/src/shared/message/server_message.rs b/src/shared/message/server_message.rs
@@ -335,30 +335,33 @@ impl ServerMessage {
         let to_messages: &Messages<ToClients<M>> = unsafe { to_messages.deref() };
         // For server messages we don't track read message because
         // all of them will always be drained in the local sending system.
-        for ToClients { message, mode } in to_messages.get_cursor().read(to_messages) {
-            debug!("sending message `{}` with `{mode:?}`", ShortName::of::<M>());
+        for ToClients { message, targets } in to_messages.get_cursor().read(to_messages) {
+            debug!(
+                "sending message `{}` for `{targets:?}`",
+                ShortName::of::<M>()
+            );
 
             if self.independent {
                 unsafe {
                     self.send_independent_message::<M, I>(
                         ctx,
                         message,
-                        mode,
+                        *targets,
                         server_messages,
                         clients,
                     )
                     .expect("independent server message should be serializable");
                 }
             } else {
                 unsafe {
-                    self.buffer_message::<M, I>(ctx, message, *mode, message_buffer)
+                    self.buffer_message::<M, I>(ctx, message, *targets, message_buffer)
                         .expect("server message should be serializable");
                 }
             }
         }
     }
 
-    /// Sends independent remote message `M` based on a mode.
+    /// Sends independent remote message `M` to the given targets.
     ///
     /// # Safety
     ///
@@ -369,28 +372,28 @@ impl ServerMessage {
         &self,
         ctx: &mut ServerSendCtx,
         message: &M,
-        mode: &SendMode,
+        targets: SendTargets,
         server_messages: &mut ServerMessages,
         clients: &Query<Entity, With<ConnectedClient>>,
     ) -> Result<()> {
         let mut message_bytes = Vec::new();
         unsafe { self.serialize::<M, I>(ctx, message, &mut message_bytes)? }
         let message_bytes: Bytes = message_bytes.into();
 
-        match *mode {
-            SendMode::Broadcast => {
+        match targets {
+            SendTargets::All => {
                 for client in clients {
                     server_messages.send(client, self.channel_id, message_bytes.clone());
                 }
             }
-            SendMode::BroadcastExcept(ignored_id) => {
+            SendTargets::AllExcept(ignored_id) => {
                 for client in clients {
                     if ignored_id != client.into() {
                         server_messages.send(client, self.channel_id, message_bytes.clone());
                     }
                 }
             }
-            SendMode::Direct(client_id) => {
+            SendTargets::Single(client_id) => {
                 if let ClientId::Client(client) = client_id {
                     server_messages.send(client, self.channel_id, message_bytes.clone());
                 }
@@ -400,7 +403,7 @@ impl ServerMessage {
         Ok(())
     }
 
-    /// Buffers message `M` based on mode.
+    /// Buffers message `M` for the given targets.
     ///
     /// # Safety
     ///
@@ -411,11 +414,11 @@ impl ServerMessage {
         &self,
         ctx: &mut ServerSendCtx,
         message: &M,
-        mode: SendMode,
+        targets: SendTargets,
         message_buffer: &mut MessageBuffer,
     ) -> Result<()> {
         let message_bytes = unsafe { self.serialize_with_padding::<M, I>(ctx, message)? };
-        message_buffer.insert(mode, self.channel_id, message_bytes);
+        message_buffer.insert(targets, self.channel_id, message_bytes);
         Ok(())
     }
 
@@ -545,18 +548,18 @@ impl ServerMessage {
     unsafe fn send_locally_typed<M: Message>(to_messages: PtrMut, messages: PtrMut) {
         let to_messages: &mut Messages<ToClients<M>> = unsafe { to_messages.deref_mut() };
         let messages: &mut Messages<M> = unsafe { messages.deref_mut() };
-        for ToClients { message, mode } in to_messages.drain() {
+        for ToClients { message, targets } in to_messages.drain() {
             debug!("writing message `{}` locally", ShortName::of::<M>());
-            match mode {
-                SendMode::Broadcast => {
+            match targets {
+                SendTargets::All => {
                     messages.write(message);
                 }
-                SendMode::BroadcastExcept(ignored_id) => {
+                SendTargets::AllExcept(ignored_id) => {
                     if ignored_id != ClientId::Server {
                         messages.write(message);
                     }
                 }
-                SendMode::Direct(client_id) => {
+                SendTargets::Single(client_id) => {
                     if client_id == ClientId::Server {
                         messages.write(message);
                     }
@@ -672,7 +675,7 @@ type ResetFn = unsafe fn(PtrMut);
 #[derive(Event, Message, Deref, DerefMut, Debug, Clone, Copy)]
 pub struct ToClients<T> {
     /// Recipients.
-    pub mode: SendMode,
+    pub targets: SendTargets,
 
     /// Transmitted message.
     #[deref]
@@ -685,28 +688,32 @@ impl<E: EntityEvent> EntityEvent for ToClients<E> {
     }
 }
 
-/// Type of server message sending.
+/// Recipients of a server message.
 #[derive(Clone, Copy, Debug)]
-pub enum SendMode {
+pub enum SendTargets {
     /// Send to every client.
     ///
     /// This will also send the message locally to support listen server configuration.
     /// Use [`Self::CLIENTS_ONLY`] if you want to send messages only to the clients.
-    Broadcast,
-    /// Send to every client except the specified connected client.
-    BroadcastExcept(ClientId),
+    All,
+    /// Send to everyone except this client.
+    AllExcept(ClientId),
     /// Send only to the specified client.
-    Direct(ClientId),
+    Single(ClientId),
 }
 
-impl SendMode {
+impl SendTargets {
     /// Send to every client except the listen server.
-    pub const CLIENTS_ONLY: SendMode = SendMode::BroadcastExcept(ClientId::Server);
+    pub const CLIENTS_ONLY: SendTargets = SendTargets::AllExcept(ClientId::Server);
 
     /// Send only to the server.
-    pub const SERVER_ONLY: SendMode = SendMode::Direct(ClientId::Server);
+    pub const SERVER_ONLY: SendTargets = SendTargets::Single(ClientId::Server);
 }
 
+/// A deprecated alias for [`SendTargets`].
+#[deprecated(note = "renamed to `SendTargets`")]
+pub type SendMode = SendTargets;
+
 /// Default message serialization function.
 pub fn default_serialize<M: Serialize>(
     _ctx: &mut ServerSendCtx,
diff --git a/src/shared/message/server_message/message_buffer.rs b/src/shared/message/server_message/message_buffer.rs
@@ -31,13 +31,18 @@ impl MessageBuffer {
         self.ticks.last_mut()
     }
 
-    pub(super) fn insert(&mut self, mode: SendMode, channel_id: usize, message: SerializedMessage) {
+    pub(super) fn insert(
+        &mut self,
+        targets: SendTargets,
+        channel_id: usize,
+        message: SerializedMessage,
+    ) {
         let buffer = self
             .active_tick()
             .expect("`start_tick` should be called before buffering");
 
         buffer.messages.push(BufferedMessage {
-            mode,
+            targets,
             channel_id,
             message,
         });
@@ -57,8 +62,8 @@ impl MessageBuffer {
     ) -> Result<()> {
         for mut tick in self.ticks.drain(..) {
             for mut message in tick.messages.drain(..) {
-                match message.mode {
-                    SendMode::Broadcast => {
+                match message.targets {
+                    SendTargets::All => {
                         for (client, ticks) in
                             clients.iter().filter(|(e, _)| !tick.excluded.contains(e))
                         {
@@ -72,7 +77,7 @@ impl MessageBuffer {
                             }
                         }
                     }
-                    SendMode::BroadcastExcept(ignored_id) => {
+                    SendTargets::AllExcept(ignored_id) => {
                         for (client, ticks) in
                             clients.iter().filter(|(c, _)| !tick.excluded.contains(c))
                         {
@@ -90,7 +95,7 @@ impl MessageBuffer {
                             }
                         }
                     }
-                    SendMode::Direct(client_id) => {
+                    SendTargets::Single(client_id) => {
                         if let ClientId::Client(client) = client_id
                             && let Ok((_, ticks)) = clients.get(client)
                             && !tick.excluded.contains(&client)
@@ -136,7 +141,7 @@ impl TickMessages {
 }
 
 struct BufferedMessage {
-    mode: SendMode,
+    targets: SendTargets,
     channel_id: usize,
     message: SerializedMessage,
 }
diff --git a/tests/bidirectional_event.rs b/tests/bidirectional_event.rs
@@ -26,7 +26,7 @@ fn message() {
 
     client_app.world_mut().write_message(Test);
     server_app.world_mut().write_message(ToClients {
-        mode: SendMode::Broadcast,
+        targets: SendTargets::All,
         message: Test,
     });
 
@@ -72,7 +72,7 @@ fn event() {
 
     client_app.world_mut().client_trigger(Test);
     server_app.world_mut().server_trigger(ToClients {
-        mode: SendMode::Broadcast,
+        targets: SendTargets::All,
         message: Test,
     });
 
diff --git a/tests/server_event.rs b/tests/server_event.rs
@@ -24,7 +24,7 @@ fn regular() {
     server_app.connect_client(&mut client_app);
 
     server_app.world_mut().server_trigger(ToClients {
-        mode: SendMode::Broadcast,
+        targets: SendTargets::All,
         message: Test,
     });
 
@@ -56,7 +56,7 @@ fn mapped() {
     let server_entity = server_app.world_mut().spawn(Replicated).id();
 
     server_app.world_mut().server_trigger(ToClients {
-        mode: SendMode::Broadcast,
+        targets: SendTargets::All,
         message: WithEntity(server_entity),
     });
 
@@ -108,7 +108,7 @@ fn without_plugins() {
     server_app.connect_client(&mut client_app);
 
     server_app.world_mut().server_trigger(ToClients {
-        mode: SendMode::Broadcast,
+        targets: SendTargets::All,
         message: Test,
     });
 
@@ -133,7 +133,7 @@ fn local_sending() {
     app.init_resource::<EventReader<Test>>();
 
     app.world_mut().server_trigger(ToClients {
-        mode: SendMode::Broadcast,
+        targets: SendTargets::All,
         message: Test,
     });
 
@@ -181,11 +181,11 @@ fn independent() {
     *client_app.world_mut().resource_mut::<ServerUpdateTick>() = Default::default();
 
     server_app.world_mut().server_trigger(ToClients {
-        mode: SendMode::Broadcast,
+        targets: SendTargets::All,
         message: Test,
     });
     server_app.world_mut().server_trigger(ToClients {
-        mode: SendMode::Broadcast,
+        targets: SendTargets::All,
         message: Independent,
     });
 
diff --git a/tests/server_message.rs b/tests/server_message.rs

Original file line number	Diff line number	Diff line change
`@@ -31,13 +31,18 @@ impl MessageBuffer {`
`31`	`31`	`self.ticks.last_mut()`
`32`	`32`	`}`
`33`	`33`
`34`		`- pub(super) fn insert(&mut self, mode: SendMode, channel_id: usize, message: SerializedMessage) {`
	`34`	`+ pub(super) fn insert(`
	`35`	`+ &mut self,`
	`36`	`+ targets: SendTargets,`
	`37`	`+ channel_id: usize,`
	`38`	`+ message: SerializedMessage,`
	`39`	`+ ) {`
`35`	`40`	`let buffer = self`
`36`	`41`	`.active_tick()`
`37`	`42`	.expect("`start_tick` should be called before buffering");
`38`	`43`
`39`	`44`	`buffer.messages.push(BufferedMessage {`
`40`		`- mode,`
	`45`	`+ targets,`
`41`	`46`	`channel_id,`
`42`	`47`	`message,`
`43`	`48`	`});`
`@@ -57,8 +62,8 @@ impl MessageBuffer {`
`57`	`62`	`) -> Result<()> {`
`58`	`63`	`for mut tick in self.ticks.drain(..) {`
`59`	`64`	`for mut message in tick.messages.drain(..) {`
`60`		`- match message.mode {`
`61`		`- SendMode::Broadcast => {`
	`65`	`+ match message.targets {`
	`66`	`+ SendTargets::All => {`
`62`	`67`	`for (client, ticks) in`
`63`	`68`	`clients.iter().filter(\|(e, _)\| !tick.excluded.contains(e))`
`64`	`69`	`{`
`@@ -72,7 +77,7 @@ impl MessageBuffer {`
`72`	`77`	`}`
`73`	`78`	`}`
`74`	`79`	`}`
`75`		`- SendMode::BroadcastExcept(ignored_id) => {`
	`80`	`+ SendTargets::AllExcept(ignored_id) => {`
`76`	`81`	`for (client, ticks) in`
`77`	`82`	`clients.iter().filter(\|(c, _)\| !tick.excluded.contains(c))`
`78`	`83`	`{`
`@@ -90,7 +95,7 @@ impl MessageBuffer {`
`90`	`95`	`}`
`91`	`96`	`}`
`92`	`97`	`}`
`93`		`- SendMode::Direct(client_id) => {`
	`98`	`+ SendTargets::Single(client_id) => {`
`94`	`99`	`if let ClientId::Client(client) = client_id`
`95`	`100`	`&& let Ok((_, ticks)) = clients.get(client)`
`96`	`101`	`&& !tick.excluded.contains(&client)`
`@@ -136,7 +141,7 @@ impl TickMessages {`
`136`	`141`	`}`
`137`	`142`
`138`	`143`	`struct BufferedMessage {`
`139`		`- mode: SendMode,`
	`144`	`+ targets: SendTargets,`
`140`	`145`	`channel_id: usize,`
`141`	`146`	`message: SerializedMessage,`
`142`	`147`	`}`