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

use std::borrow::Cow;
use std::sync::mpsc::{Receiver, Sender};
use std::time::Duration;

use bevy::math::Vec3A;
use bevy::prelude::{IntoExclusiveSystem, Plugin, SystemSet};
use futures_util::Future;

use self::asynchronous::RemoteThreadError;
use self::message::distributor;

pub use bevy;
pub use futures_util;
pub use quinn;
pub use rcgen;
pub use rustls;
pub use tokio;

pub use self::interface::{Interface, InterfaceError, StreamCounter, StreamId};
pub use self::message::{
    AppRegisterMsgExt, DefaultMessages, Message, MessageReceived, MessageWriter, ReflectMessage,
    ReflectMessageFromReflect, RegisterMessage,
};
pub use self::serde::{ReflectObject, RemoteEntity};

pub mod asynchronous;
mod interface;
pub mod message;
pub mod serde;
pub mod systems;

pub struct CommonPlugin<
    Run: 'static
        + Fn(
            Receiver<(StreamId, Box<dyn Message>)>,
            Sender<(StreamId, Box<dyn Message>)>,
            StreamCounter,
        ) -> F
        + Send
        + Sync
        + Copy,
    F: 'static + Future<Output = Result<(), RemoteThreadError>>,
>(pub Run);

impl<
        Run: 'static
            + Fn(
                Receiver<(StreamId, Box<dyn Message>)>,
                Sender<(StreamId, Box<dyn Message>)>,
                StreamCounter,
            ) -> F
            + Send
            + Sync
            + Copy,
        F: 'static + Future<Output = Result<(), RemoteThreadError>>,
    > Plugin for CommonPlugin<Run, F>
{
    fn build(&self, app: &mut bevy::prelude::App) {
        app.insert_resource(StreamCounter::default())
            .add_startup_system(asynchronous::open_remote_thread(self.0).exclusive_system())
            .add_system_set(
                SystemSet::new()
                    .with_run_criteria(systems::run_on_timer(Duration::from_secs(1)))
                    .with_system(systems::monitor_remote_thread(self.0).exclusive_system()),
            )
            .add_distributor()
            .add_messages::<DefaultMessages>()
            .add_system(distributor::distribute_messages.exclusive_system())
            .add_system(distributor::collect_messages.exclusive_system())
            .register_type::<Cow<'static, str>>()
            .register_type::<Vec3A>();
    }
}

// TODO: These won't be necessary forever
pub fn server_addr() -> std::net::SocketAddr {
    "127.0.0.1:5001".parse().unwrap()
}

pub fn client_addr() -> std::net::SocketAddr {
    "127.0.0.1:5000".parse().unwrap()
}