bevy_quinnet 0.20.0

Bevy plugin for Client/Server multiplayer games using QUIC
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
126
127
128

use bevy::prelude::{Entity, Vec2, Vec3};
use bevy_quinnet::shared::{
    channels::{ChannelConfig, ChannelId, SendChannelsConfiguration},
    ClientId,
};
use serde::{Deserialize, Serialize};
use strum::{EnumIter, IntoEnumIterator};

use crate::BrickId;

#[derive(Debug, Default, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub(crate) enum PaddleInput {
    #[default]
    None,
    Left,
    Right,
}

// Messages from clients
#[derive(Debug, Clone, Serialize, Deserialize)]
pub(crate) enum ClientMessage {
    PaddleInput { input: PaddleInput },
}

// Game setup messages from the server
#[derive(Debug, Clone, Serialize, Deserialize)]
pub(crate) enum ServerSetupMessage {
    InitClient {
        client_id: ClientId,
    },
    SpawnPaddle {
        owner_client_id: ClientId,
        entity: Entity,
        position: Vec3,
    },
    SpawnBall {
        owner_client_id: ClientId,
        entity: Entity,
        position: Vec3,
        direction: Vec2,
    },
    SpawnBricks {
        offset: Vec2,
        rows: usize,
        columns: usize,
    },
    StartGame,
}

// Game events from the server
#[derive(Debug, Clone, Serialize, Deserialize)]
pub(crate) enum ServerEvent {
    BrickDestroyed {
        by_client_id: ClientId,
        brick_id: BrickId,
    },
    BallCollided {
        owner_client_id: ClientId,
        entity: Entity,
        position: Vec3,
        velocity: Vec2,
    },
}

// Game updates from the server
#[derive(Debug, Clone, Serialize, Deserialize)]
pub(crate) enum ServerUpdate {
    PaddleMoved { entity: Entity, position: Vec3 },
}

#[derive(Debug, Clone, Copy, EnumIter)]
#[repr(u8)]
pub enum ClientChannel {
    PaddleCommands,
}
impl Into<ChannelId> for ClientChannel {
    fn into(self) -> ChannelId {
        self as ChannelId
    }
}
impl ClientChannel {
    pub fn to_channel_config(self) -> ChannelConfig {
        match self {
            ClientChannel::PaddleCommands => ChannelConfig::default_ordered_reliable(),
        }
    }
    pub fn channels_configuration() -> SendChannelsConfiguration {
        SendChannelsConfiguration::from_configs(
            ClientChannel::iter()
                .map(ClientChannel::to_channel_config)
                .collect(),
        )
        .unwrap()
    }
}

#[derive(Debug, Clone, Copy, EnumIter)]
#[repr(u8)]
pub enum ServerChannel {
    GameSetup,
    GameEvents,
    PaddleUpdates,
}

impl Into<ChannelId> for ServerChannel {
    fn into(self) -> ChannelId {
        self as ChannelId
    }
}

impl ServerChannel {
    pub fn to_channel_config(self) -> ChannelConfig {
        match self {
            ServerChannel::GameSetup => ChannelConfig::default_ordered_reliable(),
            ServerChannel::GameEvents => ChannelConfig::default_ordered_reliable(),
            ServerChannel::PaddleUpdates => ChannelConfig::default_unreliable(),
        }
    }

    pub fn channels_configuration() -> SendChannelsConfiguration {
        SendChannelsConfiguration::from_configs(
            ServerChannel::iter()
                .map(ServerChannel::to_channel_config)
                .collect(),
        )
        .unwrap()
    }
}