Events rework

Cargo.toml

@@ -48,6 +48,7 @@ valence_advancement = { workspace = true, optional = true }
 valence_anvil = { workspace = true, optional = true }
 valence_boss_bar = { workspace = true, optional = true }
 valence_server.workspace = true
+valence_event.workspace = true
 valence_inventory = { workspace = true, optional = true }
 valence_network = { workspace = true, optional = true }
 valence_player_list = { workspace = true, optional = true }
@@ -167,6 +168,7 @@ valence_advancement.path = "crates/valence_advancement"
 valence_anvil.path = "crates/valence_anvil"
 valence_build_utils.path = "crates/valence_build_utils"
 valence_server.path = "crates/valence_server"
+valence_event.path = "crates/valence_event"
 valence_packet_macros.path = "crates/valence_packet_macros"
 valence_server_core.path = "crates/valence_server_core"
 valence_entity.path = "crates/valence_entity"

crates/valence_event/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "valence_event"
+version.workspace = true
+edition.workspace = true
+
+[dependencies]
+valence_server_core.workspace = true
+valence_protocol.workspace = true
+valence_server.workspace = true
+bevy_ecs.workspace = true
+bevy_app.workspace = true
+bitfield-struct.workspace = true
+tracing.workspace = true
+
+

crates/valence_event/README.md

@@ -0,0 +1,3 @@
+# valence_event
+
+This crate provides a cancellable event system for Bevy, and implements all valence event types.

crates/valence_event/src/events.rs

@@ -0,0 +1,60 @@
+use bevy_app::{App, First, Plugin, PluginGroup, PluginGroupBuilder};
+use bevy_ecs::prelude::Event;
+use bevy_ecs::schedule::{IntoSystemSetConfigs, SystemSet};
+use valence_server::EventLoopPreUpdate;
+
+use self::inventory::InventoryEventPlugin;
+use crate::state_event::{EventsWithState, State, States};
+
+pub mod inventory;
+
+#[derive(SystemSet, Debug, Hash, PartialEq, Eq, Clone)]
+pub enum EventDispacherSets {
+ MainEvents,
+ Checks,
+ UserEvents,
+}
+
+pub struct EventDispacherPlugin;
+
+impl Plugin for EventDispacherPlugin {
+ fn build(&self, app: &mut App) {
+ app.configure_sets(
+ EventLoopPreUpdate,
+ (
+ EventDispacherSets::MainEvents,
+ EventDispacherSets::Checks,
+ EventDispacherSets::UserEvents,
+ )
+ .chain(),
+ )
+
+ .init_resource::<States>();
+
+ }
+}
+
+pub struct EventPlugins;
+
+impl PluginGroup for EventPlugins {
+ fn build(self) -> PluginGroupBuilder {
+ PluginGroupBuilder::start::<Self>().add(InventoryEventPlugin)
+ }
+}
+
+trait AddEventWithStateExt {
+ fn add_event_with_state<E: Event>(&mut self) -> &mut Self;
+}
+
+impl AddEventWithStateExt for App {
+ fn add_event_with_state<E: Event>(&mut self) -> &mut Self {
+ if !self.world.contains_resource::<EventsWithState<E>>() {
+ self.init_resource::<EventsWithState<E>>()
+ .add_systems(First, EventsWithState::<E>::update_system);
+ }
+ // if !self.world.contains_resource::<States>() {
+ // self.init_resource::<States>();
+ // }
+ self
+ }
+}

crates/valence_event/src/events/inventory.rs

@@ -0,0 +1,79 @@
+use bevy_ecs::prelude::{Entity, Event, EventReader};
+use bevy_ecs::schedule::IntoSystemConfigs;
+use valence_protocol::packets::play::click_slot_c2s::{ClickMode, SlotChange};
+use valence_protocol::packets::play::ClickSlotC2s;
+use valence_protocol::ItemStack;
+use valence_server::event_loop::PacketEvent;
+
+use self::click::{handle_inventory_click, InventoryClickEvent};
+use super::*;
+use crate::state_event::EventWithStateWriter;
+
+pub mod click;
+
+pub struct InventoryEventPlugin;
+
+impl Plugin for InventoryEventPlugin {
+ fn build(&self, app: &mut App) {
+ app.add_event_with_state::<ClickSlotEvent>()
+ .add_event_with_state::<InventoryClickEvent>()
+ .add_systems(
+ EventLoopPreUpdate,
+ handle_click_slot.in_set(EventDispacherSets::MainEvents),
+ )
+ .add_systems(
+ EventLoopPreUpdate,
+ handle_inventory_click.in_set(EventDispacherSets::UserEvents),
+ );
+ }
+}
+
+#[derive(Clone, Debug)]
+struct Canceled(bool);
+
+impl State for Canceled {
+ fn get(&self) -> bool {
+ self.0
+ }
+
+ fn set(&mut self, value: bool) {
+ self.0 = value;
+ }
+}
+
+#[derive(Clone, Debug, Event)]
+pub struct ClickSlotEvent {
+ pub client: Entity,
+ pub window_id: u8,
+ pub state_id: i32,
+ pub slot_idx: i16,
+ pub button: i8,
+ pub mode: ClickMode,
+ pub slot_changes: Vec<SlotChange>,
+ pub carried_item: Option<ItemStack>,
+}
+
+fn handle_click_slot(
+ mut packet_events: EventReader<PacketEvent>,
+ mut click_slot_events: EventWithStateWriter<ClickSlotEvent>,
+) {
+ for packet in packet_events.iter() {
+ let Some(pkt) = packet.decode::<ClickSlotC2s>() else {
+ continue;
+ };
+
+ click_slot_events.send(
+ ClickSlotEvent {
+ client: packet.client,
+ window_id: pkt.window_id,
+ state_id: pkt.state_id.0,
+ slot_idx: pkt.slot_idx,
+ button: pkt.button,
+ mode: pkt.mode,
+ slot_changes: pkt.slot_changes,
+ carried_item: pkt.carried_item,
+ },
+ Canceled(false),
+ );
+ }
+}

crates/valence_event/src/events/inventory/click.rs

@@ -0,0 +1,64 @@
+use crate::state_event::{EventWithStateReader, EventReader};
+
+use super::*;
+
+#[derive(Debug, Event, Clone)]
+pub struct InventoryClickEvent {
+ pub client: Entity,
+ pub window_id: u8,
+ pub state_id: i32,
+ pub slot_idx: i16,
+ pub click_type: ClickType,
+ pub clicked_item: Option<SlotChange>,
+ pub cursor_item: Option<ItemStack>,
+}
+
+#[derive(Debug, Clone)]
+pub enum ClickType {
+ Left,
+ Right,
+ ShiftLeft,
+ ShiftRight,
+ DoubleLeft,
+ DoubleRight,
+}
+
+pub(super) fn handle_inventory_click(
+ mut click_slot_events: EventReader<ClickSlotEvent>,
+ mut inventory_click_events: EventWithStateWriter<InventoryClickEvent>,
+) {
+ for (event, state_id, _) in click_slot_events.iter_with_ids() {
+ let click_type = match event.mode {
+ ClickMode::Click => match event.button {
+ 0 => ClickType::Left,
+ 1 => ClickType::Right,
+ _ => panic!("Invalid button for click mode"),
+ },
+ ClickMode::ShiftClick => match event.button {
+ 0 => ClickType::ShiftLeft,
+ 1 => ClickType::ShiftRight,
+ _ => panic!("Invalid button for shift click mode"),
+ },
+ ClickMode::DoubleClick => match event.button {
+ 0 => ClickType::DoubleLeft,
+ 1 => ClickType::DoubleRight,
+ _ => panic!("Invalid button for double click mode"),
+ },
+ _ => {
+ continue;
+ }
+ };
+
+ let inventory_click_event = InventoryClickEvent {
+ client: event.client,
+ window_id: event.window_id,
+ state_id: event.state_id,
+ slot_idx: event.slot_idx,
+ click_type,
+ clicked_item: event.slot_changes.get(0).cloned(),
+ cursor_item: event.carried_item.clone(),
+ };
+
+ inventory_click_events.send_with_state(inventory_click_event, state_id)
+ }
+}

crates/valence_event/src/lib.rs

@@ -0,0 +1,2 @@
+pub mod events;
+pub mod state_event;