mat/azalea
1
2
Fork 0
mirror of https://github.com/mat-1/azalea.git synced 2025-08-02 06:16:04 +00:00
Code Issues Projects Releases Packages Activity

make SendPacketEvent a bevy trigger

Browse source
This commit is contained in:
mat 2025-03-19 21:35:47 +00:00
parent ca2e0b3922
commit 75efbc83fd
17 changed files with 125 additions and 82 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
azalea-client/src/plugins/attack.rs
View file

@ -75,7 +75,7 @@ pub fn handle_attack_event(
&mut Sprinting,
&mut ShiftKeyDown,
)>,
mut send_packet_events: EventWriter<SendPacketEvent>,
mut commands: Commands,
mut swing_arm_event: EventWriter<SwingArmEvent>,
) {
for event in events.read() {
@ -85,7 +85,7 @@ pub fn handle_attack_event(
swing_arm_event.send(SwingArmEvent {
entity: event.entity,
});
send_packet_events.send(SendPacketEvent::new(
commands.trigger(SendPacketEvent::new(
event.entity,
ServerboundInteract {
entity_id: event.target,

2
azalea-client/src/plugins/brand.rs
View file

@ -19,7 +19,7 @@ impl Plugin for BrandPlugin {
fn build(&self, app: &mut App) {
app.add_systems(
Update,
handle_end_login_state.before(crate::packet::config::handle_send_packet_event),
handle_end_login_state.before(crate::packet::config::handle_outgoing_packets),
);
}
}

4
azalea-client/src/plugins/chat/handler.rs
View file

@ -29,7 +29,7 @@ pub struct SendChatKindEvent {
pub fn handle_send_chat_kind_event(
mut events: EventReader<SendChatKindEvent>,
mut send_packet_events: EventWriter<SendPacketEvent>,
mut commands: Commands,
) {
for event in events.read() {
let content = event
@ -58,6 +58,6 @@ pub fn handle_send_chat_kind_event(
}
};
send_packet_events.send(SendPacketEvent::new(event.entity, packet));
commands.trigger(SendPacketEvent::new(event.entity, packet));
}
}

4
azalea-client/src/plugins/chunks.rs
View file

@ -154,13 +154,13 @@ pub fn handle_chunk_batch_start_event(
pub fn handle_chunk_batch_finished_event(
mut query: Query<&mut ChunkBatchInfo>,
mut events: EventReader<ChunkBatchFinishedEvent>,
mut send_packets: EventWriter<SendPacketEvent>,
mut commands: Commands,
) {
for event in events.read() {
if let Ok(mut chunk_batch_info) = query.get_mut(event.entity) {
chunk_batch_info.batch_finished(event.batch_size);
let desired_chunks_per_tick = chunk_batch_info.desired_chunks_per_tick();
send_packets.send(SendPacketEvent::new(
commands.trigger(SendPacketEvent::new(
event.entity,
ServerboundChunkBatchReceived {
desired_chunks_per_tick,

13
azalea-client/src/plugins/interact.rs
View file

@ -22,7 +22,7 @@ use bevy_app::{App, Plugin, Update};
use bevy_ecs::{
component::Component,
entity::Entity,
event::{Event, EventReader, EventWriter},
event::{Event, EventReader},
query::{Changed, With},
schedule::IntoSystemConfigs,
system::{Commands, Query, Res},
@ -112,7 +112,7 @@ pub struct HitResultComponent(BlockHitResult);
pub fn handle_block_interact_event(
mut events: EventReader<BlockInteractEvent>,
mut query: Query<(Entity, &mut CurrentSequenceNumber, &HitResultComponent)>,
mut send_packet_events: EventWriter<SendPacketEvent>,
mut commands: Commands,
) {
for event in events.read() {
let Ok((entity, mut sequence_number, hit_result)) = query.get_mut(event.entity) else {
@ -150,7 +150,7 @@ pub fn handle_block_interact_event(
}
};
send_packet_events.send(SendPacketEvent::new(
commands.trigger(SendPacketEvent::new(
entity,
ServerboundUseItemOn {
hand: InteractionHand::MainHand,
@ -299,12 +299,9 @@ pub fn can_use_game_master_blocks(
pub struct SwingArmEvent {
pub entity: Entity,
}
pub fn handle_swing_arm_event(
mut events: EventReader<SwingArmEvent>,
mut send_packet_events: EventWriter<SendPacketEvent>,
) {
pub fn handle_swing_arm_event(mut events: EventReader<SwingArmEvent>, mut commands: Commands) {
for event in events.read() {
send_packet_events.send(SendPacketEvent::new(
commands.trigger(SendPacketEvent::new(
event.entity,
ServerboundSwing {
hand: InteractionHand::MainHand,

14
azalea-client/src/plugins/inventory.rs
View file

@ -21,7 +21,7 @@ use bevy_ecs::{
event::EventReader,
prelude::{Event, EventWriter},
schedule::{IntoSystemConfigs, SystemSet},
system::Query,
system::{Commands, Query},
};
use tracing::warn;
@ -610,7 +610,7 @@ fn handle_container_close_event(
query: Query<(Entity, &Inventory)>,
mut events: EventReader<CloseContainerEvent>,
mut client_side_events: EventWriter<ClientSideCloseContainerEvent>,
mut send_packet_events: EventWriter<SendPacketEvent>,
mut commands: Commands,
) {
for event in events.read() {
let (entity, inventory) = query.get(event.entity).unwrap();
@ -622,7 +622,7 @@ fn handle_container_close_event(
continue;
}
send_packet_events.send(SendPacketEvent::new(
commands.trigger(SendPacketEvent::new(
entity,
ServerboundContainerClose {
container_id: inventory.id,
@ -662,7 +662,7 @@ pub struct ContainerClickEvent {
pub fn handle_container_click_event(
mut query: Query<(Entity, &mut Inventory)>,
mut events: EventReader<ContainerClickEvent>,
mut send_packet_events: EventWriter<SendPacketEvent>,
mut commands: Commands,
) {
for event in events.read() {
let (entity, mut inventory) = query.get_mut(event.entity).unwrap();
@ -689,7 +689,7 @@ pub fn handle_container_click_event(
}
}
send_packet_events.send(SendPacketEvent::new(
commands.trigger(SendPacketEvent::new(
entity,
ServerboundContainerClick {
container_id: event.window_id,
@ -744,7 +744,7 @@ pub struct SetSelectedHotbarSlotEvent {
}
fn handle_set_selected_hotbar_slot_event(
mut events: EventReader<SetSelectedHotbarSlotEvent>,
mut send_packet_events: EventWriter<SendPacketEvent>,
mut commands: Commands,
mut query: Query<&mut Inventory>,
) {
for event in events.read() {
@ -756,7 +756,7 @@ fn handle_set_selected_hotbar_slot_event(
}
inventory.selected_hotbar_slot = event.slot;
send_packet_events.send(SendPacketEvent::new(
commands.trigger(SendPacketEvent::new(
event.entity,
ServerboundSetCarriedItem {
slot: event.slot as u16,

19
azalea-client/src/plugins/mining.rs
View file

@ -186,7 +186,7 @@ pub struct StartMiningBlockWithDirectionEvent {
fn handle_start_mining_block_with_direction_event(
mut events: EventReader<StartMiningBlockWithDirectionEvent>,
mut finish_mining_events: EventWriter<FinishMiningBlockEvent>,
mut send_packet_events: EventWriter<SendPacketEvent>,
mut commands: Commands,
mut attack_block_events: EventWriter<AttackBlockEvent>,
mut mine_block_progress_events: EventWriter<MineBlockProgressEvent>,
mut query: Query<(
@ -204,7 +204,6 @@ fn handle_start_mining_block_with_direction_event(
&mut MineBlockPos,
)>,
instances: Res<InstanceContainer>,
mut commands: Commands,
) {
for event in events.read() {
let (
@ -252,7 +251,7 @@ fn handle_start_mining_block_with_direction_event(
{
if mining.is_some() {
// send a packet to stop mining since we just changed target
send_packet_events.send(SendPacketEvent::new(
commands.trigger(SendPacketEvent::new(
event.entity,
ServerboundPlayerAction {
action: s_player_action::Action::AbortDestroyBlock,
@ -324,7 +323,7 @@ fn handle_start_mining_block_with_direction_event(
});
}
send_packet_events.send(SendPacketEvent::new(
commands.trigger(SendPacketEvent::new(
event.entity,
ServerboundPlayerAction {
action: s_player_action::Action::StartDestroyBlock,
@ -483,17 +482,16 @@ pub struct StopMiningBlockEvent {
}
pub fn handle_stop_mining_block_event(
mut events: EventReader<StopMiningBlockEvent>,
mut send_packet_events: EventWriter<SendPacketEvent>,
mut commands: Commands,
mut mine_block_progress_events: EventWriter<MineBlockProgressEvent>,
mut query: Query<(&mut Mining, &MineBlockPos, &mut MineProgress)>,
mut commands: Commands,
) {
for event in events.read() {
let (mut _mining, mine_block_pos, mut mine_progress) = query.get_mut(event.entity).unwrap();
let mine_block_pos =
mine_block_pos.expect("IsMining is true so MineBlockPos must be present");
send_packet_events.send(SendPacketEvent::new(
commands.trigger(SendPacketEvent::new(
event.entity,
ServerboundPlayerAction {
action: s_player_action::Action::AbortDestroyBlock,
@ -529,13 +527,12 @@ pub fn continue_mining_block(
&mut MineTicks,
&mut CurrentSequenceNumber,
)>,
mut send_packet_events: EventWriter<SendPacketEvent>,
mut commands: Commands,
mut mine_block_progress_events: EventWriter<MineBlockProgressEvent>,
mut finish_mining_events: EventWriter<FinishMiningBlockEvent>,
mut start_mining_events: EventWriter<StartMiningBlockWithDirectionEvent>,
mut swing_arm_events: EventWriter<SwingArmEvent>,
instances: Res<InstanceContainer>,
mut commands: Commands,
) {
for (
entity,
@ -566,7 +563,7 @@ pub fn continue_mining_block(
position: mining.pos,
});
*sequence_number += 1;
send_packet_events.send(SendPacketEvent::new(
commands.trigger(SendPacketEvent::new(
entity,
ServerboundPlayerAction {
action: s_player_action::Action::StartDestroyBlock,
@ -611,7 +608,7 @@ pub fn continue_mining_block(
entity,
position: mining.pos,
});
send_packet_events.send(SendPacketEvent::new(
commands.trigger(SendPacketEvent::new(
entity,
ServerboundPlayerAction {
action: s_player_action::Action::StopDestroyBlock,

13
azalea-client/src/plugins/movement.rs
View file

@ -17,7 +17,7 @@ use azalea_protocol::packets::{
};
use azalea_world::{MinecraftEntityId, MoveEntityError};
use bevy_app::{App, Plugin, Update};
use bevy_ecs::prelude::{Event, EventWriter};
use bevy_ecs::prelude::Event;
use bevy_ecs::schedule::SystemSet;
use bevy_ecs::system::Commands;
use bevy_ecs::{
@ -158,7 +158,7 @@ pub fn send_position(
),
With<InLoadedChunk>,
>,
mut send_packet_events: EventWriter<SendPacketEvent>,
mut commands: Commands,
) {
for (
entity,
@ -245,7 +245,7 @@ pub fn send_position(
};
if let Some(packet) = packet {
send_packet_events.send(SendPacketEvent {
commands.trigger(SendPacketEvent {
sent_by: entity,
packet,
});
@ -257,7 +257,6 @@ pub fn send_position(
pub struct LastSentInput(pub ServerboundPlayerInput);
pub fn send_player_input_packet(
mut query: Query<(Entity, &PhysicsState, &Jumping, Option<&LastSentInput>)>,
mut send_packet_events: EventWriter<SendPacketEvent>,
mut commands: Commands,
) {
for (entity, physics_state, jumping, last_sent_input) in query.iter_mut() {
@ -279,7 +278,7 @@ pub fn send_player_input_packet(
let last_sent_input = last_sent_input.cloned().unwrap_or_default();
if input != last_sent_input.0 {
send_packet_events.send(SendPacketEvent {
commands.trigger(SendPacketEvent {
sent_by: entity,
packet: input.clone().into_variant(),
});
@ -290,7 +289,7 @@ pub fn send_player_input_packet(
fn send_sprinting_if_needed(
mut query: Query<(Entity, &MinecraftEntityId, &Sprinting, &mut PhysicsState)>,
mut send_packet_events: EventWriter<SendPacketEvent>,
mut commands: Commands,
) {
for (entity, minecraft_entity_id, sprinting, mut physics_state) in query.iter_mut() {
let was_sprinting = physics_state.was_sprinting;
@ -300,7 +299,7 @@ fn send_sprinting_if_needed(
} else {
azalea_protocol::packets::game::s_player_command::Action::StopSprinting
};
send_packet_events.send(SendPacketEvent::new(
commands.trigger(SendPacketEvent::new(
entity,
ServerboundPlayerCommand {
id: *minecraft_entity_id,

2
azalea-client/src/plugins/packet/config/events.rs
View file

@ -34,7 +34,7 @@ impl SendConfigPacketEvent {
}
}
pub fn handle_send_packet_event(
pub fn handle_outgoing_packets(
mut send_packet_events: EventReader<SendConfigPacketEvent>,
mut query: Query<(&mut RawConnection, Option<&InConfigState>)>,
) {

18
azalea-client/src/plugins/packet/game/events.rs
View file

@ -49,7 +49,7 @@ pub struct ReceivePacketEvent {
}
/// An event for sending a packet to the server while we're in the `game` state.
#[derive(Event)]
#[derive(Event, Clone, Debug)]
pub struct SendPacketEvent {
pub sent_by: Entity,
pub packet: ServerboundGamePacket,
@ -61,18 +61,19 @@ impl SendPacketEvent {
}
}
pub fn handle_outgoing_packets(
mut send_packet_events: EventReader<SendPacketEvent>,
pub fn handle_outgoing_packets_observer(
trigger: Trigger<SendPacketEvent>,
mut query: Query<(&mut RawConnection, Option<&InGameState>)>,
) {
for event in send_packet_events.read() {
let event = trigger.event();
if let Ok((raw_connection, in_game_state)) = query.get_mut(event.sent_by) {
if in_game_state.is_none() {
error!(
"Tried to send a game packet {:?} while not in game state",
event.packet
);
continue;
return;
}
// debug!("Sending packet: {:?}", event.packet);
@ -81,6 +82,13 @@ pub fn handle_outgoing_packets(
}
}
}
/// A system that converts [`SendPacketEvent`] events into triggers so they get
/// received by [`handle_outgoing_packets_observer`].
pub fn handle_outgoing_packets(mut commands: Commands, mut events: EventReader<SendPacketEvent>) {
for event in events.read() {
commands.trigger(event.clone());
}
}
pub fn emit_receive_packet_events(

22
azalea-client/src/plugins/packet/game/mod.rs
View file

@ -222,7 +222,6 @@ impl GamePacketHandler<'_> {
EventWriter<InstanceLoadedEvent>,
ResMut<InstanceContainer>,
ResMut<EntityUuidIndex>,
EventWriter<SendPacketEvent>,
Query<&mut LoadedBy, Without<LocalEntity>>,
)>(
self.ecs,
@ -232,7 +231,6 @@ impl GamePacketHandler<'_> {
mut instance_loaded_events,
mut instance_container,
mut entity_uuid_index,
mut send_packet_events,
mut loaded_by_query,
)| {
let (
@ -342,7 +340,7 @@ impl GamePacketHandler<'_> {
"Sending client information because login: {:?}",
client_information
);
send_packet_events.send(SendPacketEvent::new(self.player,
commands.trigger(SendPacketEvent::new(self.player,
azalea_protocol::packets::game::s_client_information::ServerboundClientInformation { information: client_information.clone() },
));
},
@ -435,8 +433,8 @@ impl GamePacketHandler<'_> {
&mut Position,
&mut LastSentPosition,
)>,
EventWriter<SendPacketEvent>,
)>(self.ecs, |(mut query, mut send_packet_events)| {
Commands,
)>(self.ecs, |(mut query, mut commands)| {
let Ok((mut physics, mut direction, mut position, mut last_sent_position)) =
query.get_mut(self.player)
else {
@ -507,11 +505,11 @@ impl GamePacketHandler<'_> {
// send the relevant packets
send_packet_events.send(SendPacketEvent::new(
commands.trigger(SendPacketEvent::new(
self.player,
ServerboundAcceptTeleportation { id: p.id },
));
send_packet_events.send(SendPacketEvent::new(
commands.trigger(SendPacketEvent::new(
self.player,
ServerboundMovePlayerPosRot {
pos: new_pos,
@ -1043,14 +1041,14 @@ impl GamePacketHandler<'_> {
pub fn keep_alive(&mut self, p: &ClientboundKeepAlive) {
debug!("Got keep alive packet {p:?} for {:?}", self.player);
as_system::<(EventWriter<KeepAliveEvent>, EventWriter<SendPacketEvent>)>(
as_system::<(EventWriter<KeepAliveEvent>, Commands)>(
self.ecs,
|(mut keepalive_events, mut send_packet_events)| {
|(mut keepalive_events, mut commands)| {
keepalive_events.send(KeepAliveEvent {
entity: self.player,
id: p.id,
});
send_packet_events.send(SendPacketEvent::new(
commands.trigger(SendPacketEvent::new(
self.player,
ServerboundKeepAlive { id: p.id },
));
@ -1364,8 +1362,8 @@ impl GamePacketHandler<'_> {
pub fn ping(&mut self, p: &ClientboundPing) {
debug!("Got ping packet {p:?}");
as_system::<EventWriter<_>>(self.ecs, |mut events| {
events.send(SendPacketEvent::new(
as_system::<Commands>(self.ecs, |mut commands| {
commands.trigger(SendPacketEvent::new(
self.player,
ServerboundPong { id: p.id },
));

3
azalea-client/src/plugins/packet/mod.rs
View file

@ -54,11 +54,12 @@ impl Plugin for PacketPlugin {
login::process_packet_events,
),
)
.add_observer(game::handle_outgoing_packets_observer)
.add_systems(
Update,
(
(
config::handle_send_packet_event,
config::handle_outgoing_packets,
game::handle_outgoing_packets,
)
.chain(),

7
azalea-client/src/plugins/respawn.rs
View file

@ -20,12 +20,9 @@ impl Plugin for RespawnPlugin {
}
}
pub fn perform_respawn(
mut events: EventReader<PerformRespawnEvent>,
mut send_packets: EventWriter<SendPacketEvent>,
) {
pub fn perform_respawn(mut events: EventReader<PerformRespawnEvent>, mut commands: Commands) {
for event in events.read() {
send_packets.send(SendPacketEvent::new(
commands.trigger(SendPacketEvent::new(
event.entity,
ServerboundClientCommand {
action: s_client_command::Action::PerformRespawn,

4
azalea-client/src/plugins/tick_end.rs
View file

@ -28,9 +28,9 @@ impl Plugin for TickEndPlugin {
pub fn game_tick_packet(
query: Query<Entity, (With<LocalEntity>, With<InstanceName>)>,
mut send_packets: EventWriter<SendPacketEvent>,
mut commands: Commands,
) {
for entity in query.iter() {
send_packets.send(SendPacketEvent::new(entity, ServerboundClientTickEnd));
commands.trigger(SendPacketEvent::new(entity, ServerboundClientTickEnd));
}
}

9
azalea-client/src/test_simulation.rs
View file

@ -113,6 +113,15 @@ impl Simulation {
pub fn has_component<T: Component>(&self) -> bool {
self.app.world().get::<T>(self.entity).is_some()
}
pub fn resource<T: Resource + Clone>(&self) -> T {
self.app.world().get_resource::<T>().unwrap().clone()
}
pub fn with_resource<T: Resource>(&self, f: impl FnOnce(&T)) {
f(self.app.world().get_resource::<T>().unwrap());
}
pub fn with_resource_mut<T: Resource>(&mut self, f: impl FnOnce(Mut<T>)) {
f(self.app.world_mut().get_resource_mut::<T>().unwrap());
}
pub fn chunk(&self, chunk_pos: ChunkPos) -> Option<Arc<RwLock<Chunk>>> {
self.component::<InstanceHolder>()

37
azalea-client/tests/receive_start_config_packet.rs Normal file
View file

@ -0,0 +1,37 @@
use azalea_client::{InConfigState, packet::game::SendPacketEvent, test_simulation::*};
use azalea_core::resource_location::ResourceLocation;
use azalea_protocol::packets::{ConnectionProtocol, game::ClientboundStartConfiguration};
use azalea_registry::DimensionType;
use azalea_world::InstanceName;
use bevy_ecs::event::Events;
use bevy_log::tracing_subscriber;
#[test]
fn test_receive_start_config_packet() {
let _ = tracing_subscriber::fmt::try_init();
let mut simulation = Simulation::new(ConnectionProtocol::Game);
simulation.receive_packet(make_basic_login_packet(
DimensionType::new_raw(0),
ResourceLocation::new("minecraft:overworld"),
));
simulation.tick();
assert!(simulation.has_component::<InstanceName>());
simulation.tick();
// we shouldn't be using the `SendPacketEvent` event directly, we should be
// using the trigger instead
simulation.with_resource_mut::<Events<SendPacketEvent>>(|send_packet_events| {
assert_eq!(send_packet_events.len(), 0);
});
simulation.receive_packet(ClientboundStartConfiguration);
simulation.tick();
assert!(simulation.has_component::<InConfigState>());
// check again just in case
simulation.with_resource_mut::<Events<SendPacketEvent>>(|send_packet_events| {
assert_eq!(send_packet_events.len(), 0);
});
}

10
azalea/src/accept_resource_packs.rs
View file

@ -1,7 +1,7 @@
use azalea_client::InConfigState;
use azalea_client::chunks::handle_chunk_batch_finished_event;
use azalea_client::inventory::InventorySet;
use azalea_client::packet::config::{SendConfigPacketEvent, handle_send_packet_event};
use azalea_client::packet::config::{SendConfigPacketEvent, handle_outgoing_packets};
use azalea_client::packet::game::SendPacketEvent;
use azalea_client::packet::{death_event_on_0_health, game::ResourcePackEvent};
use azalea_client::respawn::perform_respawn;
@ -24,7 +24,7 @@ impl Plugin for AcceptResourcePacksPlugin {
.after(death_event_on_0_health)
.after(handle_chunk_batch_finished_event)
.after(InventorySet)
.before(handle_send_packet_event)
.before(handle_outgoing_packets)
.after(azalea_client::brand::handle_end_login_state),
);
}
@ -32,7 +32,7 @@ impl Plugin for AcceptResourcePacksPlugin {
fn accept_resource_pack(
mut events: EventReader<ResourcePackEvent>,
mut send_packet_events: EventWriter<SendPacketEvent>,
mut commands: Commands,
mut send_config_packet_events: EventWriter<SendConfigPacketEvent>,
query_in_config_state: Query<Option<&InConfigState>>,
) {
@ -57,14 +57,14 @@ fn accept_resource_pack(
},
));
} else {
send_packet_events.send(SendPacketEvent::new(
commands.trigger(SendPacketEvent::new(
event.entity,
ServerboundResourcePack {
id: event.id,
action: s_resource_pack::Action::Accepted,
},
));
send_packet_events.send(SendPacketEvent::new(
commands.trigger(SendPacketEvent::new(
event.entity,
ServerboundResourcePack {
id: event.id,