bevy_connect 0.18.6

Connectivity via TCP sessions
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use crate::ClientId;
use bevy_ecs::prelude::*;

use crate::Message;
use crate::channel::{Channel, SessionConfig};
use crate::events::{SessionConnectedEvent, SessionDisconnectedEvent};
use std::marker::PhantomData;
use std::net::{IpAddr, Ipv4Addr, SocketAddr};
use tracing::debug;
use tracing::error;

/// Starts a new connection based on the passed [`SessionConfig`].
/// Issuing a connection with an already existing connected resource will just
/// replace the existing connection (disconnecting the old) with another.
/// A disconnect + connect event will occur in that case.
/// They are unique by type T.
pub struct SessionConnectCommand<T: Message> {
    config: SessionConfig,
    _t: PhantomData<T>,
}

impl<T: Message> Command for SessionConnectCommand<T> {
    fn apply(self, world: &mut World) {
        let SessionConfig::Direct {
            addr,
            port,
            host,
            compress: _,
            key: _,
            options: _,
        } = self.config;
        let addr = addr.unwrap_or(IpAddr::V4(Ipv4Addr::UNSPECIFIED));
        let addr = SocketAddr::from((addr, port));
        if host {
            debug!("Creating new host to {addr}...");
            let channel = Channel::<T>::new_host(&self.config);
            let Ok(channel) = channel else {
                error!("Could not connect to host {addr}");
                return;
            };
            let uuid = channel.uuid();
            world.insert_resource(channel);
            world.write_message(SessionConnectedEvent::<T> { _t: PhantomData });
            debug!("Host created on {addr} with uuid {uuid}.");
        } else {
            debug!("Connecting new client to {addr}...");
            let channel = Channel::<T>::try_new_client(&self.config);
            let Ok(channel) = channel else {
                error!("Could not connect to host {addr}");
                return;
            };
            let uuid = channel.uuid();
            world.insert_resource(channel);
            world.write_message(SessionConnectedEvent::<T> { _t: PhantomData });
            debug!("Client connected to {addr} with uuid {uuid}.");
        }
    }
}

impl<T: Message> SessionConnectCommand<T> {
    #[must_use]
    pub fn from_config(config: SessionConfig) -> Self {
        Self {
            config,
            _t: PhantomData,
        }
    }
}

/// Disconnects the current typed T connection. If there was no connection,
/// this is a no-op.
pub struct SessionDisconnectCommand<T: Message> {
    _t: PhantomData<T>,
}

impl<T: Message> Default for SessionDisconnectCommand<T> {
    fn default() -> Self {
        Self { _t: PhantomData }
    }
}

impl<T: Message> Command for SessionDisconnectCommand<T> {
    fn apply(self, world: &mut World) {
        debug!("Disconnecting channel...");
        if let Some(c) = world.remove_resource::<Channel<T>>() {
            drop(c);
        }
        world.write_message(SessionDisconnectedEvent::<T> { _t: PhantomData });
        debug!("Channel disconnected.");
    }
}

/// Promotes one of the clients to a host
/// All the other participants will then become clients to this new host.
/// The session is considered unaltered, the uuids will be staying the same.
/// The [`Channel::host_uuid`] will return the new host as the uuid once the
/// process is complete.
pub struct SessionPromoteToHostCommand<T: Message> {
    pub(crate) new_host: ClientId,
    pub(crate) port: Option<u16>,
    _t: PhantomData<T>,
}

impl<T: Message> SessionPromoteToHostCommand<T> {
    #[must_use]
    pub fn new(new_host: ClientId, port: Option<u16>) -> Self {
        Self {
            new_host,
            port,
            _t: PhantomData,
        }
    }
}

impl<T: Message> Command for SessionPromoteToHostCommand<T> {
    fn apply(self, world: &mut World) {
        let mut channel = world.resource_mut::<Channel<T>>();
        channel.promote_new_host(self.new_host, self.port);
    }
}