chunkedge_server/
client_command.rs

1use bevy_app::prelude::*;
2use bevy_ecs::prelude::*;
3use chunkedge_entity::entity::Flags;
4use chunkedge_entity::{Pose, entity};
5use chunkedge_protocol::packets::play::PlayerCommandC2s;
6pub use chunkedge_protocol::packets::play::player_command_c2s::PlayerCommand;
7
8use crate::event_loop::{EventLoopPreUpdate, PacketMessage};
9
10pub struct ClientCommandPlugin;
11
12impl Plugin for ClientCommandPlugin {
13    fn build(&self, app: &mut App) {
14        app.add_message::<SprintMessage>()
15            .add_message::<SneakMessage>()
16            .add_message::<JumpWithHorseMessage>()
17            .add_message::<LeaveBedMessage>()
18            .add_systems(EventLoopPreUpdate, handle_client_command);
19    }
20}
21
22#[derive(Message, Copy, Clone, PartialEq, Eq, Debug)]
23pub struct SprintMessage {
24    pub client: Entity,
25    pub state: SprintState,
26}
27
28#[derive(Copy, Clone, PartialEq, Eq, Debug)]
29pub enum SprintState {
30    Start,
31    Stop,
32}
33
34#[derive(Message, Copy, Clone, PartialEq, Eq, Debug)]
35pub struct SneakMessage {
36    pub client: Entity,
37    pub state: SneakState,
38}
39
40#[derive(Copy, Clone, PartialEq, Eq, Debug)]
41pub enum SneakState {
42    Start,
43    Stop,
44}
45
46#[derive(Message, Copy, Clone, PartialEq, Eq, Debug)]
47pub struct JumpWithHorseMessage {
48    pub client: Entity,
49    pub state: JumpWithHorseState,
50}
51
52#[derive(Copy, Clone, PartialEq, Eq, Debug)]
53pub enum JumpWithHorseState {
54    Start {
55        /// The power of the horse jump in `0..=100`.
56        power: u8,
57    },
58    Stop,
59}
60
61#[derive(Message, Copy, Clone, PartialEq, Eq, Debug)]
62pub struct LeaveBedMessage {
63    pub client: Entity,
64}
65
66fn handle_client_command(
67    mut packets: MessageReader<PacketMessage>,
68    mut clients: Query<(&mut entity::Pose, &mut Flags)>,
69    mut sprinting_messages: MessageWriter<SprintMessage>,
70    mut sneaking_messages: MessageWriter<SneakMessage>,
71    mut jump_with_horse_messages: MessageWriter<JumpWithHorseMessage>,
72    mut leave_bed_messages: MessageWriter<LeaveBedMessage>,
73) {
74    for packet in packets.read() {
75        if let Some(pkt) = packet.decode::<PlayerCommandC2s>() {
76            match pkt.action {
77                PlayerCommand::StartSneaking => {
78                    if let Ok((mut pose, mut flags)) = clients.get_mut(packet.client) {
79                        pose.0 = Pose::Sneaking;
80                        flags.set_sneaking(true);
81                    }
82
83                    sneaking_messages.write(SneakMessage {
84                        client: packet.client,
85                        state: SneakState::Start,
86                    });
87                }
88                PlayerCommand::StopSneaking => {
89                    if let Ok((mut pose, mut flags)) = clients.get_mut(packet.client) {
90                        pose.0 = Pose::Standing;
91                        flags.set_sneaking(false);
92                    }
93
94                    sneaking_messages.write(SneakMessage {
95                        client: packet.client,
96                        state: SneakState::Stop,
97                    });
98                }
99                PlayerCommand::LeaveBed => {
100                    leave_bed_messages.write(LeaveBedMessage {
101                        client: packet.client,
102                    });
103                }
104                PlayerCommand::StartSprinting => {
105                    if let Ok((_, mut flags)) = clients.get_mut(packet.client) {
106                        flags.set_sprinting(true);
107                    }
108
109                    sprinting_messages.write(SprintMessage {
110                        client: packet.client,
111                        state: SprintState::Start,
112                    });
113                }
114                PlayerCommand::StopSprinting => {
115                    if let Ok((_, mut flags)) = clients.get_mut(packet.client) {
116                        flags.set_sprinting(false);
117                    }
118
119                    sprinting_messages.write(SprintMessage {
120                        client: packet.client,
121                        state: SprintState::Stop,
122                    });
123                }
124                PlayerCommand::StartJumpWithHorse => {
125                    jump_with_horse_messages.write(JumpWithHorseMessage {
126                        client: packet.client,
127                        state: JumpWithHorseState::Start {
128                            power: pkt.jump_boost.0 as u8,
129                        },
130                    });
131                }
132                PlayerCommand::StopJumpWithHorse => {
133                    jump_with_horse_messages.write(JumpWithHorseMessage {
134                        client: packet.client,
135                        state: JumpWithHorseState::Stop,
136                    });
137                }
138                PlayerCommand::OpenHorseInventory => {} // TODO
139                PlayerCommand::StartFlyingWithElytra => {
140                    if let Ok((mut pose, _)) = clients.get_mut(packet.client) {
141                        pose.0 = Pose::FallFlying;
142                    }
143
144                    // TODO.
145                }
146            }
147        }
148    }
149}
chunkedge_server/client_command.rs

chunkedge_server/
client_command.rs
