lightyear_steam 0.22.4

Connection handling for the lightyear networking library
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
121
122
123
124
125

use aeronet_io::connection::PeerAddr;
use aeronet_steam::client::SteamNetClient;
use aeronet_steam::steamworks::ClientManager;
use aeronet_steam::{
    SessionConfig, SteamworksClient,
    client::{ConnectTarget, SteamNetClientPlugin},
};
use bevy_app::{App, Plugin};
use bevy_ecs::component::HookContext;
use bevy_ecs::prelude::{OnAdd, With};
use bevy_ecs::world::DeferredWorld;
use bevy_ecs::{
    error::Result,
    prelude::{Commands, Component, Entity, EntityCommand, Name, Query, Trigger, Without, World},
};
use lightyear_aeronet::{AeronetLinkOf, AeronetPlugin};
use lightyear_connection::client::{Connected, Disconnect};
use lightyear_core::id::{LocalId, PeerId, RemoteId};
use lightyear_link::{Link, LinkStart, Linked, Linking, Unlink};
use std::prelude::rust_2015::ToString;
use tracing::trace;

pub struct SteamClientPlugin;

impl Plugin for SteamClientPlugin {
    fn build(&self, app: &mut App) {
        if !app.is_plugin_added::<AeronetPlugin>() {
            app.add_plugins(AeronetPlugin);
        }
        app.add_plugins(SteamNetClientPlugin::<ClientManager>::default());
        app.add_observer(Self::link);
        app.add_observer(Self::on_linked);
        app.add_observer(Self::disconnect);
    }
}

/// Component to insert on an entity to start a Steam  socket client which
/// can connect to a dedicated server or another peer.
///
/// The [`SteamworksClient`] resource must have been created beforehand.
#[derive(Debug, Component)]
#[component(on_add = SteamClientIo::on_add)]
#[require(Link)]
pub struct SteamClientIo {
    pub target: ConnectTarget,
    pub config: SessionConfig,
}

impl SteamClientIo {
    /// When we add the SteamClientIo component, we will also add a LocalId component
    fn on_add(mut world: DeferredWorld, context: HookContext) {
        let entity = context.entity;
        let local_steam_id = world.resource::<SteamworksClient>().0.user().steam_id();
        world
            .commands()
            .entity(entity)
            .insert(LocalId(PeerId::Steam(local_steam_id.raw())));
    }
}

impl SteamClientPlugin {
    fn link(
        trigger: Trigger<LinkStart>,
        query: Query<(Entity, &SteamClientIo), (Without<Linking>, Without<Linked>)>,
        mut commands: Commands,
    ) -> Result {
        if let Ok((entity, client)) = query.get(trigger.target()) {
            let config = client.config.clone();
            let target = client.target;
            commands.queue(move |world: &mut World| -> Result {
                let mut link_entity_mut = world.entity_mut(entity);
                match target {
                    ConnectTarget::Addr(peer_addr) => {
                        link_entity_mut.insert(PeerAddr(peer_addr));

                        // TODO: we need a RemoteId here. Maybe SteamP2PAddr?
                        link_entity_mut.insert(RemoteId(PeerId::Server));
                    }
                    ConnectTarget::Peer { steam_id, .. } => {
                        link_entity_mut.insert(RemoteId(PeerId::Steam(steam_id.raw())));
                    }
                }
                let entity_mut =
                    world.spawn((
                        AeronetLinkOf(entity),
                        Name::from("SteamClient")
                    ));
                let aeronet_entity = entity_mut.id();
                trace!("Starting LinkStart for SteamClientIo on entity {entity:?}. Spawning aeronet entity: {aeronet_entity:?}");

                // TODO: also add LocalAddr or LocalId components
                SteamNetClient::<ClientManager>::connect(config, target).apply(entity_mut);
                Ok(())
            });
        }
        Ok(())
    }

    /// Steam is both a Link and a Connection, so we add Connected when Linked is added
    fn on_linked(
        trigger: Trigger<OnAdd, Linked>,
        query: Query<(), With<SteamClientIo>>,
        mut commands: Commands,
    ) {
        if query.get(trigger.target()).is_ok() {
            commands.entity(trigger.target()).insert(Connected);
        }
    }

    /// Steam is both a Link and a Connection, so we trigger Unlink when Disconnect is triggered
    fn disconnect(
        trigger: Trigger<Disconnect>,
        query: Query<(), With<SteamClientIo>>,
        mut commands: Commands,
    ) {
        if query.get(trigger.target()).is_ok() {
            commands.trigger_targets(
                Unlink {
                    reason: "User requested disconnect".to_string(),
                },
                trigger.target(),
            );
        }
    }
}