81 lines
1.9 KiB
Rust
81 lines
1.9 KiB
Rust
use std::collections::{hash_map, HashMap};
|
|
|
|
use bevy_derive::{Deref, DerefMut};
|
|
use bevy_ecs::{component::Component, entity::Entity, system::Resource};
|
|
|
|
use crate::common::{ClientChannel, ClientMessage, ServerMessage};
|
|
|
|
pub enum ServerClient {
|
|
Local(ClientChannel),
|
|
}
|
|
|
|
impl ServerClient {
|
|
pub fn recv(&mut self) -> Vec<ServerMessage> {
|
|
match self {
|
|
Self::Local(ch) => ch.recv().collect(),
|
|
}
|
|
}
|
|
pub fn send(&self, msg: ClientMessage) {
|
|
match self {
|
|
Self::Local(ch) => ch.send(msg),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Deref, DerefMut)]
|
|
pub struct ServerClients {
|
|
map: HashMap<Entity, ServerClient>,
|
|
}
|
|
|
|
impl ServerClients {
|
|
pub fn new() -> Self {
|
|
Self {
|
|
map: HashMap::new(),
|
|
}
|
|
}
|
|
pub fn add(&mut self, id: Entity, client: ServerClient) {
|
|
self.map.insert(id, client);
|
|
}
|
|
}
|
|
|
|
impl<'a> IntoIterator for &'a mut ServerClients {
|
|
type Item = (&'a Entity, &'a mut ServerClient);
|
|
type IntoIter = hash_map::IterMut<'a, Entity, ServerClient>;
|
|
fn into_iter(self) -> Self::IntoIter {
|
|
self.map.iter_mut()
|
|
}
|
|
}
|
|
|
|
// I don't think it's worth putting a reciever in here rn
|
|
// and moving that stuff into the ecs but we'll see
|
|
#[derive(Component)]
|
|
pub struct ClientComponent {
|
|
send: Vec<ClientMessage>,
|
|
}
|
|
|
|
impl ClientComponent {
|
|
pub fn new() -> Self {
|
|
Self { send: Vec::new() }
|
|
}
|
|
pub fn send(&mut self, msg: ClientMessage) {
|
|
self.send.push(msg);
|
|
}
|
|
pub fn take(&mut self) -> Vec<ClientMessage> {
|
|
std::mem::take(&mut self.send)
|
|
}
|
|
}
|
|
|
|
#[derive(Resource)]
|
|
pub struct ClientBroadcast(Vec<ClientMessage>);
|
|
impl ClientBroadcast {
|
|
pub fn new() -> Self {
|
|
Self(Vec::new())
|
|
}
|
|
pub fn send(&mut self, msg: ClientMessage) {
|
|
self.0.push(msg);
|
|
}
|
|
pub fn take(&mut self) -> Vec<ClientMessage> {
|
|
std::mem::take(&mut self.0)
|
|
}
|
|
}
|