Orthros/orthros-server/src/main.rs

pub mod temporal_management;
use bevy::{
    prelude::*,
    render::{RenderPlugin, settings::WgpuSettings, view::Hdr},
    time::common_conditions::on_timer,
};
use bevy_matchbox::{matchbox_signaling::SignalingServer, prelude::*};
use orthros_network::{
    generic::EntityID,
    starchart::star::{STARS, StarClass, StarInfo, star_diameter_range},
};
use rand::{
    Rng,
    distr::{Distribution, Uniform},
    rng,
};
use std::{
    collections::HashSet,
    net::{Ipv4Addr, SocketAddrV4},
    time::Duration,
};
const CHANNEL_ID: usize = 0;
#[derive(Component)]
struct NetworkObject;
#[derive(Component)]
struct Changed;
fn main() {
    App::new()
        .add_plugins((DefaultPlugins.set(RenderPlugin {
            render_creation: WgpuSettings {
                backends: None,
                ..default()
            }
            .into(),
            ..default()
        }),))
        .add_systems(
            Startup,
            (
                start_signaling_server,
                start_socket.after(start_signaling_server),
                setup_scene.after(start_socket),
            ),
        )
        .add_systems(
            Update,
            (
                receive_messages,
                send_message.run_if(on_timer(Duration::from_secs(5))),
            ),
        )
        .run();
}
fn start_signaling_server(mut commands: Commands) {
    info!("Starting signaling server");
    let addr = SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, 3536);
    let signaling_server = MatchboxServer::from(
        SignalingServer::client_server_builder(addr)
            .on_connection_request(|connection| {
                info!("Connecting: {connection:?}");
                Ok(true) // Allow all connections
            })
            .on_id_assignment(|(socket, id)| info!("{socket} received {id}"))
            .on_host_connected(|id| info!("Host joined: {id}"))
            .on_host_disconnected(|id| info!("Host left: {id}"))
            .on_client_connected(|id| info!("Client joined: {id}"))
            .on_client_disconnected(|id| info!("Client left: {id}"))
            .cors()
            .trace()
            .build(),
    );
    commands.insert_resource(signaling_server);
}

fn setup_scene(mut commands: Commands, mut socket: ResMut<MatchboxSocket>) {
    let mut spawned_ids: HashSet<u32> = HashSet::new();
    for _ in 0..4 {
        let x = Uniform::try_from(-2000..2000).unwrap().sample(&mut rng());
        let z = Uniform::try_from(-8000..8000).unwrap().sample(&mut rng());
        let star_class: StarClass = match rng().random_range(0..2) {
            0 => StarClass::MType,
            1 => StarClass::BType,
            2 => StarClass::GType,
            _ => todo!(),
        };
        let mut id: u32 = rng().random();
        while spawned_ids.contains(&id) {
            id = rng().random();
        }
        spawned_ids.insert(id);
        info!("{:?}", star_diameter_range(&star_class));
        let star_info = StarInfo {
            id: EntityID(id),
            name: STARS[(rng().random_range(0..100)) as usize].to_string(),
            diameter: rng().random_range(star_diameter_range(&star_class)),
            class: star_class,
            transform: Transform::from_xyz(x as f32 / 100.0, z as f32 / 20000.0, z as f32 / 100.0),
        };

        commands.spawn((StarInfoComp(star_info), NetworkObject, Changed));
        let peers: Vec<_> = socket.connected_peers().collect();

        for peer in peers {
            let message = "Hello";
            info!("Sending message: {message:?} to {peer}");
            socket
                .channel_mut(CHANNEL_ID)
                .send(message.as_bytes().into(), peer);
        }
    }
}
fn on_client_connect(mut socket: ResMut<MatchboxSocket>, Query<&StarInfo>)
fn start_socket(mut commands: Commands) {
    let socket = MatchboxSocket::new_reliable("ws://localhost:3536/hello");
    info!("Created socket");
    commands.insert_resource(socket);
}

fn send_message(mut socket: ResMut<MatchboxSocket>) {
    let peers: Vec<_> = socket.connected_peers().collect();

    for peer in peers {
        let message = "Hello";
        info!("Sending message: {message:?} to {peer}");
        socket
            .channel_mut(CHANNEL_ID)
            .send(message.as_bytes().into(), peer);
    }
}

fn receive_messages(mut socket: ResMut<MatchboxSocket>) {
    for (peer, state) in socket.update_peers() {
        info!("{peer}: {state:?}");
    }

    for (_id, message) in socket.channel_mut(CHANNEL_ID).receive() {
        match std::str::from_utf8(&message) {
            Ok(message) => info!("Received message: {message:?}"),
            Err(e) => error!("Failed to convert message to string: {e}"),
        }
    }
}