diff --git a/crates/pumpkin-plugin-api/src/events/block/bell_resonate.rs b/crates/pumpkin-plugin-api/src/events/block/bell_resonate.rs new file mode 100644 index 000000000..e27a470bb --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/block/bell_resonate.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{BellResonateEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a bell resonates. +pub struct BellResonateEvent; +impl FromIntoEvent for BellResonateEvent { + const EVENT_TYPE: EventType = EventType::BellResonateEvent; + type Data = BellResonateEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::BellResonateEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::BellResonateEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/block/bell_ring.rs b/crates/pumpkin-plugin-api/src/events/block/bell_ring.rs new file mode 100644 index 000000000..83d5d3a41 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/block/bell_ring.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{BellRingEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a bell is rung. +pub struct BellRingEvent; +impl FromIntoEvent for BellRingEvent { + const EVENT_TYPE: EventType = EventType::BellRingEvent; + type Data = BellRingEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::BellRingEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::BellRingEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/block/block_brush.rs b/crates/pumpkin-plugin-api/src/events/block/block_brush.rs new file mode 100644 index 000000000..4e4ff3a7d --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/block/block_brush.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{BlockBrushEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player brushes a block. +pub struct BlockBrushEvent; +impl FromIntoEvent for BlockBrushEvent { + const EVENT_TYPE: EventType = EventType::BlockBrushEvent; + type Data = BlockBrushEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::BlockBrushEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::BlockBrushEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/block/block_cook.rs b/crates/pumpkin-plugin-api/src/events/block/block_cook.rs new file mode 100644 index 000000000..8c9992a94 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/block/block_cook.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{BlockCookEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a block cooks an item. +pub struct BlockCookEvent; +impl FromIntoEvent for BlockCookEvent { + const EVENT_TYPE: EventType = EventType::BlockCookEvent; + type Data = BlockCookEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::BlockCookEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::BlockCookEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/block/block_damage_abort.rs b/crates/pumpkin-plugin-api/src/events/block/block_damage_abort.rs new file mode 100644 index 000000000..12cec62bb --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/block/block_damage_abort.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{BlockDamageAbortEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player stops damaging a block. +pub struct BlockDamageAbortEvent; +impl FromIntoEvent for BlockDamageAbortEvent { + const EVENT_TYPE: EventType = EventType::BlockDamageAbortEvent; + type Data = BlockDamageAbortEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::BlockDamageAbortEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::BlockDamageAbortEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/block/block_dispense_armor.rs b/crates/pumpkin-plugin-api/src/events/block/block_dispense_armor.rs new file mode 100644 index 000000000..cae00034d --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/block/block_dispense_armor.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{BlockDispenseArmorEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a dispenser equips armor on an entity. +pub struct BlockDispenseArmorEvent; +impl FromIntoEvent for BlockDispenseArmorEvent { + const EVENT_TYPE: EventType = EventType::BlockDispenseArmorEvent; + type Data = BlockDispenseArmorEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::BlockDispenseArmorEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::BlockDispenseArmorEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/block/block_dispense_loot.rs b/crates/pumpkin-plugin-api/src/events/block/block_dispense_loot.rs new file mode 100644 index 000000000..4f2bf2c7f --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/block/block_dispense_loot.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{BlockDispenseLootEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a block dispenses loot. +pub struct BlockDispenseLootEvent; +impl FromIntoEvent for BlockDispenseLootEvent { + const EVENT_TYPE: EventType = EventType::BlockDispenseLootEvent; + type Data = BlockDispenseLootEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::BlockDispenseLootEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::BlockDispenseLootEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/block/block_drop_item.rs b/crates/pumpkin-plugin-api/src/events/block/block_drop_item.rs new file mode 100644 index 000000000..c87580772 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/block/block_drop_item.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{BlockDropItemEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a block drops items into the world. +pub struct BlockDropItemEvent; +impl FromIntoEvent for BlockDropItemEvent { + const EVENT_TYPE: EventType = EventType::BlockDropItemEvent; + type Data = BlockDropItemEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::BlockDropItemEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::BlockDropItemEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/block/block_exp.rs b/crates/pumpkin-plugin-api/src/events/block/block_exp.rs new file mode 100644 index 000000000..7f8b9fce6 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/block/block_exp.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{BlockExpEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a block gives experience. +pub struct BlockExpEvent; +impl FromIntoEvent for BlockExpEvent { + const EVENT_TYPE: EventType = EventType::BlockExpEvent; + type Data = BlockExpEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::BlockExpEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::BlockExpEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/block/block_fertilize.rs b/crates/pumpkin-plugin-api/src/events/block/block_fertilize.rs new file mode 100644 index 000000000..cd36073d4 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/block/block_fertilize.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{BlockFertilizeEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a block is fertilized. +pub struct BlockFertilizeEvent; +impl FromIntoEvent for BlockFertilizeEvent { + const EVENT_TYPE: EventType = EventType::BlockFertilizeEvent; + type Data = BlockFertilizeEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::BlockFertilizeEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::BlockFertilizeEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/block/block_multi_place.rs b/crates/pumpkin-plugin-api/src/events/block/block_multi_place.rs new file mode 100644 index 000000000..2de930f77 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/block/block_multi_place.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{BlockMultiPlaceEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when multiple blocks are placed at once. +pub struct BlockMultiPlaceEvent; +impl FromIntoEvent for BlockMultiPlaceEvent { + const EVENT_TYPE: EventType = EventType::BlockMultiPlaceEvent; + type Data = BlockMultiPlaceEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::BlockMultiPlaceEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::BlockMultiPlaceEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/block/block_receive_game.rs b/crates/pumpkin-plugin-api/src/events/block/block_receive_game.rs new file mode 100644 index 000000000..c7841b3c4 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/block/block_receive_game.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{BlockReceiveGameEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a block receives a game event. +pub struct BlockReceiveGameEvent; +impl FromIntoEvent for BlockReceiveGameEvent { + const EVENT_TYPE: EventType = EventType::BlockReceiveGameEvent; + type Data = BlockReceiveGameEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::BlockReceiveGameEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::BlockReceiveGameEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/block/block_shear_entity.rs b/crates/pumpkin-plugin-api/src/events/block/block_shear_entity.rs new file mode 100644 index 000000000..ff3a6b62a --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/block/block_shear_entity.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{BlockShearEntityEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a dispenser shears an entity. +pub struct BlockShearEntityEvent; +impl FromIntoEvent for BlockShearEntityEvent { + const EVENT_TYPE: EventType = EventType::BlockShearEntityEvent; + type Data = BlockShearEntityEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::BlockShearEntityEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::BlockShearEntityEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/block/block_spread.rs b/crates/pumpkin-plugin-api/src/events/block/block_spread.rs new file mode 100644 index 000000000..ec13e0e77 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/block/block_spread.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{BlockSpreadEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a block spreads based on world conditions. +pub struct BlockSpreadEvent; +impl FromIntoEvent for BlockSpreadEvent { + const EVENT_TYPE: EventType = EventType::BlockSpreadEvent; + type Data = BlockSpreadEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::BlockSpreadEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::BlockSpreadEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/block/brewing_start.rs b/crates/pumpkin-plugin-api/src/events/block/brewing_start.rs new file mode 100644 index 000000000..3aa8a7187 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/block/brewing_start.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{BrewingStartEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a brewing stand starts brewing. +pub struct BrewingStartEvent; +impl FromIntoEvent for BrewingStartEvent { + const EVENT_TYPE: EventType = EventType::BrewingStartEvent; + type Data = BrewingStartEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::BrewingStartEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::BrewingStartEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/block/campfire_start.rs b/crates/pumpkin-plugin-api/src/events/block/campfire_start.rs new file mode 100644 index 000000000..d5424731e --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/block/campfire_start.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{CampfireStartEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a campfire starts cooking an item. +pub struct CampfireStartEvent; +impl FromIntoEvent for CampfireStartEvent { + const EVENT_TYPE: EventType = EventType::CampfireStartEvent; + type Data = CampfireStartEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::CampfireStartEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::CampfireStartEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/block/cauldron_level_change.rs b/crates/pumpkin-plugin-api/src/events/block/cauldron_level_change.rs new file mode 100644 index 000000000..9a5f645f6 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/block/cauldron_level_change.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{CauldronLevelChangeEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a cauldron fluid level changes. +pub struct CauldronLevelChangeEvent; +impl FromIntoEvent for CauldronLevelChangeEvent { + const EVENT_TYPE: EventType = EventType::CauldronLevelChangeEvent; + type Data = CauldronLevelChangeEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::CauldronLevelChangeEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::CauldronLevelChangeEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/block/crafter_craft.rs b/crates/pumpkin-plugin-api/src/events/block/crafter_craft.rs new file mode 100644 index 000000000..00ce23c75 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/block/crafter_craft.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{CrafterCraftEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a crafter crafts an item. +pub struct CrafterCraftEvent; +impl FromIntoEvent for CrafterCraftEvent { + const EVENT_TYPE: EventType = EventType::CrafterCraftEvent; + type Data = CrafterCraftEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::CrafterCraftEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::CrafterCraftEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/block/entity_block_form.rs b/crates/pumpkin-plugin-api/src/events/block/entity_block_form.rs new file mode 100644 index 000000000..b82805bd7 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/block/entity_block_form.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{EntityBlockFormEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a block forms due to an entity action. +pub struct EntityBlockFormEvent; +impl FromIntoEvent for EntityBlockFormEvent { + const EVENT_TYPE: EventType = EventType::EntityBlockFormEvent; + type Data = EntityBlockFormEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::EntityBlockFormEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::EntityBlockFormEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/block/fluid_level_change.rs b/crates/pumpkin-plugin-api/src/events/block/fluid_level_change.rs new file mode 100644 index 000000000..3e674bbda --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/block/fluid_level_change.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, FluidLevelChangeEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a fluid level changes. +pub struct FluidLevelChangeEvent; +impl FromIntoEvent for FluidLevelChangeEvent { + const EVENT_TYPE: EventType = EventType::FluidLevelChangeEvent; + type Data = FluidLevelChangeEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::FluidLevelChangeEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::FluidLevelChangeEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/block/inventory_block_start.rs b/crates/pumpkin-plugin-api/src/events/block/inventory_block_start.rs new file mode 100644 index 000000000..50d078301 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/block/inventory_block_start.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, InventoryBlockStartEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when an inventory block starts an operation. +pub struct InventoryBlockStartEvent; +impl FromIntoEvent for InventoryBlockStartEvent { + const EVENT_TYPE: EventType = EventType::InventoryBlockStartEvent; + type Data = InventoryBlockStartEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::InventoryBlockStartEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::InventoryBlockStartEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/block/leaves_decay.rs b/crates/pumpkin-plugin-api/src/events/block/leaves_decay.rs new file mode 100644 index 000000000..d50d2e7ca --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/block/leaves_decay.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, LeavesDecayEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when leaves decay naturally. +pub struct LeavesDecayEvent; +impl FromIntoEvent for LeavesDecayEvent { + const EVENT_TYPE: EventType = EventType::LeavesDecayEvent; + type Data = LeavesDecayEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::LeavesDecayEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::LeavesDecayEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/block/mod.rs b/crates/pumpkin-plugin-api/src/events/block/mod.rs index 4de629e90..6c6c5e367 100644 --- a/crates/pumpkin-plugin-api/src/events/block/mod.rs +++ b/crates/pumpkin-plugin-api/src/events/block/mod.rs @@ -1,58 +1,133 @@ +/// Bell resonate event. +pub mod bell_resonate; +/// Bell ring event. +pub mod bell_ring; /// Block break event. pub mod block_break; +/// Block brush event. +pub mod block_brush; /// Block burn event. pub mod block_burn; /// Block can build check event. pub mod block_can_build; +/// Block cook event. +pub mod block_cook; /// Block damage event. pub mod block_damage; +/// Block damage abort event. +pub mod block_damage_abort; /// Block dispense event. pub mod block_dispense; +/// Block dispense armor event. +pub mod block_dispense_armor; +/// Block dispense loot event. +pub mod block_dispense_loot; +/// Block drop item event. +pub mod block_drop_item; +/// Block exp event. +pub mod block_exp; /// Block explode event. pub mod block_explode; /// Block fade event. pub mod block_fade; +/// Block fertilize event. +pub mod block_fertilize; /// Block form event. pub mod block_form; /// Block fluid flow event. pub mod block_from_to; -/// Block growth event. +/// Block grow event. pub mod block_grow; /// Block ignite event. pub mod block_ignite; +/// Block multi-place event. +pub mod block_multi_place; /// Block physics event. pub mod block_physics; /// Block piston event. pub mod block_piston; /// Block place event. pub mod block_place; +/// Block receive game event. +pub mod block_receive_game; /// Block redstone signal event. pub mod block_redstone; +/// Block shear entity event. +pub mod block_shear_entity; +/// Block spread event. +pub mod block_spread; +/// Brewing start event. +pub mod brewing_start; +/// Campfire start event. +pub mod campfire_start; +/// Cauldron level change event. +pub mod cauldron_level_change; +/// Crafter craft event. +pub mod crafter_craft; +/// Entity block form event. +pub mod entity_block_form; +/// Fluid level change event. +pub mod fluid_level_change; +/// Inventory block start event. +pub mod inventory_block_start; +/// Leaves decay event. +pub mod leaves_decay; +/// Moisture change event. +pub mod moisture_change; /// Note block play event. pub mod note_play; +/// Sculk bloom event. +pub mod sculk_bloom; /// Sign text change event. pub mod sign_change; /// Sponge absorb water event. pub mod sponge_absorb; /// TNT prime event. pub mod tnt_prime; +/// Vault display item event. +pub mod vault_display_item; +pub use bell_resonate::*; +pub use bell_ring::*; pub use block_break::*; +pub use block_brush::*; pub use block_burn::*; pub use block_can_build::*; +pub use block_cook::*; pub use block_damage::*; +pub use block_damage_abort::*; pub use block_dispense::*; +pub use block_dispense_armor::*; +pub use block_dispense_loot::*; +pub use block_drop_item::*; +pub use block_exp::*; pub use block_explode::*; pub use block_fade::*; +pub use block_fertilize::*; pub use block_form::*; pub use block_from_to::*; pub use block_grow::*; pub use block_ignite::*; +pub use block_multi_place::*; pub use block_physics::*; pub use block_piston::*; pub use block_place::*; +pub use block_receive_game::*; pub use block_redstone::*; +pub use block_shear_entity::*; +pub use block_spread::*; +pub use brewing_start::*; +pub use campfire_start::*; +pub use cauldron_level_change::*; +pub use crafter_craft::*; +pub use entity_block_form::*; +pub use fluid_level_change::*; +pub use inventory_block_start::*; +pub use leaves_decay::*; +pub use moisture_change::*; pub use note_play::*; +pub use sculk_bloom::*; pub use sign_change::*; pub use sponge_absorb::*; pub use tnt_prime::*; +pub use vault_display_item::*; diff --git a/crates/pumpkin-plugin-api/src/events/block/moisture_change.rs b/crates/pumpkin-plugin-api/src/events/block/moisture_change.rs new file mode 100644 index 000000000..97ac3894b --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/block/moisture_change.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, MoistureChangeEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when farmland moisture changes. +pub struct MoistureChangeEvent; +impl FromIntoEvent for MoistureChangeEvent { + const EVENT_TYPE: EventType = EventType::MoistureChangeEvent; + type Data = MoistureChangeEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::MoistureChangeEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::MoistureChangeEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/block/sculk_bloom.rs b/crates/pumpkin-plugin-api/src/events/block/sculk_bloom.rs new file mode 100644 index 000000000..b1680ad30 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/block/sculk_bloom.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, SculkBloomEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a sculk catalyst blooms. +pub struct SculkBloomEvent; +impl FromIntoEvent for SculkBloomEvent { + const EVENT_TYPE: EventType = EventType::SculkBloomEvent; + type Data = SculkBloomEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::SculkBloomEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::SculkBloomEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/block/vault_display_item.rs b/crates/pumpkin-plugin-api/src/events/block/vault_display_item.rs new file mode 100644 index 000000000..84a81e461 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/block/vault_display_item.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, VaultDisplayItemEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a vault displays an item. +pub struct VaultDisplayItemEvent; +impl FromIntoEvent for VaultDisplayItemEvent { + const EVENT_TYPE: EventType = EventType::VaultDisplayItemEvent; + type Data = VaultDisplayItemEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::VaultDisplayItemEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::VaultDisplayItemEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/enchantment/enchant_item.rs b/crates/pumpkin-plugin-api/src/events/enchantment/enchant_item.rs new file mode 100644 index 000000000..8e0c1ff5a --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/enchantment/enchant_item.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{EnchantItemEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// Event triggered when an item is enchanted at an enchanting table. +pub struct EnchantItemEvent; +impl FromIntoEvent for EnchantItemEvent { + const EVENT_TYPE: EventType = EventType::EnchantItemEvent; + type Data = EnchantItemEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::EnchantItemEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::EnchantItemEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/enchantment/mod.rs b/crates/pumpkin-plugin-api/src/events/enchantment/mod.rs new file mode 100644 index 000000000..233bd3b05 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/enchantment/mod.rs @@ -0,0 +1,7 @@ +/// Enchant item event. +pub mod enchant_item; +/// Prepare item enchant event. +pub mod prepare_item_enchant; + +pub use enchant_item::*; +pub use prepare_item_enchant::*; diff --git a/crates/pumpkin-plugin-api/src/events/enchantment/prepare_item_enchant.rs b/crates/pumpkin-plugin-api/src/events/enchantment/prepare_item_enchant.rs new file mode 100644 index 000000000..0ed655d80 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/enchantment/prepare_item_enchant.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PrepareItemEnchantEventData}; + +use super::super::FromIntoEvent; + +/// Event triggered when an item is placed in an enchanting table to prepare options. +pub struct PrepareItemEnchantEvent; +impl FromIntoEvent for PrepareItemEnchantEvent { + const EVENT_TYPE: EventType = EventType::PrepareItemEnchantEvent; + type Data = PrepareItemEnchantEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PrepareItemEnchantEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PrepareItemEnchantEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/area_effect_cloud_apply.rs b/crates/pumpkin-plugin-api/src/events/entity/area_effect_cloud_apply.rs new file mode 100644 index 000000000..f8912f4d0 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/area_effect_cloud_apply.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{AreaEffectCloudApplyEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when an area effect cloud applies its effect to entities. +pub struct AreaEffectCloudApplyEvent; +impl FromIntoEvent for AreaEffectCloudApplyEvent { + const EVENT_TYPE: EventType = EventType::AreaEffectCloudApplyEvent; + type Data = AreaEffectCloudApplyEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::AreaEffectCloudApplyEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::AreaEffectCloudApplyEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/arrow_body_count_change.rs b/crates/pumpkin-plugin-api/src/events/entity/arrow_body_count_change.rs new file mode 100644 index 000000000..5cbde8d88 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/arrow_body_count_change.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{ArrowBodyCountChangeEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when the number of arrows stuck in an entity changes. +pub struct ArrowBodyCountChangeEvent; +impl FromIntoEvent for ArrowBodyCountChangeEvent { + const EVENT_TYPE: EventType = EventType::ArrowBodyCountChangeEvent; + type Data = ArrowBodyCountChangeEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::ArrowBodyCountChangeEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::ArrowBodyCountChangeEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/bat_toggle_sleep.rs b/crates/pumpkin-plugin-api/src/events/entity/bat_toggle_sleep.rs new file mode 100644 index 000000000..b51e3d618 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/bat_toggle_sleep.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{BatToggleSleepEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a bat toggles its sleep state. +pub struct BatToggleSleepEvent; +impl FromIntoEvent for BatToggleSleepEvent { + const EVENT_TYPE: EventType = EventType::BatToggleSleepEvent; + type Data = BatToggleSleepEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::BatToggleSleepEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::BatToggleSleepEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/creature_spawn.rs b/crates/pumpkin-plugin-api/src/events/entity/creature_spawn.rs new file mode 100644 index 000000000..906612147 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/creature_spawn.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{CreatureSpawnEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// Event triggered when a creature spawns. +pub struct CreatureSpawnEvent; +impl FromIntoEvent for CreatureSpawnEvent { + const EVENT_TYPE: EventType = EventType::CreatureSpawnEvent; + type Data = CreatureSpawnEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::CreatureSpawnEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::CreatureSpawnEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/creeper_power.rs b/crates/pumpkin-plugin-api/src/events/entity/creeper_power.rs new file mode 100644 index 000000000..b93550a93 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/creeper_power.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{CreeperPowerEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a creeper is powered. +pub struct CreeperPowerEvent; +impl FromIntoEvent for CreeperPowerEvent { + const EVENT_TYPE: EventType = EventType::CreeperPowerEvent; + type Data = CreeperPowerEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::CreeperPowerEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::CreeperPowerEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/ender_dragon_change_phase.rs b/crates/pumpkin-plugin-api/src/events/entity/ender_dragon_change_phase.rs new file mode 100644 index 000000000..7f2134452 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/ender_dragon_change_phase.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{EnderDragonChangePhaseEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// Event triggered when an Ender Dragon changes its phase. +pub struct EnderDragonChangePhaseEvent; +impl FromIntoEvent for EnderDragonChangePhaseEvent { + const EVENT_TYPE: EventType = EventType::EnderDragonChangePhaseEvent; + type Data = EnderDragonChangePhaseEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::EnderDragonChangePhaseEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::EnderDragonChangePhaseEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/entity_break_door.rs b/crates/pumpkin-plugin-api/src/events/entity/entity_break_door.rs new file mode 100644 index 000000000..55b46dbb2 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/entity_break_door.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{EntityBreakDoorEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// Event triggered when an entity breaks a door. +pub struct EntityBreakDoorEvent; +impl FromIntoEvent for EntityBreakDoorEvent { + const EVENT_TYPE: EventType = EventType::EntityBreakDoorEvent; + type Data = EntityBreakDoorEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::EntityBreakDoorEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::EntityBreakDoorEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/entity_change_block.rs b/crates/pumpkin-plugin-api/src/events/entity/entity_change_block.rs new file mode 100644 index 000000000..200e0b4ea --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/entity_change_block.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{EntityChangeBlockEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// Event triggered when an entity changes a block in the world. +pub struct EntityChangeBlockEvent; +impl FromIntoEvent for EntityChangeBlockEvent { + const EVENT_TYPE: EventType = EventType::EntityChangeBlockEvent; + type Data = EntityChangeBlockEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::EntityChangeBlockEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::EntityChangeBlockEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/entity_combust_by_block.rs b/crates/pumpkin-plugin-api/src/events/entity/entity_combust_by_block.rs new file mode 100644 index 000000000..7d98bb5bc --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/entity_combust_by_block.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{EntityCombustByBlockEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when an entity is set on fire by a block. +pub struct EntityCombustByBlockEvent; +impl FromIntoEvent for EntityCombustByBlockEvent { + const EVENT_TYPE: EventType = EventType::EntityCombustByBlockEvent; + type Data = EntityCombustByBlockEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::EntityCombustByBlockEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::EntityCombustByBlockEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/entity_combust_by_entity.rs b/crates/pumpkin-plugin-api/src/events/entity/entity_combust_by_entity.rs new file mode 100644 index 000000000..cf7278274 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/entity_combust_by_entity.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{EntityCombustByEntityEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when an entity is set on fire by another entity. +pub struct EntityCombustByEntityEvent; +impl FromIntoEvent for EntityCombustByEntityEvent { + const EVENT_TYPE: EventType = EventType::EntityCombustByEntityEvent; + type Data = EntityCombustByEntityEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::EntityCombustByEntityEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::EntityCombustByEntityEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/entity_damage_by_block.rs b/crates/pumpkin-plugin-api/src/events/entity/entity_damage_by_block.rs new file mode 100644 index 000000000..5d8c67eaf --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/entity_damage_by_block.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{EntityDamageByBlockEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// Event triggered when an entity takes damage from a block. +pub struct EntityDamageByBlockEvent; +impl FromIntoEvent for EntityDamageByBlockEvent { + const EVENT_TYPE: EventType = EventType::EntityDamageByBlockEvent; + type Data = EntityDamageByBlockEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::EntityDamageByBlockEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::EntityDamageByBlockEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/entity_damage_by_entity.rs b/crates/pumpkin-plugin-api/src/events/entity/entity_damage_by_entity.rs new file mode 100644 index 000000000..5a7cbad7c --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/entity_damage_by_entity.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{EntityDamageByEntityEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// Event triggered when an entity takes damage from another entity. +pub struct EntityDamageByEntityEvent; +impl FromIntoEvent for EntityDamageByEntityEvent { + const EVENT_TYPE: EventType = EventType::EntityDamageByEntityEvent; + type Data = EntityDamageByEntityEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::EntityDamageByEntityEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::EntityDamageByEntityEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/entity_drop_item.rs b/crates/pumpkin-plugin-api/src/events/entity/entity_drop_item.rs new file mode 100644 index 000000000..9e1ff603c --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/entity_drop_item.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{EntityDropItemEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// Event triggered when an entity drops an item. +pub struct EntityDropItemEvent; +impl FromIntoEvent for EntityDropItemEvent { + const EVENT_TYPE: EventType = EventType::EntityDropItemEvent; + type Data = EntityDropItemEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::EntityDropItemEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::EntityDropItemEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/entity_enter_block.rs b/crates/pumpkin-plugin-api/src/events/entity/entity_enter_block.rs new file mode 100644 index 000000000..1774d4108 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/entity_enter_block.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{EntityEnterBlockEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// Event triggered when an entity enters a block. +pub struct EntityEnterBlockEvent; +impl FromIntoEvent for EntityEnterBlockEvent { + const EVENT_TYPE: EventType = EventType::EntityEnterBlockEvent; + type Data = EntityEnterBlockEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::EntityEnterBlockEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::EntityEnterBlockEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/entity_exhaustion.rs b/crates/pumpkin-plugin-api/src/events/entity/entity_exhaustion.rs new file mode 100644 index 000000000..3104a1343 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/entity_exhaustion.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{EntityExhaustionEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// Event triggered when an entity experiences hunger exhaustion. +pub struct EntityExhaustionEvent; +impl FromIntoEvent for EntityExhaustionEvent { + const EVENT_TYPE: EventType = EventType::EntityExhaustionEvent; + type Data = EntityExhaustionEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::EntityExhaustionEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::EntityExhaustionEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/entity_interact.rs b/crates/pumpkin-plugin-api/src/events/entity/entity_interact.rs new file mode 100644 index 000000000..f84ba3d7c --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/entity_interact.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{EntityInteractEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// Event triggered when an entity interacts with a block. +pub struct EntityInteractEvent; +impl FromIntoEvent for EntityInteractEvent { + const EVENT_TYPE: EventType = EventType::EntityInteractEvent; + type Data = EntityInteractEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::EntityInteractEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::EntityInteractEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/entity_knockback.rs b/crates/pumpkin-plugin-api/src/events/entity/entity_knockback.rs new file mode 100644 index 000000000..37f91c27a --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/entity_knockback.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{EntityKnockbackEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// Event triggered when an entity receives knockback. +pub struct EntityKnockbackEvent; +impl FromIntoEvent for EntityKnockbackEvent { + const EVENT_TYPE: EventType = EventType::EntityKnockbackEvent; + type Data = EntityKnockbackEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::EntityKnockbackEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::EntityKnockbackEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/entity_knockback_by_entity.rs b/crates/pumpkin-plugin-api/src/events/entity/entity_knockback_by_entity.rs new file mode 100644 index 000000000..42c03e802 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/entity_knockback_by_entity.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{EntityKnockbackByEntityEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when an entity is knocked back by another entity. +pub struct EntityKnockbackByEntityEvent; +impl FromIntoEvent for EntityKnockbackByEntityEvent { + const EVENT_TYPE: EventType = EventType::EntityKnockbackByEntityEvent; + type Data = EntityKnockbackByEntityEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::EntityKnockbackByEntityEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::EntityKnockbackByEntityEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/entity_place.rs b/crates/pumpkin-plugin-api/src/events/entity/entity_place.rs new file mode 100644 index 000000000..4d489d49a --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/entity_place.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{EntityPlaceEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// Event triggered when an entity places a block. +pub struct EntityPlaceEvent; +impl FromIntoEvent for EntityPlaceEvent { + const EVENT_TYPE: EventType = EventType::EntityPlaceEvent; + type Data = EntityPlaceEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::EntityPlaceEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::EntityPlaceEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/entity_portal_enter.rs b/crates/pumpkin-plugin-api/src/events/entity/entity_portal_enter.rs new file mode 100644 index 000000000..417971469 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/entity_portal_enter.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{EntityPortalEnterEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when an entity enters a portal. +pub struct EntityPortalEnterEvent; +impl FromIntoEvent for EntityPortalEnterEvent { + const EVENT_TYPE: EventType = EventType::EntityPortalEnterEvent; + type Data = EntityPortalEnterEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::EntityPortalEnterEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::EntityPortalEnterEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/entity_portal_exit.rs b/crates/pumpkin-plugin-api/src/events/entity/entity_portal_exit.rs new file mode 100644 index 000000000..f2dc68e9e --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/entity_portal_exit.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{EntityPortalExitEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when an entity exits a portal. +pub struct EntityPortalExitEvent; +impl FromIntoEvent for EntityPortalExitEvent { + const EVENT_TYPE: EventType = EventType::EntityPortalExitEvent; + type Data = EntityPortalExitEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::EntityPortalExitEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::EntityPortalExitEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/entity_pose_change.rs b/crates/pumpkin-plugin-api/src/events/entity/entity_pose_change.rs new file mode 100644 index 000000000..4dbca76a1 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/entity_pose_change.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{EntityPoseChangeEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// Event triggered when an entity's pose changes. +pub struct EntityPoseChangeEvent; +impl FromIntoEvent for EntityPoseChangeEvent { + const EVENT_TYPE: EventType = EventType::EntityPoseChangeEvent; + type Data = EntityPoseChangeEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::EntityPoseChangeEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::EntityPoseChangeEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/entity_potion_effect.rs b/crates/pumpkin-plugin-api/src/events/entity/entity_potion_effect.rs new file mode 100644 index 000000000..89aa6a286 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/entity_potion_effect.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{EntityPotionEffectEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// Event triggered when a potion status effect is applied to an entity. +pub struct EntityPotionEffectEvent; +impl FromIntoEvent for EntityPotionEffectEvent { + const EVENT_TYPE: EventType = EventType::EntityPotionEffectEvent; + type Data = EntityPotionEffectEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::EntityPotionEffectEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::EntityPotionEffectEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/entity_remove.rs b/crates/pumpkin-plugin-api/src/events/entity/entity_remove.rs new file mode 100644 index 000000000..79dad81e4 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/entity_remove.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{EntityRemoveEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when an entity is removed from the world. +pub struct EntityRemoveEvent; +impl FromIntoEvent for EntityRemoveEvent { + const EVENT_TYPE: EventType = EventType::EntityRemoveEvent; + type Data = EntityRemoveEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::EntityRemoveEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::EntityRemoveEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/entity_spell_cast.rs b/crates/pumpkin-plugin-api/src/events/entity/entity_spell_cast.rs new file mode 100644 index 000000000..682ff7b0d --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/entity_spell_cast.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{EntitySpellCastEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// Event triggered when a spellcasting entity casts a spell. +pub struct EntitySpellCastEvent; +impl FromIntoEvent for EntitySpellCastEvent { + const EVENT_TYPE: EventType = EventType::EntitySpellCastEvent; + type Data = EntitySpellCastEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::EntitySpellCastEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::EntitySpellCastEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/entity_target_block.rs b/crates/pumpkin-plugin-api/src/events/entity/entity_target_block.rs new file mode 100644 index 000000000..91b7fc388 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/entity_target_block.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{EntityTargetBlockEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when an entity targets a block. +pub struct EntityTargetBlockEvent; +impl FromIntoEvent for EntityTargetBlockEvent { + const EVENT_TYPE: EventType = EventType::EntityTargetBlockEvent; + type Data = EntityTargetBlockEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::EntityTargetBlockEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::EntityTargetBlockEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/entity_target_living_entity.rs b/crates/pumpkin-plugin-api/src/events/entity/entity_target_living_entity.rs new file mode 100644 index 000000000..c9fb1db29 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/entity_target_living_entity.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{EntityTargetLivingEntityEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// Event triggered when an entity targets a living entity. +pub struct EntityTargetLivingEntityEvent; +impl FromIntoEvent for EntityTargetLivingEntityEvent { + const EVENT_TYPE: EventType = EventType::EntityTargetLivingEntityEvent; + type Data = EntityTargetLivingEntityEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::EntityTargetLivingEntityEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::EntityTargetLivingEntityEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/entity_toggle_swim.rs b/crates/pumpkin-plugin-api/src/events/entity/entity_toggle_swim.rs new file mode 100644 index 000000000..9692e6baf --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/entity_toggle_swim.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{EntityToggleSwimEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// Event triggered when an entity starts or stops swimming. +pub struct EntityToggleSwimEvent; +impl FromIntoEvent for EntityToggleSwimEvent { + const EVENT_TYPE: EventType = EventType::EntityToggleSwimEvent; + type Data = EntityToggleSwimEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::EntityToggleSwimEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::EntityToggleSwimEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/entity_unleash.rs b/crates/pumpkin-plugin-api/src/events/entity/entity_unleash.rs new file mode 100644 index 000000000..f35cecff0 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/entity_unleash.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{EntityUnleashEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An event that occurs when an entity is unleashed. +pub struct EntityUnleashEvent; +impl FromIntoEvent for EntityUnleashEvent { + const EVENT_TYPE: EventType = EventType::EntityUnleashEvent; + type Data = EntityUnleashEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::EntityUnleashEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::EntityUnleashEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/exp_bottle.rs b/crates/pumpkin-plugin-api/src/events/entity/exp_bottle.rs new file mode 100644 index 000000000..5099a5a83 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/exp_bottle.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, ExpBottleEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when an experience bottle breaks. +pub struct ExpBottleEvent; +impl FromIntoEvent for ExpBottleEvent { + const EVENT_TYPE: EventType = EventType::ExpBottleEvent; + type Data = ExpBottleEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::ExpBottleEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::ExpBottleEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/explosion_prime.rs b/crates/pumpkin-plugin-api/src/events/entity/explosion_prime.rs new file mode 100644 index 000000000..f9e51d8a6 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/explosion_prime.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, ExplosionPrimeEventData}; + +use super::super::FromIntoEvent; + +/// Event triggered when an entity is primed to explode. +pub struct ExplosionPrimeEvent; +impl FromIntoEvent for ExplosionPrimeEvent { + const EVENT_TYPE: EventType = EventType::ExplosionPrimeEvent; + type Data = ExplosionPrimeEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::ExplosionPrimeEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::ExplosionPrimeEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/firework_explode.rs b/crates/pumpkin-plugin-api/src/events/entity/firework_explode.rs new file mode 100644 index 000000000..3ad98887e --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/firework_explode.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, FireworkExplodeEventData}; + +use super::super::FromIntoEvent; + +/// Event triggered when a firework rocket explodes. +pub struct FireworkExplodeEvent; +impl FromIntoEvent for FireworkExplodeEvent { + const EVENT_TYPE: EventType = EventType::FireworkExplodeEvent; + type Data = FireworkExplodeEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::FireworkExplodeEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::FireworkExplodeEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/food_level_change.rs b/crates/pumpkin-plugin-api/src/events/entity/food_level_change.rs new file mode 100644 index 000000000..0c96d1929 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/food_level_change.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, FoodLevelChangeEventData}; + +use super::super::FromIntoEvent; + +/// Event triggered when an entity's food level changes. +pub struct FoodLevelChangeEvent; +impl FromIntoEvent for FoodLevelChangeEvent { + const EVENT_TYPE: EventType = EventType::FoodLevelChangeEvent; + type Data = FoodLevelChangeEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::FoodLevelChangeEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::FoodLevelChangeEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/horse_jump.rs b/crates/pumpkin-plugin-api/src/events/entity/horse_jump.rs new file mode 100644 index 000000000..561efa65b --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/horse_jump.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, HorseJumpEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a horse jumps. +pub struct HorseJumpEvent; +impl FromIntoEvent for HorseJumpEvent { + const EVENT_TYPE: EventType = EventType::HorseJumpEvent; + type Data = HorseJumpEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::HorseJumpEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::HorseJumpEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/item_despawn.rs b/crates/pumpkin-plugin-api/src/events/entity/item_despawn.rs new file mode 100644 index 000000000..a22f520cd --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/item_despawn.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, ItemDespawnEventData}; + +use super::super::FromIntoEvent; + +/// Event triggered when an item entity despawns after aging. +pub struct ItemDespawnEvent; +impl FromIntoEvent for ItemDespawnEvent { + const EVENT_TYPE: EventType = EventType::ItemDespawnEvent; + type Data = ItemDespawnEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::ItemDespawnEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::ItemDespawnEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/item_merge.rs b/crates/pumpkin-plugin-api/src/events/entity/item_merge.rs new file mode 100644 index 000000000..e605966ca --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/item_merge.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, ItemMergeEventData}; + +use super::super::FromIntoEvent; + +/// Event triggered when two item entities merge. +pub struct ItemMergeEvent; +impl FromIntoEvent for ItemMergeEvent { + const EVENT_TYPE: EventType = EventType::ItemMergeEvent; + type Data = ItemMergeEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::ItemMergeEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::ItemMergeEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/item_spawn.rs b/crates/pumpkin-plugin-api/src/events/entity/item_spawn.rs new file mode 100644 index 000000000..a257369ad --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/item_spawn.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, ItemSpawnEventData}; + +use super::super::FromIntoEvent; + +/// Event triggered when an item entity spawns in the world. +pub struct ItemSpawnEvent; +impl FromIntoEvent for ItemSpawnEvent { + const EVENT_TYPE: EventType = EventType::ItemSpawnEvent; + type Data = ItemSpawnEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::ItemSpawnEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::ItemSpawnEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/lingering_potion_splash.rs b/crates/pumpkin-plugin-api/src/events/entity/lingering_potion_splash.rs new file mode 100644 index 000000000..12fed40ad --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/lingering_potion_splash.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, LingeringPotionSplashEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a lingering potion splashes. +pub struct LingeringPotionSplashEvent; +impl FromIntoEvent for LingeringPotionSplashEvent { + const EVENT_TYPE: EventType = EventType::LingeringPotionSplashEvent; + type Data = LingeringPotionSplashEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::LingeringPotionSplashEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::LingeringPotionSplashEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/mod.rs b/crates/pumpkin-plugin-api/src/events/entity/mod.rs index 6c88e513a..f3a9c4849 100644 --- a/crates/pumpkin-plugin-api/src/events/entity/mod.rs +++ b/crates/pumpkin-plugin-api/src/events/entity/mod.rs @@ -1,64 +1,229 @@ +/// Area effect cloud apply event. +pub mod area_effect_cloud_apply; +/// Arrow body count change event. +pub mod arrow_body_count_change; +/// Bat toggle sleep event. +pub mod bat_toggle_sleep; +/// Creature spawn event. +pub mod creature_spawn; +/// Creeper power event. +pub mod creeper_power; +/// Ender dragon change phase event. +pub mod ender_dragon_change_phase; /// Entity air change event. pub mod entity_air_change; +/// Entity break door event. +pub mod entity_break_door; /// Entity breeding event. pub mod entity_breed; +/// Entity change block event. +pub mod entity_change_block; /// Entity combust (catch fire) event. pub mod entity_combust; +/// Entity combust by block event. +pub mod entity_combust_by_block; +/// Entity combust by entity event. +pub mod entity_combust_by_entity; /// Entity damage event. pub mod entity_damage; +/// Entity damage by block event. +pub mod entity_damage_by_block; +/// Entity damage by entity event. +pub mod entity_damage_by_entity; /// Entity death and player death events. pub mod entity_death; /// Entity dismount event. pub mod entity_dismount; +/// Entity drop item event. +pub mod entity_drop_item; /// Entity dye event. pub mod entity_dye; +/// Entity enter block event. +pub mod entity_enter_block; /// Entity enter love mode event. pub mod entity_enter_love_mode; +/// Entity exhaustion event. +pub mod entity_exhaustion; /// Entity explode event. pub mod entity_explode; +/// Entity interact event. +pub mod entity_interact; +/// Entity knockback event. +pub mod entity_knockback; +/// Entity knockback by entity event. +pub mod entity_knockback_by_entity; /// Entity mount event. pub mod entity_mount; /// Entity pickup item event. pub mod entity_pickup_item; +/// Entity place event. +pub mod entity_place; /// Entity portal travel event. pub mod entity_portal; +/// Entity portal enter event. +pub mod entity_portal_enter; +/// Entity portal exit event. +pub mod entity_portal_exit; +/// Entity pose change event. +pub mod entity_pose_change; +/// Entity potion effect event. +pub mod entity_potion_effect; /// Entity health regeneration event. pub mod entity_regain_health; +/// Entity remove event. +pub mod entity_remove; /// Entity resurrect event. pub mod entity_resurrect; /// Entity shoot bow event. pub mod entity_shoot_bow; /// Entity spawn event. pub mod entity_spawn; +/// Entity spell cast event. +pub mod entity_spell_cast; /// Entity tame event. pub mod entity_tame; /// Entity target event. pub mod entity_target; +/// Entity target block event. +pub mod entity_target_block; +/// Entity target living entity event. +pub mod entity_target_living_entity; /// Entity teleport event. pub mod entity_teleport; /// Entity toggle glide event. pub mod entity_toggle_glide; +/// Entity toggle swim event. +pub mod entity_toggle_swim; /// Entity transform event. pub mod entity_transform; +/// Entity unleash event. +pub mod entity_unleash; +/// Experience bottle event. +pub mod exp_bottle; +/// Explosion prime event. +pub mod explosion_prime; +/// Firework explode event. +pub mod firework_explode; +/// Food level change event. +pub mod food_level_change; +/// Horse jump event. +pub mod horse_jump; +/// Item despawn event. +pub mod item_despawn; +/// Item merge event. +pub mod item_merge; +/// Item spawn event. +pub mod item_spawn; +/// Lingering potion splash event. +pub mod lingering_potion_splash; +/// Pig zap event. +pub mod pig_zap; +/// Pig zombie anger event. +pub mod pig_zombie_anger; +/// Piglin barter event. +pub mod piglin_barter; +/// Potion splash event. +pub mod potion_splash; +/// Projectile hit event. +pub mod projectile_hit; +/// Projectile launch event. +pub mod projectile_launch; +/// Sheep dye wool event. +pub mod sheep_dye_wool; +/// Sheep regrow wool event. +pub mod sheep_regrow_wool; +/// Slime split event. +pub mod slime_split; +/// Spawner spawn event. +pub mod spawner_spawn; +/// Strider temperature change event. +pub mod strider_temperature_change; +/// Trial spawner spawn event. +pub mod trial_spawner_spawn; +/// Villager acquire trade event. +pub mod villager_acquire_trade; +/// Villager career change event. +pub mod villager_career_change; +/// Villager replenish trade event. +pub mod villager_replenish_trade; +/// Villager reputation change event. +pub mod villager_reputation_change; +/// Warden anger change event. +pub mod warden_anger_change; +pub use area_effect_cloud_apply::*; +pub use arrow_body_count_change::*; +pub use bat_toggle_sleep::*; +pub use creature_spawn::*; +pub use creeper_power::*; +pub use ender_dragon_change_phase::*; pub use entity_air_change::*; +pub use entity_break_door::*; pub use entity_breed::*; +pub use entity_change_block::*; pub use entity_combust::*; +pub use entity_combust_by_block::*; +pub use entity_combust_by_entity::*; pub use entity_damage::*; +pub use entity_damage_by_block::*; +pub use entity_damage_by_entity::*; pub use entity_death::*; pub use entity_dismount::*; +pub use entity_drop_item::*; pub use entity_dye::*; +pub use entity_enter_block::*; pub use entity_enter_love_mode::*; +pub use entity_exhaustion::*; pub use entity_explode::*; +pub use entity_interact::*; +pub use entity_knockback::*; +pub use entity_knockback_by_entity::*; pub use entity_mount::*; pub use entity_pickup_item::*; +pub use entity_place::*; pub use entity_portal::*; +pub use entity_portal_enter::*; +pub use entity_portal_exit::*; +pub use entity_pose_change::*; +pub use entity_potion_effect::*; pub use entity_regain_health::*; +pub use entity_remove::*; pub use entity_resurrect::*; pub use entity_shoot_bow::*; pub use entity_spawn::*; +pub use entity_spell_cast::*; pub use entity_tame::*; pub use entity_target::*; +pub use entity_target_block::*; +pub use entity_target_living_entity::*; pub use entity_teleport::*; pub use entity_toggle_glide::*; +pub use entity_toggle_swim::*; pub use entity_transform::*; +pub use entity_unleash::*; +pub use exp_bottle::*; +pub use explosion_prime::*; +pub use firework_explode::*; +pub use food_level_change::*; +pub use horse_jump::*; +pub use item_despawn::*; +pub use item_merge::*; +pub use item_spawn::*; +pub use lingering_potion_splash::*; +pub use pig_zap::*; +pub use pig_zombie_anger::*; +pub use piglin_barter::*; +pub use potion_splash::*; +pub use projectile_hit::*; +pub use projectile_launch::*; +pub use sheep_dye_wool::*; +pub use sheep_regrow_wool::*; +pub use slime_split::*; +pub use spawner_spawn::*; +pub use strider_temperature_change::*; +pub use trial_spawner_spawn::*; +pub use villager_acquire_trade::*; +pub use villager_career_change::*; +pub use villager_replenish_trade::*; +pub use villager_reputation_change::*; +pub use warden_anger_change::*; diff --git a/crates/pumpkin-plugin-api/src/events/entity/pig_zap.rs b/crates/pumpkin-plugin-api/src/events/entity/pig_zap.rs new file mode 100644 index 000000000..eeb516b99 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/pig_zap.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PigZapEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a pig transforms into a zombie pigman due to lightning. +pub struct PigZapEvent; +impl FromIntoEvent for PigZapEvent { + const EVENT_TYPE: EventType = EventType::PigZapEvent; + type Data = PigZapEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PigZapEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PigZapEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/pig_zombie_anger.rs b/crates/pumpkin-plugin-api/src/events/entity/pig_zombie_anger.rs new file mode 100644 index 000000000..3c8b3fdb1 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/pig_zombie_anger.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PigZombieAngerEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a zombie pigman becomes angry. +pub struct PigZombieAngerEvent; +impl FromIntoEvent for PigZombieAngerEvent { + const EVENT_TYPE: EventType = EventType::PigZombieAngerEvent; + type Data = PigZombieAngerEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PigZombieAngerEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PigZombieAngerEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/piglin_barter.rs b/crates/pumpkin-plugin-api/src/events/entity/piglin_barter.rs new file mode 100644 index 000000000..8871c72b4 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/piglin_barter.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PiglinBarterEventData}; + +use super::super::FromIntoEvent; + +/// Event triggered when a piglin barters. +pub struct PiglinBarterEvent; +impl FromIntoEvent for PiglinBarterEvent { + const EVENT_TYPE: EventType = EventType::PiglinBarterEvent; + type Data = PiglinBarterEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PiglinBarterEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PiglinBarterEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/potion_splash.rs b/crates/pumpkin-plugin-api/src/events/entity/potion_splash.rs new file mode 100644 index 000000000..6e599476e --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/potion_splash.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PotionSplashEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a potion splashes. +pub struct PotionSplashEvent; +impl FromIntoEvent for PotionSplashEvent { + const EVENT_TYPE: EventType = EventType::PotionSplashEvent; + type Data = PotionSplashEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PotionSplashEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PotionSplashEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/projectile_hit.rs b/crates/pumpkin-plugin-api/src/events/entity/projectile_hit.rs new file mode 100644 index 000000000..8ca486895 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/projectile_hit.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, ProjectileHitEventData}; + +use super::super::FromIntoEvent; + +/// Event triggered when a projectile hits an entity or block. +pub struct ProjectileHitEvent; +impl FromIntoEvent for ProjectileHitEvent { + const EVENT_TYPE: EventType = EventType::ProjectileHitEvent; + type Data = ProjectileHitEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::ProjectileHitEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::ProjectileHitEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/projectile_launch.rs b/crates/pumpkin-plugin-api/src/events/entity/projectile_launch.rs new file mode 100644 index 000000000..8643a8898 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/projectile_launch.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, ProjectileLaunchEventData}; + +use super::super::FromIntoEvent; + +/// Event triggered when a projectile is launched. +pub struct ProjectileLaunchEvent; +impl FromIntoEvent for ProjectileLaunchEvent { + const EVENT_TYPE: EventType = EventType::ProjectileLaunchEvent; + type Data = ProjectileLaunchEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::ProjectileLaunchEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::ProjectileLaunchEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/sheep_dye_wool.rs b/crates/pumpkin-plugin-api/src/events/entity/sheep_dye_wool.rs new file mode 100644 index 000000000..ca1df1b66 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/sheep_dye_wool.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, SheepDyeWoolEventData}; + +use super::super::FromIntoEvent; + +/// Event triggered when a sheep has its wool dyed. +pub struct SheepDyeWoolEvent; +impl FromIntoEvent for SheepDyeWoolEvent { + const EVENT_TYPE: EventType = EventType::SheepDyeWoolEvent; + type Data = SheepDyeWoolEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::SheepDyeWoolEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::SheepDyeWoolEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/sheep_regrow_wool.rs b/crates/pumpkin-plugin-api/src/events/entity/sheep_regrow_wool.rs new file mode 100644 index 000000000..23558f7a8 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/sheep_regrow_wool.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, SheepRegrowWoolEventData}; + +use super::super::FromIntoEvent; + +/// Event triggered when a sheep regrows its wool. +pub struct SheepRegrowWoolEvent; +impl FromIntoEvent for SheepRegrowWoolEvent { + const EVENT_TYPE: EventType = EventType::SheepRegrowWoolEvent; + type Data = SheepRegrowWoolEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::SheepRegrowWoolEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::SheepRegrowWoolEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/slime_split.rs b/crates/pumpkin-plugin-api/src/events/entity/slime_split.rs new file mode 100644 index 000000000..bb80973e6 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/slime_split.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, SlimeSplitEventData}; + +use super::super::FromIntoEvent; + +/// Event triggered when a slime splits into smaller slimes. +pub struct SlimeSplitEvent; +impl FromIntoEvent for SlimeSplitEvent { + const EVENT_TYPE: EventType = EventType::SlimeSplitEvent; + type Data = SlimeSplitEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::SlimeSplitEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::SlimeSplitEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/spawner_spawn.rs b/crates/pumpkin-plugin-api/src/events/entity/spawner_spawn.rs new file mode 100644 index 000000000..ee177e8cd --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/spawner_spawn.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, SpawnerSpawnEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a spawner spawns an entity. +pub struct SpawnerSpawnEvent; +impl FromIntoEvent for SpawnerSpawnEvent { + const EVENT_TYPE: EventType = EventType::SpawnerSpawnEvent; + type Data = SpawnerSpawnEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::SpawnerSpawnEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::SpawnerSpawnEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/strider_temperature_change.rs b/crates/pumpkin-plugin-api/src/events/entity/strider_temperature_change.rs new file mode 100644 index 000000000..e9f0ccb70 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/strider_temperature_change.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, StriderTemperatureChangeEventData}; + +use super::super::FromIntoEvent; + +/// Event triggered when a strider's shivering status changes. +pub struct StriderTemperatureChangeEvent; +impl FromIntoEvent for StriderTemperatureChangeEvent { + const EVENT_TYPE: EventType = EventType::StriderTemperatureChangeEvent; + type Data = StriderTemperatureChangeEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::StriderTemperatureChangeEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::StriderTemperatureChangeEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/trial_spawner_spawn.rs b/crates/pumpkin-plugin-api/src/events/entity/trial_spawner_spawn.rs new file mode 100644 index 000000000..bee3d5ef9 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/trial_spawner_spawn.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, TrialSpawnerSpawnEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a trial spawner spawns an entity. +pub struct TrialSpawnerSpawnEvent; +impl FromIntoEvent for TrialSpawnerSpawnEvent { + const EVENT_TYPE: EventType = EventType::TrialSpawnerSpawnEvent; + type Data = TrialSpawnerSpawnEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::TrialSpawnerSpawnEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::TrialSpawnerSpawnEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/villager_acquire_trade.rs b/crates/pumpkin-plugin-api/src/events/entity/villager_acquire_trade.rs new file mode 100644 index 000000000..80cd140b3 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/villager_acquire_trade.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, VillagerAcquireTradeEventData}; + +use super::super::FromIntoEvent; + +/// Event triggered when a villager acquires a new trade. +pub struct VillagerAcquireTradeEvent; +impl FromIntoEvent for VillagerAcquireTradeEvent { + const EVENT_TYPE: EventType = EventType::VillagerAcquireTradeEvent; + type Data = VillagerAcquireTradeEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::VillagerAcquireTradeEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::VillagerAcquireTradeEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/villager_career_change.rs b/crates/pumpkin-plugin-api/src/events/entity/villager_career_change.rs new file mode 100644 index 000000000..bd73ae1ac --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/villager_career_change.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, VillagerCareerChangeEventData}; + +use super::super::FromIntoEvent; + +/// Event triggered when a villager changes its profession. +pub struct VillagerCareerChangeEvent; +impl FromIntoEvent for VillagerCareerChangeEvent { + const EVENT_TYPE: EventType = EventType::VillagerCareerChangeEvent; + type Data = VillagerCareerChangeEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::VillagerCareerChangeEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::VillagerCareerChangeEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/villager_replenish_trade.rs b/crates/pumpkin-plugin-api/src/events/entity/villager_replenish_trade.rs new file mode 100644 index 000000000..6ab1a511c --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/villager_replenish_trade.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, VillagerReplenishTradeEventData}; + +use super::super::FromIntoEvent; + +/// Event triggered when a villager replenishes its trades. +pub struct VillagerReplenishTradeEvent; +impl FromIntoEvent for VillagerReplenishTradeEvent { + const EVENT_TYPE: EventType = EventType::VillagerReplenishTradeEvent; + type Data = VillagerReplenishTradeEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::VillagerReplenishTradeEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::VillagerReplenishTradeEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/villager_reputation_change.rs b/crates/pumpkin-plugin-api/src/events/entity/villager_reputation_change.rs new file mode 100644 index 000000000..2908f3ce8 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/villager_reputation_change.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, VillagerReputationChangeEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a villager's reputation changes. +pub struct VillagerReputationChangeEvent; +impl FromIntoEvent for VillagerReputationChangeEvent { + const EVENT_TYPE: EventType = EventType::VillagerReputationChangeEvent; + type Data = VillagerReputationChangeEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::VillagerReputationChangeEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::VillagerReputationChangeEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/entity/warden_anger_change.rs b/crates/pumpkin-plugin-api/src/events/entity/warden_anger_change.rs new file mode 100644 index 000000000..1e3b59b17 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/entity/warden_anger_change.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, WardenAngerChangeEventData}; + +use super::super::FromIntoEvent; + +/// Event triggered when a warden's anger towards an entity changes. +pub struct WardenAngerChangeEvent; +impl FromIntoEvent for WardenAngerChangeEvent { + const EVENT_TYPE: EventType = EventType::WardenAngerChangeEvent; + type Data = WardenAngerChangeEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::WardenAngerChangeEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::WardenAngerChangeEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/hanging/hanging_break.rs b/crates/pumpkin-plugin-api/src/events/hanging/hanging_break.rs new file mode 100644 index 000000000..d0a4fe3e6 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/hanging/hanging_break.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, HangingBreakEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a hanging entity is broken. +pub struct HangingBreakEvent; +impl FromIntoEvent for HangingBreakEvent { + const EVENT_TYPE: EventType = EventType::HangingBreakEvent; + type Data = HangingBreakEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::HangingBreakEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::HangingBreakEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/hanging/hanging_break_by_entity.rs b/crates/pumpkin-plugin-api/src/events/hanging/hanging_break_by_entity.rs new file mode 100644 index 000000000..c20947d6c --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/hanging/hanging_break_by_entity.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, HangingBreakByEntityEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a hanging entity is broken by another entity. +pub struct HangingBreakByEntityEvent; +impl FromIntoEvent for HangingBreakByEntityEvent { + const EVENT_TYPE: EventType = EventType::HangingBreakByEntityEvent; + type Data = HangingBreakByEntityEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::HangingBreakByEntityEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::HangingBreakByEntityEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/hanging/hanging_place.rs b/crates/pumpkin-plugin-api/src/events/hanging/hanging_place.rs new file mode 100644 index 000000000..6a7bab0f5 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/hanging/hanging_place.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, HangingPlaceEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a hanging entity is placed. +pub struct HangingPlaceEvent; +impl FromIntoEvent for HangingPlaceEvent { + const EVENT_TYPE: EventType = EventType::HangingPlaceEvent; + type Data = HangingPlaceEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::HangingPlaceEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::HangingPlaceEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/hanging/mod.rs b/crates/pumpkin-plugin-api/src/events/hanging/mod.rs new file mode 100644 index 000000000..e26527a96 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/hanging/mod.rs @@ -0,0 +1,10 @@ +/// Hanging break event. +pub mod hanging_break; +/// Hanging break by entity event. +pub mod hanging_break_by_entity; +/// Hanging place event. +pub mod hanging_place; + +pub use hanging_break::*; +pub use hanging_break_by_entity::*; +pub use hanging_place::*; diff --git a/crates/pumpkin-plugin-api/src/events/inventory/brew.rs b/crates/pumpkin-plugin-api/src/events/inventory/brew.rs new file mode 100644 index 000000000..87618bccf --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/inventory/brew.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{BrewEventData, Event, EventType}; + +/// Event triggered when potion(s) finish brewing in a brewing stand. +pub struct BrewEvent; +impl FromIntoEvent for BrewEvent { + const EVENT_TYPE: EventType = EventType::BrewEvent; + type Data = BrewEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::BrewEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::BrewEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/inventory/brewing_stand_fuel.rs b/crates/pumpkin-plugin-api/src/events/inventory/brewing_stand_fuel.rs new file mode 100644 index 000000000..0f9bc69b0 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/inventory/brewing_stand_fuel.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{BrewingStandFuelEventData, Event, EventType}; + +/// Event triggered when brewing stand fuel is consumed or refilled. +pub struct BrewingStandFuelEvent; +impl FromIntoEvent for BrewingStandFuelEvent { + const EVENT_TYPE: EventType = EventType::BrewingStandFuelEvent; + type Data = BrewingStandFuelEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::BrewingStandFuelEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::BrewingStandFuelEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/inventory/furnace_burn.rs b/crates/pumpkin-plugin-api/src/events/inventory/furnace_burn.rs new file mode 100644 index 000000000..5fdb8e370 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/inventory/furnace_burn.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, FurnaceBurnEventData}; + +/// Event triggered when fuel is burned in a furnace. +pub struct FurnaceBurnEvent; +impl FromIntoEvent for FurnaceBurnEvent { + const EVENT_TYPE: EventType = EventType::FurnaceBurnEvent; + type Data = FurnaceBurnEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::FurnaceBurnEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::FurnaceBurnEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/inventory/furnace_extract.rs b/crates/pumpkin-plugin-api/src/events/inventory/furnace_extract.rs new file mode 100644 index 000000000..f44a0cceb --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/inventory/furnace_extract.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, FurnaceExtractEventData}; + +/// Event triggered when a player extracts items from a furnace output slot. +pub struct FurnaceExtractEvent; +impl FromIntoEvent for FurnaceExtractEvent { + const EVENT_TYPE: EventType = EventType::FurnaceExtractEvent; + type Data = FurnaceExtractEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::FurnaceExtractEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::FurnaceExtractEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/inventory/furnace_start_smelt.rs b/crates/pumpkin-plugin-api/src/events/inventory/furnace_start_smelt.rs new file mode 100644 index 000000000..7e7736cb3 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/inventory/furnace_start_smelt.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, FurnaceStartSmeltEventData}; + +/// Event triggered when a furnace starts smelting an item. +pub struct FurnaceStartSmeltEvent; +impl FromIntoEvent for FurnaceStartSmeltEvent { + const EVENT_TYPE: EventType = EventType::FurnaceStartSmeltEvent; + type Data = FurnaceStartSmeltEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::FurnaceStartSmeltEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::FurnaceStartSmeltEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/inventory/hopper_inventory_search.rs b/crates/pumpkin-plugin-api/src/events/inventory/hopper_inventory_search.rs new file mode 100644 index 000000000..c6c0ec70f --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/inventory/hopper_inventory_search.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, HopperInventorySearchEventData}; + +/// Event triggered when a hopper searches for a container. +pub struct HopperInventorySearchEvent; +impl FromIntoEvent for HopperInventorySearchEvent { + const EVENT_TYPE: EventType = EventType::HopperInventorySearchEvent; + type Data = HopperInventorySearchEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::HopperInventorySearchEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::HopperInventorySearchEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/inventory/inventory_creative.rs b/crates/pumpkin-plugin-api/src/events/inventory/inventory_creative.rs new file mode 100644 index 000000000..11a8e88f2 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/inventory/inventory_creative.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, InventoryCreativeEventData}; + +/// Event triggered when a player in creative mode sets an inventory slot. +pub struct InventoryCreativeEvent; +impl FromIntoEvent for InventoryCreativeEvent { + const EVENT_TYPE: EventType = EventType::InventoryCreativeEvent; + type Data = InventoryCreativeEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::InventoryCreativeEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::InventoryCreativeEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/inventory/inventory_interact.rs b/crates/pumpkin-plugin-api/src/events/inventory/inventory_interact.rs new file mode 100644 index 000000000..933b8d6cc --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/inventory/inventory_interact.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, InventoryInteractEventData}; + +/// Event triggered when a player interacts with an inventory. +pub struct InventoryInteractEvent; +impl FromIntoEvent for InventoryInteractEvent { + const EVENT_TYPE: EventType = EventType::InventoryInteractEvent; + type Data = InventoryInteractEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::InventoryInteractEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::InventoryInteractEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/inventory/inventory_move_item.rs b/crates/pumpkin-plugin-api/src/events/inventory/inventory_move_item.rs new file mode 100644 index 000000000..2f9861a97 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/inventory/inventory_move_item.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, InventoryMoveItemEventData}; + +/// Event triggered when an item is moved between inventories. +pub struct InventoryMoveItemEvent; +impl FromIntoEvent for InventoryMoveItemEvent { + const EVENT_TYPE: EventType = EventType::InventoryMoveItemEvent; + type Data = InventoryMoveItemEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::InventoryMoveItemEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::InventoryMoveItemEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/inventory/inventory_pickup_item.rs b/crates/pumpkin-plugin-api/src/events/inventory/inventory_pickup_item.rs new file mode 100644 index 000000000..ed155674c --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/inventory/inventory_pickup_item.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, InventoryPickupItemEventData}; + +/// Event triggered when a container inventory picks up an item entity. +pub struct InventoryPickupItemEvent; +impl FromIntoEvent for InventoryPickupItemEvent { + const EVENT_TYPE: EventType = EventType::InventoryPickupItemEvent; + type Data = InventoryPickupItemEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::InventoryPickupItemEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::InventoryPickupItemEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/inventory/mod.rs b/crates/pumpkin-plugin-api/src/events/inventory/mod.rs index 109106d76..7de247fa7 100644 --- a/crates/pumpkin-plugin-api/src/events/inventory/mod.rs +++ b/crates/pumpkin-plugin-api/src/events/inventory/mod.rs @@ -1,13 +1,64 @@ +/// Brew event. +pub mod brew; +/// Brewing stand fuel event. +pub mod brewing_stand_fuel; /// Craft item event. pub mod craft_item; +/// Furnace burn event. +pub mod furnace_burn; +/// Furnace extract event. +pub mod furnace_extract; /// Furnace smelt event. pub mod furnace_smelt; +/// Furnace start smelt event. +pub mod furnace_start_smelt; +/// Hopper inventory search event. +pub mod hopper_inventory_search; +/// Inventory creative event. +pub mod inventory_creative; /// Inventory drag event. pub mod inventory_drag; +/// Inventory interact event. +pub mod inventory_interact; +/// Inventory move item event. +pub mod inventory_move_item; /// Inventory open event. pub mod inventory_open; +/// Inventory pickup item event. +pub mod inventory_pickup_item; +/// Prepare anvil event. +pub mod prepare_anvil; +/// Prepare grindstone event. +pub mod prepare_grindstone; +/// Prepare inventory result event. +pub mod prepare_inventory_result; +/// Prepare item craft event. +pub mod prepare_item_craft; +/// Prepare smithing event. +pub mod prepare_smithing; +/// Smith item event. +pub mod smith_item; +/// Trade select event. +pub mod trade_select; +pub use brew::*; +pub use brewing_stand_fuel::*; pub use craft_item::*; +pub use furnace_burn::*; +pub use furnace_extract::*; pub use furnace_smelt::*; +pub use furnace_start_smelt::*; +pub use hopper_inventory_search::*; +pub use inventory_creative::*; pub use inventory_drag::*; +pub use inventory_interact::*; +pub use inventory_move_item::*; pub use inventory_open::*; +pub use inventory_pickup_item::*; +pub use prepare_anvil::*; +pub use prepare_grindstone::*; +pub use prepare_inventory_result::*; +pub use prepare_item_craft::*; +pub use prepare_smithing::*; +pub use smith_item::*; +pub use trade_select::*; diff --git a/crates/pumpkin-plugin-api/src/events/inventory/prepare_anvil.rs b/crates/pumpkin-plugin-api/src/events/inventory/prepare_anvil.rs new file mode 100644 index 000000000..6fd7cb07d --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/inventory/prepare_anvil.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, PrepareAnvilEventData}; + +/// Event triggered when an item is prepared in an anvil. +pub struct PrepareAnvilEvent; +impl FromIntoEvent for PrepareAnvilEvent { + const EVENT_TYPE: EventType = EventType::PrepareAnvilEvent; + type Data = PrepareAnvilEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PrepareAnvilEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PrepareAnvilEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/inventory/prepare_grindstone.rs b/crates/pumpkin-plugin-api/src/events/inventory/prepare_grindstone.rs new file mode 100644 index 000000000..dce2c725f --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/inventory/prepare_grindstone.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, PrepareGrindstoneEventData}; + +/// Event triggered when items are prepared in a grindstone. +pub struct PrepareGrindstoneEvent; +impl FromIntoEvent for PrepareGrindstoneEvent { + const EVENT_TYPE: EventType = EventType::PrepareGrindstoneEvent; + type Data = PrepareGrindstoneEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PrepareGrindstoneEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PrepareGrindstoneEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/inventory/prepare_inventory_result.rs b/crates/pumpkin-plugin-api/src/events/inventory/prepare_inventory_result.rs new file mode 100644 index 000000000..11240edb2 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/inventory/prepare_inventory_result.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, PrepareInventoryResultEventData}; + +/// Generalized event triggered when an inventory result slot is prepared. +pub struct PrepareInventoryResultEvent; +impl FromIntoEvent for PrepareInventoryResultEvent { + const EVENT_TYPE: EventType = EventType::PrepareInventoryResultEvent; + type Data = PrepareInventoryResultEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PrepareInventoryResultEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PrepareInventoryResultEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/inventory/prepare_item_craft.rs b/crates/pumpkin-plugin-api/src/events/inventory/prepare_item_craft.rs new file mode 100644 index 000000000..c8d1905ec --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/inventory/prepare_item_craft.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, PrepareItemCraftEventData}; + +/// Event triggered when a recipe is prepared in a crafting matrix. +pub struct PrepareItemCraftEvent; +impl FromIntoEvent for PrepareItemCraftEvent { + const EVENT_TYPE: EventType = EventType::PrepareItemCraftEvent; + type Data = PrepareItemCraftEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PrepareItemCraftEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PrepareItemCraftEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/inventory/prepare_smithing.rs b/crates/pumpkin-plugin-api/src/events/inventory/prepare_smithing.rs new file mode 100644 index 000000000..5e2680e49 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/inventory/prepare_smithing.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, PrepareSmithingEventData}; + +/// Event triggered when items are prepared in a smithing table. +pub struct PrepareSmithingEvent; +impl FromIntoEvent for PrepareSmithingEvent { + const EVENT_TYPE: EventType = EventType::PrepareSmithingEvent; + type Data = PrepareSmithingEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PrepareSmithingEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PrepareSmithingEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/inventory/smith_item.rs b/crates/pumpkin-plugin-api/src/events/inventory/smith_item.rs new file mode 100644 index 000000000..69d425103 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/inventory/smith_item.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, SmithItemEventData}; + +/// Event triggered when an item is crafted in a smithing table. +pub struct SmithItemEvent; +impl FromIntoEvent for SmithItemEvent { + const EVENT_TYPE: EventType = EventType::SmithItemEvent; + type Data = SmithItemEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::SmithItemEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::SmithItemEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/inventory/trade_select.rs b/crates/pumpkin-plugin-api/src/events/inventory/trade_select.rs new file mode 100644 index 000000000..d6d3a30d0 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/inventory/trade_select.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, TradeSelectEventData}; + +/// Event triggered when a player selects a merchant trade option. +pub struct TradeSelectEvent; +impl FromIntoEvent for TradeSelectEvent { + const EVENT_TYPE: EventType = EventType::TradeSelectEvent; + type Data = TradeSelectEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::TradeSelectEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::TradeSelectEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/mod.rs b/crates/pumpkin-plugin-api/src/events/mod.rs index 42f9a5e5b..0857491b2 100644 --- a/crates/pumpkin-plugin-api/src/events/mod.rs +++ b/crates/pumpkin-plugin-api/src/events/mod.rs @@ -18,25 +18,37 @@ use crate::{Context, Result, Server, wit::pumpkin::plugin::event::EventType}; /// Block events. pub mod block; +/// Enchantment events. +pub mod enchantment; /// Entity events. pub mod entity; +/// Hanging entity events. +pub mod hanging; /// Inventory events. pub mod inventory; /// Network packet events. pub mod packet; /// Player events. pub mod player; +/// Raid events. +pub mod raid; /// Server lifecycle events. pub mod server; +/// Vehicle events. +pub mod vehicle; /// World events. pub mod world; pub use block::*; +pub use enchantment::*; pub use entity::*; +pub use hanging::*; pub use inventory::*; pub use packet::*; pub use player::*; +pub use raid::*; pub use server::*; +pub use vehicle::*; pub use world::*; pub(crate) static NEXT_HANDLER_ID: AtomicU32 = AtomicU32::new(0); diff --git a/crates/pumpkin-plugin-api/src/events/player/async_player_chat.rs b/crates/pumpkin-plugin-api/src/events/player/async_player_chat.rs new file mode 100644 index 000000000..db3e8aedc --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/async_player_chat.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{AsyncPlayerChatEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An asynchronous event that occurs when a player sends a chat message. +pub struct AsyncPlayerChatEvent; +impl FromIntoEvent for AsyncPlayerChatEvent { + const EVENT_TYPE: EventType = EventType::AsyncPlayerChatEvent; + type Data = AsyncPlayerChatEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::AsyncPlayerChatEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::AsyncPlayerChatEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/async_player_pre_login.rs b/crates/pumpkin-plugin-api/src/events/player/async_player_pre_login.rs new file mode 100644 index 000000000..93497d18b --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/async_player_pre_login.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{AsyncPlayerPreLoginEventData, Event, EventType}; + +use super::super::FromIntoEvent; + +/// An asynchronous event that occurs when a player attempts to pre-login. +pub struct AsyncPlayerPreLoginEvent; +impl FromIntoEvent for AsyncPlayerPreLoginEvent { + const EVENT_TYPE: EventType = EventType::AsyncPlayerPreLoginEvent; + type Data = AsyncPlayerPreLoginEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::AsyncPlayerPreLoginEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::AsyncPlayerPreLoginEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/mod.rs b/crates/pumpkin-plugin-api/src/events/player/mod.rs index f6be1e115..a3c6a3d20 100644 --- a/crates/pumpkin-plugin-api/src/events/player/mod.rs +++ b/crates/pumpkin-plugin-api/src/events/player/mod.rs @@ -1,3 +1,7 @@ +/// Asynchronous player chat event. +pub mod async_player_chat; +/// Asynchronous player pre-login event. +pub mod async_player_pre_login; /// Bedrock form response event. pub mod bedrock_form_response; /// Player main hand change event. @@ -16,44 +20,122 @@ pub mod inventory_click; pub mod inventory_close; /// Item held slot change event. pub mod item_held; +/// Player advancement completion event. +pub mod player_advancement_done; +/// Player animation event. +pub mod player_animation; +/// Player armor stand manipulate event. +pub mod player_armor_stand_manipulate; /// Player bed enter and leave events. pub mod player_bed; /// Player bucket empty and fill events. pub mod player_bucket; +/// Player bucket entity event. +pub mod player_bucket_entity; /// Player world change event. pub mod player_change_world; +/// Player changed world event. +pub mod player_changed_world; +/// Player plugin channel event. +pub mod player_channel; /// Player chat event. pub mod player_chat; +/// Player command preprocess event. +pub mod player_command_preprocess; /// Player command send event. pub mod player_command_send; /// Player custom payload event. pub mod player_custom_payload; /// Player drop item event. pub mod player_drop_item; +/// Player edit book event. +pub mod player_edit_book; +/// Player elytra boost event. +pub mod player_elytra_boost; +/// Player experience cooldown change event. +pub mod player_exp_cooldown_change; /// Player gamemode change event. pub mod player_gamemode_change; +/// Player harvest block event. +pub mod player_harvest_block; +/// Player hide entity event. +pub mod player_hide_entity; +/// Player input event. +pub mod player_input; /// Player interact block event. pub mod player_interact; +/// Player interact at entity event. +pub mod player_interact_at_entity; /// Player interact entity event. pub mod player_interact_entity; /// Player interact unknown entity event. pub mod player_interact_unknown_entity; +/// Player item break event. +pub mod player_item_break; /// Player item consume event. pub mod player_item_consume; /// Player item damage event. pub mod player_item_damage; +/// Player item mend event. +pub mod player_item_mend; /// Player join event. pub mod player_join; +/// Player kick event. +pub mod player_kick; +/// Player leash entity event. +pub mod player_leash_entity; /// Player leave event. pub mod player_leave; +/// Player level change event. +pub mod player_level_change; +/// Player links send event. +pub mod player_links_send; +/// Player client locale change event. +pub mod player_locale_change; /// Player login event. pub mod player_login; /// Player move event. pub mod player_move; +/// Player name entity event. +pub mod player_name_entity; +/// Player open sign event. +pub mod player_open_sign; /// Player permission check event. pub mod player_permission_check; +/// Player pickup arrow event. +pub mod player_pickup_arrow; +/// Player portal event. +pub mod player_portal; +/// Player pre-login event. +pub mod player_pre_login; +/// Player recipe book click event. +pub mod player_recipe_book_click; +/// Player recipe book settings change event. +pub mod player_recipe_book_settings_change; +/// Player recipe discover event. +pub mod player_recipe_discover; +/// Player register channel event. +pub mod player_register_channel; +/// Player resource pack status event. +pub mod player_resource_pack_status; /// Player respawn event. pub mod player_respawn; +/// Player riptide event. +pub mod player_riptide; +/// Player shear entity event. +pub mod player_shear_entity; +/// Player show entity event. +pub mod player_show_entity; +/// Player spawn change event. +pub mod player_spawn_change; +/// Player spawn location event. +pub mod player_spawn_location; +/// Player statistic increment event. +pub mod player_statistic_increment; +/// Player swap hands event. +pub mod player_swap_hands; +/// Player take lectern book event. +pub mod player_take_lectern_book; /// Player teleport event. pub mod player_teleport; /// Player toggle flight event. @@ -62,7 +144,15 @@ pub mod player_toggle_flight; pub mod player_toggle_sneak; /// Player toggle sprint event. pub mod player_toggle_sprint; +/// Player unleash entity event. +pub mod player_unleash_entity; +/// Player unregister channel event. +pub mod player_unregister_channel; +/// Player velocity change event. +pub mod player_velocity; +pub use async_player_chat::*; +pub use async_player_pre_login::*; pub use bedrock_form_response::*; pub use changed_main_hand::*; pub use custom_click_action::*; @@ -72,26 +162,68 @@ pub use fish::*; pub use inventory_click::*; pub use inventory_close::*; pub use item_held::*; +pub use player_advancement_done::*; +pub use player_animation::*; +pub use player_armor_stand_manipulate::*; pub use player_bed::*; pub use player_bucket::*; +pub use player_bucket_entity::*; pub use player_change_world::*; +pub use player_changed_world::*; +pub use player_channel::*; pub use player_chat::*; +pub use player_command_preprocess::*; pub use player_command_send::*; pub use player_custom_payload::*; pub use player_drop_item::*; +pub use player_edit_book::*; +pub use player_elytra_boost::*; +pub use player_exp_cooldown_change::*; pub use player_gamemode_change::*; +pub use player_harvest_block::*; +pub use player_hide_entity::*; +pub use player_input::*; pub use player_interact::*; +pub use player_interact_at_entity::*; pub use player_interact_entity::*; pub use player_interact_unknown_entity::*; +pub use player_item_break::*; pub use player_item_consume::*; pub use player_item_damage::*; +pub use player_item_mend::*; pub use player_join::*; +pub use player_kick::*; +pub use player_leash_entity::*; pub use player_leave::*; +pub use player_level_change::*; +pub use player_links_send::*; +pub use player_locale_change::*; pub use player_login::*; pub use player_move::*; +pub use player_name_entity::*; +pub use player_open_sign::*; pub use player_permission_check::*; +pub use player_pickup_arrow::*; +pub use player_portal::*; +pub use player_pre_login::*; +pub use player_recipe_book_click::*; +pub use player_recipe_book_settings_change::*; +pub use player_recipe_discover::*; +pub use player_register_channel::*; +pub use player_resource_pack_status::*; pub use player_respawn::*; +pub use player_riptide::*; +pub use player_shear_entity::*; +pub use player_show_entity::*; +pub use player_spawn_change::*; +pub use player_spawn_location::*; +pub use player_statistic_increment::*; +pub use player_swap_hands::*; +pub use player_take_lectern_book::*; pub use player_teleport::*; pub use player_toggle_flight::*; pub use player_toggle_sneak::*; pub use player_toggle_sprint::*; +pub use player_unleash_entity::*; +pub use player_unregister_channel::*; +pub use player_velocity::*; diff --git a/crates/pumpkin-plugin-api/src/events/player/player_advancement_done.rs b/crates/pumpkin-plugin-api/src/events/player/player_advancement_done.rs new file mode 100644 index 000000000..bb6165d75 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_advancement_done.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerAdvancementDoneEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player completes an advancement. +pub struct PlayerAdvancementDoneEvent; +impl FromIntoEvent for PlayerAdvancementDoneEvent { + const EVENT_TYPE: EventType = EventType::PlayerAdvancementDoneEvent; + type Data = PlayerAdvancementDoneEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerAdvancementDoneEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerAdvancementDoneEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_animation.rs b/crates/pumpkin-plugin-api/src/events/player/player_animation.rs new file mode 100644 index 000000000..390d67287 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_animation.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerAnimationEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player performs an animation. +pub struct PlayerAnimationEvent; +impl FromIntoEvent for PlayerAnimationEvent { + const EVENT_TYPE: EventType = EventType::PlayerAnimationEvent; + type Data = PlayerAnimationEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerAnimationEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerAnimationEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_armor_stand_manipulate.rs b/crates/pumpkin-plugin-api/src/events/player/player_armor_stand_manipulate.rs new file mode 100644 index 000000000..eeae61fea --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_armor_stand_manipulate.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerArmorStandManipulateEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player manipulates an armor stand. +pub struct PlayerArmorStandManipulateEvent; +impl FromIntoEvent for PlayerArmorStandManipulateEvent { + const EVENT_TYPE: EventType = EventType::PlayerArmorStandManipulateEvent; + type Data = PlayerArmorStandManipulateEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerArmorStandManipulateEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerArmorStandManipulateEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_bucket_entity.rs b/crates/pumpkin-plugin-api/src/events/player/player_bucket_entity.rs new file mode 100644 index 000000000..86eaaa130 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_bucket_entity.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerBucketEntityEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player captures an entity with a bucket. +pub struct PlayerBucketEntityEvent; +impl FromIntoEvent for PlayerBucketEntityEvent { + const EVENT_TYPE: EventType = EventType::PlayerBucketEntityEvent; + type Data = PlayerBucketEntityEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerBucketEntityEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerBucketEntityEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_changed_world.rs b/crates/pumpkin-plugin-api/src/events/player/player_changed_world.rs new file mode 100644 index 000000000..095e061b2 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_changed_world.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerChangedWorldEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs after a player has changed worlds. +pub struct PlayerChangedWorldEvent; +impl FromIntoEvent for PlayerChangedWorldEvent { + const EVENT_TYPE: EventType = EventType::PlayerChangedWorldEvent; + type Data = PlayerChangedWorldEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerChangedWorldEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerChangedWorldEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_channel.rs b/crates/pumpkin-plugin-api/src/events/player/player_channel.rs new file mode 100644 index 000000000..cee919a61 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_channel.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerChannelEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player changes a plugin messaging channel. +pub struct PlayerChannelEvent; +impl FromIntoEvent for PlayerChannelEvent { + const EVENT_TYPE: EventType = EventType::PlayerChannelEvent; + type Data = PlayerChannelEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerChannelEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerChannelEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_command_preprocess.rs b/crates/pumpkin-plugin-api/src/events/player/player_command_preprocess.rs new file mode 100644 index 000000000..d157668da --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_command_preprocess.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerCommandPreprocessEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs before a player command is executed. +pub struct PlayerCommandPreprocessEvent; +impl FromIntoEvent for PlayerCommandPreprocessEvent { + const EVENT_TYPE: EventType = EventType::PlayerCommandPreprocessEvent; + type Data = PlayerCommandPreprocessEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerCommandPreprocessEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerCommandPreprocessEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_edit_book.rs b/crates/pumpkin-plugin-api/src/events/player/player_edit_book.rs new file mode 100644 index 000000000..774b88c45 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_edit_book.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerEditBookEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player edits or signs a book. +pub struct PlayerEditBookEvent; +impl FromIntoEvent for PlayerEditBookEvent { + const EVENT_TYPE: EventType = EventType::PlayerEditBookEvent; + type Data = PlayerEditBookEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerEditBookEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerEditBookEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_elytra_boost.rs b/crates/pumpkin-plugin-api/src/events/player/player_elytra_boost.rs new file mode 100644 index 000000000..b710bb978 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_elytra_boost.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerElytraBoostEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player boosts their elytra flight using a firework. +pub struct PlayerElytraBoostEvent; +impl FromIntoEvent for PlayerElytraBoostEvent { + const EVENT_TYPE: EventType = EventType::PlayerElytraBoostEvent; + type Data = PlayerElytraBoostEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerElytraBoostEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerElytraBoostEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_exp_cooldown_change.rs b/crates/pumpkin-plugin-api/src/events/player/player_exp_cooldown_change.rs new file mode 100644 index 000000000..a7d7cddfc --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_exp_cooldown_change.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerExpCooldownChangeEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player's experience cooldown changes. +pub struct PlayerExpCooldownChangeEvent; +impl FromIntoEvent for PlayerExpCooldownChangeEvent { + const EVENT_TYPE: EventType = EventType::PlayerExpCooldownChangeEvent; + type Data = PlayerExpCooldownChangeEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerExpCooldownChangeEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerExpCooldownChangeEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_harvest_block.rs b/crates/pumpkin-plugin-api/src/events/player/player_harvest_block.rs new file mode 100644 index 000000000..2dbdc5fca --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_harvest_block.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerHarvestBlockEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player harvests a block. +pub struct PlayerHarvestBlockEvent; +impl FromIntoEvent for PlayerHarvestBlockEvent { + const EVENT_TYPE: EventType = EventType::PlayerHarvestBlockEvent; + type Data = PlayerHarvestBlockEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerHarvestBlockEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerHarvestBlockEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_hide_entity.rs b/crates/pumpkin-plugin-api/src/events/player/player_hide_entity.rs new file mode 100644 index 000000000..e53fdcb41 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_hide_entity.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerHideEntityEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when an entity is hidden from a player. +pub struct PlayerHideEntityEvent; +impl FromIntoEvent for PlayerHideEntityEvent { + const EVENT_TYPE: EventType = EventType::PlayerHideEntityEvent; + type Data = PlayerHideEntityEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerHideEntityEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerHideEntityEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_input.rs b/crates/pumpkin-plugin-api/src/events/player/player_input.rs new file mode 100644 index 000000000..01a910408 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_input.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerInputEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when player inputs are received. +pub struct PlayerInputEvent; +impl FromIntoEvent for PlayerInputEvent { + const EVENT_TYPE: EventType = EventType::PlayerInputEvent; + type Data = PlayerInputEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerInputEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerInputEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_interact_at_entity.rs b/crates/pumpkin-plugin-api/src/events/player/player_interact_at_entity.rs new file mode 100644 index 000000000..8e2176c95 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_interact_at_entity.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerInteractAtEntityEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player interacts at a specific location on an entity. +pub struct PlayerInteractAtEntityEvent; +impl FromIntoEvent for PlayerInteractAtEntityEvent { + const EVENT_TYPE: EventType = EventType::PlayerInteractAtEntityEvent; + type Data = PlayerInteractAtEntityEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerInteractAtEntityEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerInteractAtEntityEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_item_break.rs b/crates/pumpkin-plugin-api/src/events/player/player_item_break.rs new file mode 100644 index 000000000..9c8a4d8cf --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_item_break.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerItemBreakEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player breaks an item. +pub struct PlayerItemBreakEvent; +impl FromIntoEvent for PlayerItemBreakEvent { + const EVENT_TYPE: EventType = EventType::PlayerItemBreakEvent; + type Data = PlayerItemBreakEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerItemBreakEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerItemBreakEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_item_mend.rs b/crates/pumpkin-plugin-api/src/events/player/player_item_mend.rs new file mode 100644 index 000000000..79f8891e0 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_item_mend.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerItemMendEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player's item is mended with experience. +pub struct PlayerItemMendEvent; +impl FromIntoEvent for PlayerItemMendEvent { + const EVENT_TYPE: EventType = EventType::PlayerItemMendEvent; + type Data = PlayerItemMendEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerItemMendEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerItemMendEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_kick.rs b/crates/pumpkin-plugin-api/src/events/player/player_kick.rs new file mode 100644 index 000000000..760b7a485 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_kick.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerKickEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player is kicked from the server. +pub struct PlayerKickEvent; +impl FromIntoEvent for PlayerKickEvent { + const EVENT_TYPE: EventType = EventType::PlayerKickEvent; + type Data = PlayerKickEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerKickEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerKickEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_leash_entity.rs b/crates/pumpkin-plugin-api/src/events/player/player_leash_entity.rs new file mode 100644 index 000000000..6b0b0a9fb --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_leash_entity.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerLeashEntityEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player leashes an entity. +pub struct PlayerLeashEntityEvent; +impl FromIntoEvent for PlayerLeashEntityEvent { + const EVENT_TYPE: EventType = EventType::PlayerLeashEntityEvent; + type Data = PlayerLeashEntityEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerLeashEntityEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerLeashEntityEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_level_change.rs b/crates/pumpkin-plugin-api/src/events/player/player_level_change.rs new file mode 100644 index 000000000..3fb9dc3c9 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_level_change.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerLevelChangeEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player's level changes. +pub struct PlayerLevelChangeEvent; +impl FromIntoEvent for PlayerLevelChangeEvent { + const EVENT_TYPE: EventType = EventType::PlayerLevelChangeEvent; + type Data = PlayerLevelChangeEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerLevelChangeEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerLevelChangeEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_links_send.rs b/crates/pumpkin-plugin-api/src/events/player/player_links_send.rs new file mode 100644 index 000000000..839e1d1dd --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_links_send.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerLinksSendEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when server links are sent to a player. +pub struct PlayerLinksSendEvent; +impl FromIntoEvent for PlayerLinksSendEvent { + const EVENT_TYPE: EventType = EventType::PlayerLinksSendEvent; + type Data = PlayerLinksSendEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerLinksSendEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerLinksSendEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_locale_change.rs b/crates/pumpkin-plugin-api/src/events/player/player_locale_change.rs new file mode 100644 index 000000000..579f6eb33 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_locale_change.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerLocaleChangeEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player changes client language/locale. +pub struct PlayerLocaleChangeEvent; +impl FromIntoEvent for PlayerLocaleChangeEvent { + const EVENT_TYPE: EventType = EventType::PlayerLocaleChangeEvent; + type Data = PlayerLocaleChangeEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerLocaleChangeEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerLocaleChangeEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_name_entity.rs b/crates/pumpkin-plugin-api/src/events/player/player_name_entity.rs new file mode 100644 index 000000000..69a9a8e63 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_name_entity.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerNameEntityEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player names an entity using a name tag. +pub struct PlayerNameEntityEvent; +impl FromIntoEvent for PlayerNameEntityEvent { + const EVENT_TYPE: EventType = EventType::PlayerNameEntityEvent; + type Data = PlayerNameEntityEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerNameEntityEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerNameEntityEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_open_sign.rs b/crates/pumpkin-plugin-api/src/events/player/player_open_sign.rs new file mode 100644 index 000000000..3b76cf983 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_open_sign.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerOpenSignEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player opens a sign editor. +pub struct PlayerOpenSignEvent; +impl FromIntoEvent for PlayerOpenSignEvent { + const EVENT_TYPE: EventType = EventType::PlayerOpenSignEvent; + type Data = PlayerOpenSignEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerOpenSignEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerOpenSignEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_pickup_arrow.rs b/crates/pumpkin-plugin-api/src/events/player/player_pickup_arrow.rs new file mode 100644 index 000000000..fe7372053 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_pickup_arrow.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerPickupArrowEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player picks up an arrow. +pub struct PlayerPickupArrowEvent; +impl FromIntoEvent for PlayerPickupArrowEvent { + const EVENT_TYPE: EventType = EventType::PlayerPickupArrowEvent; + type Data = PlayerPickupArrowEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerPickupArrowEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerPickupArrowEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_portal.rs b/crates/pumpkin-plugin-api/src/events/player/player_portal.rs new file mode 100644 index 000000000..9a71da830 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_portal.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerPortalEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player uses a portal. +pub struct PlayerPortalEvent; +impl FromIntoEvent for PlayerPortalEvent { + const EVENT_TYPE: EventType = EventType::PlayerPortalEvent; + type Data = PlayerPortalEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerPortalEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerPortalEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_pre_login.rs b/crates/pumpkin-plugin-api/src/events/player/player_pre_login.rs new file mode 100644 index 000000000..44d55f2ed --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_pre_login.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerPreLoginEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs synchronously when a player pre-logins. +pub struct PlayerPreLoginEvent; +impl FromIntoEvent for PlayerPreLoginEvent { + const EVENT_TYPE: EventType = EventType::PlayerPreLoginEvent; + type Data = PlayerPreLoginEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerPreLoginEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerPreLoginEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_recipe_book_click.rs b/crates/pumpkin-plugin-api/src/events/player/player_recipe_book_click.rs new file mode 100644 index 000000000..1a42f2d06 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_recipe_book_click.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerRecipeBookClickEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player clicks a recipe in the recipe book. +pub struct PlayerRecipeBookClickEvent; +impl FromIntoEvent for PlayerRecipeBookClickEvent { + const EVENT_TYPE: EventType = EventType::PlayerRecipeBookClickEvent; + type Data = PlayerRecipeBookClickEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerRecipeBookClickEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerRecipeBookClickEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_recipe_book_settings_change.rs b/crates/pumpkin-plugin-api/src/events/player/player_recipe_book_settings_change.rs new file mode 100644 index 000000000..511f7b9a3 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_recipe_book_settings_change.rs @@ -0,0 +1,23 @@ +use crate::wit::pumpkin::plugin::event::{ + Event, EventType, PlayerRecipeBookSettingsChangeEventData, +}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player changes recipe book settings. +pub struct PlayerRecipeBookSettingsChangeEvent; +impl FromIntoEvent for PlayerRecipeBookSettingsChangeEvent { + const EVENT_TYPE: EventType = EventType::PlayerRecipeBookSettingsChangeEvent; + type Data = PlayerRecipeBookSettingsChangeEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerRecipeBookSettingsChangeEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerRecipeBookSettingsChangeEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_recipe_discover.rs b/crates/pumpkin-plugin-api/src/events/player/player_recipe_discover.rs new file mode 100644 index 000000000..206cb5cfe --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_recipe_discover.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerRecipeDiscoverEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player discovers a recipe. +pub struct PlayerRecipeDiscoverEvent; +impl FromIntoEvent for PlayerRecipeDiscoverEvent { + const EVENT_TYPE: EventType = EventType::PlayerRecipeDiscoverEvent; + type Data = PlayerRecipeDiscoverEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerRecipeDiscoverEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerRecipeDiscoverEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_register_channel.rs b/crates/pumpkin-plugin-api/src/events/player/player_register_channel.rs new file mode 100644 index 000000000..fbabfc68c --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_register_channel.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerRegisterChannelEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a plugin channel is registered for a player. +pub struct PlayerRegisterChannelEvent; +impl FromIntoEvent for PlayerRegisterChannelEvent { + const EVENT_TYPE: EventType = EventType::PlayerRegisterChannelEvent; + type Data = PlayerRegisterChannelEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerRegisterChannelEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerRegisterChannelEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_resource_pack_status.rs b/crates/pumpkin-plugin-api/src/events/player/player_resource_pack_status.rs new file mode 100644 index 000000000..01d966800 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_resource_pack_status.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerResourcePackStatusEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player responds to a resource pack request. +pub struct PlayerResourcePackStatusEvent; +impl FromIntoEvent for PlayerResourcePackStatusEvent { + const EVENT_TYPE: EventType = EventType::PlayerResourcePackStatusEvent; + type Data = PlayerResourcePackStatusEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerResourcePackStatusEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerResourcePackStatusEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_riptide.rs b/crates/pumpkin-plugin-api/src/events/player/player_riptide.rs new file mode 100644 index 000000000..8a2d3bc74 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_riptide.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerRiptideEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player activates the riptide enchantment. +pub struct PlayerRiptideEvent; +impl FromIntoEvent for PlayerRiptideEvent { + const EVENT_TYPE: EventType = EventType::PlayerRiptideEvent; + type Data = PlayerRiptideEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerRiptideEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerRiptideEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_shear_entity.rs b/crates/pumpkin-plugin-api/src/events/player/player_shear_entity.rs new file mode 100644 index 000000000..bab82d09b --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_shear_entity.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerShearEntityEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player shears an entity. +pub struct PlayerShearEntityEvent; +impl FromIntoEvent for PlayerShearEntityEvent { + const EVENT_TYPE: EventType = EventType::PlayerShearEntityEvent; + type Data = PlayerShearEntityEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerShearEntityEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerShearEntityEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_show_entity.rs b/crates/pumpkin-plugin-api/src/events/player/player_show_entity.rs new file mode 100644 index 000000000..6e95b3592 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_show_entity.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerShowEntityEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when an entity is made visible to a player. +pub struct PlayerShowEntityEvent; +impl FromIntoEvent for PlayerShowEntityEvent { + const EVENT_TYPE: EventType = EventType::PlayerShowEntityEvent; + type Data = PlayerShowEntityEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerShowEntityEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerShowEntityEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_spawn_change.rs b/crates/pumpkin-plugin-api/src/events/player/player_spawn_change.rs new file mode 100644 index 000000000..0108f2ef1 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_spawn_change.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerSpawnChangeEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player's spawn location changes. +pub struct PlayerSpawnChangeEvent; +impl FromIntoEvent for PlayerSpawnChangeEvent { + const EVENT_TYPE: EventType = EventType::PlayerSpawnChangeEvent; + type Data = PlayerSpawnChangeEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerSpawnChangeEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerSpawnChangeEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_spawn_location.rs b/crates/pumpkin-plugin-api/src/events/player/player_spawn_location.rs new file mode 100644 index 000000000..7c4d4922a --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_spawn_location.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerSpawnLocationEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when determining player spawn position. +pub struct PlayerSpawnLocationEvent; +impl FromIntoEvent for PlayerSpawnLocationEvent { + const EVENT_TYPE: EventType = EventType::PlayerSpawnLocationEvent; + type Data = PlayerSpawnLocationEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerSpawnLocationEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerSpawnLocationEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_statistic_increment.rs b/crates/pumpkin-plugin-api/src/events/player/player_statistic_increment.rs new file mode 100644 index 000000000..60c65d33e --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_statistic_increment.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerStatisticIncrementEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player's statistic is incremented. +pub struct PlayerStatisticIncrementEvent; +impl FromIntoEvent for PlayerStatisticIncrementEvent { + const EVENT_TYPE: EventType = EventType::PlayerStatisticIncrementEvent; + type Data = PlayerStatisticIncrementEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerStatisticIncrementEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerStatisticIncrementEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_swap_hands.rs b/crates/pumpkin-plugin-api/src/events/player/player_swap_hands.rs new file mode 100644 index 000000000..37ccf199f --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_swap_hands.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerSwapHandsEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player swaps items between hands. +pub struct PlayerSwapHandsEvent; +impl FromIntoEvent for PlayerSwapHandsEvent { + const EVENT_TYPE: EventType = EventType::PlayerSwapHandsEvent; + type Data = PlayerSwapHandsEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerSwapHandsEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerSwapHandsEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_take_lectern_book.rs b/crates/pumpkin-plugin-api/src/events/player/player_take_lectern_book.rs new file mode 100644 index 000000000..794ad967a --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_take_lectern_book.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerTakeLecternBookEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player takes a book from a lectern. +pub struct PlayerTakeLecternBookEvent; +impl FromIntoEvent for PlayerTakeLecternBookEvent { + const EVENT_TYPE: EventType = EventType::PlayerTakeLecternBookEvent; + type Data = PlayerTakeLecternBookEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerTakeLecternBookEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerTakeLecternBookEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_unleash_entity.rs b/crates/pumpkin-plugin-api/src/events/player/player_unleash_entity.rs new file mode 100644 index 000000000..5108b8db4 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_unleash_entity.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerUnleashEntityEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player unleashes an entity. +pub struct PlayerUnleashEntityEvent; +impl FromIntoEvent for PlayerUnleashEntityEvent { + const EVENT_TYPE: EventType = EventType::PlayerUnleashEntityEvent; + type Data = PlayerUnleashEntityEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerUnleashEntityEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerUnleashEntityEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_unregister_channel.rs b/crates/pumpkin-plugin-api/src/events/player/player_unregister_channel.rs new file mode 100644 index 000000000..ec6c0106f --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_unregister_channel.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerUnregisterChannelEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a plugin channel is unregistered for a player. +pub struct PlayerUnregisterChannelEvent; +impl FromIntoEvent for PlayerUnregisterChannelEvent { + const EVENT_TYPE: EventType = EventType::PlayerUnregisterChannelEvent; + type Data = PlayerUnregisterChannelEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerUnregisterChannelEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerUnregisterChannelEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/player/player_velocity.rs b/crates/pumpkin-plugin-api/src/events/player/player_velocity.rs new file mode 100644 index 000000000..8680e175a --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/player/player_velocity.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, PlayerVelocityEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a player's velocity changes. +pub struct PlayerVelocityEvent; +impl FromIntoEvent for PlayerVelocityEvent { + const EVENT_TYPE: EventType = EventType::PlayerVelocityEvent; + type Data = PlayerVelocityEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PlayerVelocityEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PlayerVelocityEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/raid/mod.rs b/crates/pumpkin-plugin-api/src/events/raid/mod.rs new file mode 100644 index 000000000..7212f73a0 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/raid/mod.rs @@ -0,0 +1,13 @@ +/// Raid finish event. +pub mod raid_finish; +/// Raid spawn wave event. +pub mod raid_spawn_wave; +/// Raid stop event. +pub mod raid_stop; +/// Raid trigger event. +pub mod raid_trigger; + +pub use raid_finish::*; +pub use raid_spawn_wave::*; +pub use raid_stop::*; +pub use raid_trigger::*; diff --git a/crates/pumpkin-plugin-api/src/events/raid/raid_finish.rs b/crates/pumpkin-plugin-api/src/events/raid/raid_finish.rs new file mode 100644 index 000000000..7fe800dd3 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/raid/raid_finish.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, RaidFinishEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a raid finishes. +pub struct RaidFinishEvent; +impl FromIntoEvent for RaidFinishEvent { + const EVENT_TYPE: EventType = EventType::RaidFinishEvent; + type Data = RaidFinishEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::RaidFinishEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::RaidFinishEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/raid/raid_spawn_wave.rs b/crates/pumpkin-plugin-api/src/events/raid/raid_spawn_wave.rs new file mode 100644 index 000000000..a28076d49 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/raid/raid_spawn_wave.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, RaidSpawnWaveEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a wave of a raid spawns. +pub struct RaidSpawnWaveEvent; +impl FromIntoEvent for RaidSpawnWaveEvent { + const EVENT_TYPE: EventType = EventType::RaidSpawnWaveEvent; + type Data = RaidSpawnWaveEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::RaidSpawnWaveEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::RaidSpawnWaveEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/raid/raid_stop.rs b/crates/pumpkin-plugin-api/src/events/raid/raid_stop.rs new file mode 100644 index 000000000..156d9972b --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/raid/raid_stop.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, RaidStopEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a raid stops. +pub struct RaidStopEvent; +impl FromIntoEvent for RaidStopEvent { + const EVENT_TYPE: EventType = EventType::RaidStopEvent; + type Data = RaidStopEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::RaidStopEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::RaidStopEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/raid/raid_trigger.rs b/crates/pumpkin-plugin-api/src/events/raid/raid_trigger.rs new file mode 100644 index 000000000..c2b739c6b --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/raid/raid_trigger.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, RaidTriggerEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a raid is triggered. +pub struct RaidTriggerEvent; +impl FromIntoEvent for RaidTriggerEvent { + const EVENT_TYPE: EventType = EventType::RaidTriggerEvent; + type Data = RaidTriggerEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::RaidTriggerEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::RaidTriggerEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/server/map_initialize.rs b/crates/pumpkin-plugin-api/src/events/server/map_initialize.rs new file mode 100644 index 000000000..538efa810 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/server/map_initialize.rs @@ -0,0 +1,21 @@ +use crate::wit::pumpkin::plugin::event::{Event, EventType, MapInitializeEventData}; + +use super::super::FromIntoEvent; + +/// An event that occurs when a map is initialized. +pub struct MapInitializeEvent; +impl FromIntoEvent for MapInitializeEvent { + const EVENT_TYPE: EventType = EventType::MapInitializeEvent; + type Data = MapInitializeEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::MapInitializeEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::MapInitializeEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/server/mod.rs b/crates/pumpkin-plugin-api/src/events/server/mod.rs index 114157845..584deac52 100644 --- a/crates/pumpkin-plugin-api/src/events/server/mod.rs +++ b/crates/pumpkin-plugin-api/src/events/server/mod.rs @@ -1,3 +1,5 @@ +/// Map initialization event. +pub mod map_initialize; /// Server broadcast event. pub mod server_broadcast; /// Server command execution event. @@ -13,6 +15,7 @@ pub mod server_tick_start; /// Server spawn point change event. pub mod spawn_change; +pub use map_initialize::*; pub use server_broadcast::*; pub use server_command::*; pub use server_list_ping::*; diff --git a/crates/pumpkin-plugin-api/src/events/vehicle/mod.rs b/crates/pumpkin-plugin-api/src/events/vehicle/mod.rs new file mode 100644 index 000000000..1f40fae15 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/vehicle/mod.rs @@ -0,0 +1,33 @@ +//! Vehicle events. + +#[doc = "Vehicle block collision event."] +pub mod vehicle_block_collision; +#[doc = "Vehicle collision event."] +pub mod vehicle_collision; +#[doc = "Vehicle create event."] +pub mod vehicle_create; +#[doc = "Vehicle damage event."] +pub mod vehicle_damage; +#[doc = "Vehicle destroy event."] +pub mod vehicle_destroy; +#[doc = "Vehicle enter event."] +pub mod vehicle_enter; +#[doc = "Vehicle entity collision event."] +pub mod vehicle_entity_collision; +#[doc = "Vehicle exit event."] +pub mod vehicle_exit; +#[doc = "Vehicle move event."] +pub mod vehicle_move; +#[doc = "Vehicle update event."] +pub mod vehicle_update; + +pub use vehicle_block_collision::*; +pub use vehicle_collision::*; +pub use vehicle_create::*; +pub use vehicle_damage::*; +pub use vehicle_destroy::*; +pub use vehicle_enter::*; +pub use vehicle_entity_collision::*; +pub use vehicle_exit::*; +pub use vehicle_move::*; +pub use vehicle_update::*; diff --git a/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_block_collision.rs b/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_block_collision.rs new file mode 100644 index 000000000..4c918f012 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_block_collision.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, VehicleBlockCollisionEventData}; + +/// Event triggered when a vehicle collides with a block. +pub struct VehicleBlockCollisionEvent; +impl FromIntoEvent for VehicleBlockCollisionEvent { + const EVENT_TYPE: EventType = EventType::VehicleBlockCollisionEvent; + type Data = VehicleBlockCollisionEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::VehicleBlockCollisionEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::VehicleBlockCollisionEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_collision.rs b/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_collision.rs new file mode 100644 index 000000000..8cfc80fc9 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_collision.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, VehicleCollisionEventData}; + +/// Base event triggered when a vehicle collides. +pub struct VehicleCollisionEvent; +impl FromIntoEvent for VehicleCollisionEvent { + const EVENT_TYPE: EventType = EventType::VehicleCollisionEvent; + type Data = VehicleCollisionEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::VehicleCollisionEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::VehicleCollisionEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_create.rs b/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_create.rs new file mode 100644 index 000000000..cb16647b1 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_create.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, VehicleCreateEventData}; + +/// Event triggered when a vehicle is created. +pub struct VehicleCreateEvent; +impl FromIntoEvent for VehicleCreateEvent { + const EVENT_TYPE: EventType = EventType::VehicleCreateEvent; + type Data = VehicleCreateEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::VehicleCreateEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::VehicleCreateEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_damage.rs b/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_damage.rs new file mode 100644 index 000000000..abee60e11 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_damage.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, VehicleDamageEventData}; + +/// Event triggered when a vehicle takes damage. +pub struct VehicleDamageEvent; +impl FromIntoEvent for VehicleDamageEvent { + const EVENT_TYPE: EventType = EventType::VehicleDamageEvent; + type Data = VehicleDamageEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::VehicleDamageEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::VehicleDamageEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_destroy.rs b/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_destroy.rs new file mode 100644 index 000000000..7ae9dbfa2 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_destroy.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, VehicleDestroyEventData}; + +/// Event triggered when a vehicle is destroyed. +pub struct VehicleDestroyEvent; +impl FromIntoEvent for VehicleDestroyEvent { + const EVENT_TYPE: EventType = EventType::VehicleDestroyEvent; + type Data = VehicleDestroyEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::VehicleDestroyEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::VehicleDestroyEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_enter.rs b/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_enter.rs new file mode 100644 index 000000000..6c4845214 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_enter.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, VehicleEnterEventData}; + +/// Event triggered when an entity enters a vehicle. +pub struct VehicleEnterEvent; +impl FromIntoEvent for VehicleEnterEvent { + const EVENT_TYPE: EventType = EventType::VehicleEnterEvent; + type Data = VehicleEnterEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::VehicleEnterEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::VehicleEnterEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_entity_collision.rs b/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_entity_collision.rs new file mode 100644 index 000000000..8e63ce3f3 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_entity_collision.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, VehicleEntityCollisionEventData}; + +/// Event triggered when a vehicle collides with another entity. +pub struct VehicleEntityCollisionEvent; +impl FromIntoEvent for VehicleEntityCollisionEvent { + const EVENT_TYPE: EventType = EventType::VehicleEntityCollisionEvent; + type Data = VehicleEntityCollisionEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::VehicleEntityCollisionEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::VehicleEntityCollisionEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_exit.rs b/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_exit.rs new file mode 100644 index 000000000..072b13afe --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_exit.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, VehicleExitEventData}; + +/// Event triggered when an entity exits a vehicle. +pub struct VehicleExitEvent; +impl FromIntoEvent for VehicleExitEvent { + const EVENT_TYPE: EventType = EventType::VehicleExitEvent; + type Data = VehicleExitEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::VehicleExitEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::VehicleExitEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_move.rs b/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_move.rs new file mode 100644 index 000000000..4b98f4b70 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_move.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, VehicleMoveEventData}; + +/// Event triggered when a vehicle moves. +pub struct VehicleMoveEvent; +impl FromIntoEvent for VehicleMoveEvent { + const EVENT_TYPE: EventType = EventType::VehicleMoveEvent; + type Data = VehicleMoveEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::VehicleMoveEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::VehicleMoveEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_update.rs b/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_update.rs new file mode 100644 index 000000000..ad5834762 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/vehicle/vehicle_update.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, VehicleUpdateEventData}; + +/// Event triggered when a vehicle is updated per tick. +pub struct VehicleUpdateEvent; +impl FromIntoEvent for VehicleUpdateEvent { + const EVENT_TYPE: EventType = EventType::VehicleUpdateEvent; + type Data = VehicleUpdateEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::VehicleUpdateEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::VehicleUpdateEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/world/async_structure_generate.rs b/crates/pumpkin-plugin-api/src/events/world/async_structure_generate.rs new file mode 100644 index 000000000..2043eb518 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/world/async_structure_generate.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{AsyncStructureGenerateEventData, Event, EventType}; + +/// Event triggered when a structure is asynchronously generated. +pub struct AsyncStructureGenerateEvent; +impl FromIntoEvent for AsyncStructureGenerateEvent { + const EVENT_TYPE: EventType = EventType::AsyncStructureGenerateEvent; + type Data = AsyncStructureGenerateEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::AsyncStructureGenerateEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::AsyncStructureGenerateEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/world/async_structure_spawn.rs b/crates/pumpkin-plugin-api/src/events/world/async_structure_spawn.rs new file mode 100644 index 000000000..fc89562c8 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/world/async_structure_spawn.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{AsyncStructureSpawnEventData, Event, EventType}; + +/// Event triggered when a structure is asynchronously spawned. +pub struct AsyncStructureSpawnEvent; +impl FromIntoEvent for AsyncStructureSpawnEvent { + const EVENT_TYPE: EventType = EventType::AsyncStructureSpawnEvent; + type Data = AsyncStructureSpawnEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::AsyncStructureSpawnEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::AsyncStructureSpawnEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/world/chunk_populate.rs b/crates/pumpkin-plugin-api/src/events/world/chunk_populate.rs new file mode 100644 index 000000000..56d865ad7 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/world/chunk_populate.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{ChunkPopulateEventData, Event, EventType}; + +/// Event triggered when a chunk is populated. +pub struct ChunkPopulateEvent; +impl FromIntoEvent for ChunkPopulateEvent { + const EVENT_TYPE: EventType = EventType::ChunkPopulateEvent; + type Data = ChunkPopulateEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::ChunkPopulateEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::ChunkPopulateEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/world/chunk_unload.rs b/crates/pumpkin-plugin-api/src/events/world/chunk_unload.rs new file mode 100644 index 000000000..5e05fd75b --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/world/chunk_unload.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{ChunkUnloadEventData, Event, EventType}; + +/// Event triggered when a chunk is unloaded. +pub struct ChunkUnloadEvent; +impl FromIntoEvent for ChunkUnloadEvent { + const EVENT_TYPE: EventType = EventType::ChunkUnloadEvent; + type Data = ChunkUnloadEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::ChunkUnloadEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::ChunkUnloadEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/world/entities_load.rs b/crates/pumpkin-plugin-api/src/events/world/entities_load.rs new file mode 100644 index 000000000..a5f95582f --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/world/entities_load.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{EntitiesLoadEventData, Event, EventType}; + +/// Event triggered when entities are loaded in a chunk. +pub struct EntitiesLoadEvent; +impl FromIntoEvent for EntitiesLoadEvent { + const EVENT_TYPE: EventType = EventType::EntitiesLoadEvent; + type Data = EntitiesLoadEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::EntitiesLoadEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::EntitiesLoadEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/world/entities_unload.rs b/crates/pumpkin-plugin-api/src/events/world/entities_unload.rs new file mode 100644 index 000000000..53f480777 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/world/entities_unload.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{EntitiesUnloadEventData, Event, EventType}; + +/// Event triggered when entities are unloaded in a chunk. +pub struct EntitiesUnloadEvent; +impl FromIntoEvent for EntitiesUnloadEvent { + const EVENT_TYPE: EventType = EventType::EntitiesUnloadEvent; + type Data = EntitiesUnloadEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::EntitiesUnloadEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::EntitiesUnloadEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/world/generic_game.rs b/crates/pumpkin-plugin-api/src/events/world/generic_game.rs new file mode 100644 index 000000000..da80053c6 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/world/generic_game.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, GenericGameEventData}; + +/// Generic game event. +pub struct GenericGameEvent; +impl FromIntoEvent for GenericGameEvent { + const EVENT_TYPE: EventType = EventType::GenericGameEvent; + type Data = GenericGameEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::GenericGameEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::GenericGameEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/world/lightning_strike.rs b/crates/pumpkin-plugin-api/src/events/world/lightning_strike.rs new file mode 100644 index 000000000..66501f360 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/world/lightning_strike.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, LightningStrikeEventData}; + +/// Event triggered when a lightning strikes in a world. +pub struct LightningStrikeEvent; +impl FromIntoEvent for LightningStrikeEvent { + const EVENT_TYPE: EventType = EventType::LightningStrikeEvent; + type Data = LightningStrikeEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::LightningStrikeEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::LightningStrikeEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/world/loot_generate.rs b/crates/pumpkin-plugin-api/src/events/world/loot_generate.rs new file mode 100644 index 000000000..cfea32abb --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/world/loot_generate.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, LootGenerateEventData}; + +/// Event triggered when loot is generated. +pub struct LootGenerateEvent; +impl FromIntoEvent for LootGenerateEvent { + const EVENT_TYPE: EventType = EventType::LootGenerateEvent; + type Data = LootGenerateEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::LootGenerateEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::LootGenerateEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/world/mod.rs b/crates/pumpkin-plugin-api/src/events/world/mod.rs index 1af29b928..42e73a25c 100644 --- a/crates/pumpkin-plugin-api/src/events/world/mod.rs +++ b/crates/pumpkin-plugin-api/src/events/world/mod.rs @@ -1,16 +1,60 @@ -/// Chunk load event. -pub mod chunk_load; -/// Chunk save event. -pub mod chunk_save; -/// Chunk send packet event. -pub mod chunk_send; -/// Weather and thunder change events. -pub mod weather_change; -/// World load and unload events. -pub mod world_load; +//! World events. +#[doc = "Async structure generate event."] +pub mod async_structure_generate; +#[doc = "Async structure spawn event."] +pub mod async_structure_spawn; +#[doc = "Chunk load event."] +pub mod chunk_load; +#[doc = "Chunk populate event."] +pub mod chunk_populate; +#[doc = "Chunk save event."] +pub mod chunk_save; +#[doc = "Chunk send event."] +pub mod chunk_send; +#[doc = "Chunk unload event."] +pub mod chunk_unload; +#[doc = "Entities load event."] +pub mod entities_load; +#[doc = "Entities unload event."] +pub mod entities_unload; +#[doc = "Generic game event."] +pub mod generic_game; +#[doc = "Lightning strike event."] +pub mod lightning_strike; +#[doc = "Loot generate event."] +pub mod loot_generate; +#[doc = "Portal create event."] +pub mod portal_create; +#[doc = "Structure grow event."] +pub mod structure_grow; +#[doc = "Time skip event."] +pub mod time_skip; +#[doc = "Weather change event."] +pub mod weather_change; +#[doc = "World init event."] +pub mod world_init; +#[doc = "World load event."] +pub mod world_load; +#[doc = "World save event."] +pub mod world_save; + +pub use async_structure_generate::*; +pub use async_structure_spawn::*; pub use chunk_load::*; +pub use chunk_populate::*; pub use chunk_save::*; pub use chunk_send::*; +pub use chunk_unload::*; +pub use entities_load::*; +pub use entities_unload::*; +pub use generic_game::*; +pub use lightning_strike::*; +pub use loot_generate::*; +pub use portal_create::*; +pub use structure_grow::*; +pub use time_skip::*; pub use weather_change::*; +pub use world_init::*; pub use world_load::*; +pub use world_save::*; diff --git a/crates/pumpkin-plugin-api/src/events/world/portal_create.rs b/crates/pumpkin-plugin-api/src/events/world/portal_create.rs new file mode 100644 index 000000000..c0656a8e6 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/world/portal_create.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, PortalCreateEventData}; + +/// Event triggered when a portal is created. +pub struct PortalCreateEvent; +impl FromIntoEvent for PortalCreateEvent { + const EVENT_TYPE: EventType = EventType::PortalCreateEvent; + type Data = PortalCreateEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::PortalCreateEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::PortalCreateEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/world/structure_grow.rs b/crates/pumpkin-plugin-api/src/events/world/structure_grow.rs new file mode 100644 index 000000000..7534ad464 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/world/structure_grow.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, StructureGrowEventData}; + +/// Event triggered when a structure grows. +pub struct StructureGrowEvent; +impl FromIntoEvent for StructureGrowEvent { + const EVENT_TYPE: EventType = EventType::StructureGrowEvent; + type Data = StructureGrowEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::StructureGrowEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::StructureGrowEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/world/time_skip.rs b/crates/pumpkin-plugin-api/src/events/world/time_skip.rs new file mode 100644 index 000000000..ae26b2bf4 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/world/time_skip.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, TimeSkipEventData}; + +/// Event triggered when world time is skipped. +pub struct TimeSkipEvent; +impl FromIntoEvent for TimeSkipEvent { + const EVENT_TYPE: EventType = EventType::TimeSkipEvent; + type Data = TimeSkipEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::TimeSkipEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::TimeSkipEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/world/world_init.rs b/crates/pumpkin-plugin-api/src/events/world/world_init.rs new file mode 100644 index 000000000..33237fe57 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/world/world_init.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, WorldInitEventData}; + +/// Event triggered when a world initializes. +pub struct WorldInitEvent; +impl FromIntoEvent for WorldInitEvent { + const EVENT_TYPE: EventType = EventType::WorldInitEvent; + type Data = WorldInitEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::WorldInitEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::WorldInitEvent(data) + } +} diff --git a/crates/pumpkin-plugin-api/src/events/world/world_save.rs b/crates/pumpkin-plugin-api/src/events/world/world_save.rs new file mode 100644 index 000000000..764cfcce9 --- /dev/null +++ b/crates/pumpkin-plugin-api/src/events/world/world_save.rs @@ -0,0 +1,20 @@ +use super::super::FromIntoEvent; +use crate::wit::pumpkin::plugin::event::{Event, EventType, WorldSaveEventData}; + +/// Event triggered when a world is saved. +pub struct WorldSaveEvent; +impl FromIntoEvent for WorldSaveEvent { + const EVENT_TYPE: EventType = EventType::WorldSaveEvent; + type Data = WorldSaveEventData; + + fn data_from_event(event: Event) -> Self::Data { + match event { + Event::WorldSaveEvent(data) => data, + _ => panic!("unexpected event"), + } + } + + fn data_into_event(data: Self::Data) -> Event { + Event::WorldSaveEvent(data) + } +} diff --git a/crates/pumpkin-plugin-wit b/crates/pumpkin-plugin-wit index 12e3fdd3e..4fdd12365 160000 --- a/crates/pumpkin-plugin-wit +++ b/crates/pumpkin-plugin-wit @@ -1 +1 @@ -Subproject commit 12e3fdd3ed121c58d57902450ad40bec538def71 +Subproject commit 4fdd12365111fa545c175710e71af83f99fb1953 diff --git a/crates/pumpkin/src/block/blocks/cauldron.rs b/crates/pumpkin/src/block/blocks/cauldron.rs index 592a9f5eb..1cf237146 100644 --- a/crates/pumpkin/src/block/blocks/cauldron.rs +++ b/crates/pumpkin/src/block/blocks/cauldron.rs @@ -24,6 +24,29 @@ impl BlockMetadata for CauldronBlock { } } +async fn fire_cauldron_change( + world: &std::sync::Arc, + pos: pumpkin_util::math::position::BlockPos, + old_level: i32, + new_level: i32, + reason: crate::plugin::block::cauldron_level_change::CauldronChangeReason, + entity: Option>, +) -> bool { + let mut event = crate::plugin::block::cauldron_level_change::CauldronLevelChangeEvent { + block_pos: pos, + world: world.clone(), + old_level, + new_level, + reason, + entity, + cancelled: false, + }; + if let Some(server) = world.server.upgrade() { + server.plugin_manager.fire(&server, &mut event).await; + } + !event.cancelled +} + impl BlockBehaviour for CauldronBlock { #[allow(clippy::too_many_lines)] fn use_with_item<'a>( @@ -38,6 +61,18 @@ impl BlockBehaviour for CauldronBlock { // Filling empty cauldron with buckets if block_id == BlockId::CAULDRON { if item_id == Item::WATER_BUCKET.id { + if !fire_cauldron_change( + args.world, + *args.position, + 0, + 3, + crate::plugin::block::cauldron_level_change::CauldronChangeReason::BucketEmpty, + Some(args.player.clone()), + ) + .await + { + return BlockActionResult::Pass; + } let state_id = Block::WATER_CAULDRON .from_properties(&[("level", "3")]) .to_state_id(&Block::WATER_CAULDRON); diff --git a/crates/pumpkin/src/block/blocks/farmland.rs b/crates/pumpkin/src/block/blocks/farmland.rs index 02e5f6292..99ea3cfbc 100644 --- a/crates/pumpkin/src/block/blocks/farmland.rs +++ b/crates/pumpkin/src/block/blocks/farmland.rs @@ -73,13 +73,25 @@ impl BlockBehaviour for FarmlandBlock { if is_water_nearby(args.world, args.position) { let mut props = FarmlandProperties::default(args.block); props.moisture = 7; - args.world - .set_block_state( - args.position, - props.to_state_id(args.block), - BlockFlags::NOTIFY_NEIGHBORS, - ) - .await; + let mut event = crate::plugin::block::moisture_change::MoistureChangeEvent { + block_pos: *args.position, + world: args.world.clone(), + new_moisture: 7, + cancelled: false, + }; + if let Some(server) = args.world.server.upgrade() { + server.plugin_manager.fire(&server, &mut event).await; + } + if !event.cancelled { + props.moisture = (event.new_moisture.clamp(0, 7)) as u8; + args.world + .set_block_state( + args.position, + props.to_state_id(args.block), + BlockFlags::NOTIFY_NEIGHBORS, + ) + .await; + } } else { let state_id = args.world.get_block_state_id(args.position); let mut props = FarmlandProperties::from_state_id(state_id, args.block); @@ -111,14 +123,25 @@ impl BlockBehaviour for FarmlandBlock { .await; } } else { - props.moisture -= 1; - args.world - .set_block_state( - args.position, - props.to_state_id(args.block), - BlockFlags::NOTIFY_NEIGHBORS, - ) - .await; + let mut event = crate::plugin::block::moisture_change::MoistureChangeEvent { + block_pos: *args.position, + world: args.world.clone(), + new_moisture: (props.moisture as i32) - 1, + cancelled: false, + }; + if let Some(server) = args.world.server.upgrade() { + server.plugin_manager.fire(&server, &mut event).await; + } + if !event.cancelled { + props.moisture = (event.new_moisture.clamp(0, 7)) as u8; + args.world + .set_block_state( + args.position, + props.to_state_id(args.block), + BlockFlags::NOTIFY_NEIGHBORS, + ) + .await; + } } } }) diff --git a/crates/pumpkin/src/block/blocks/redstone/bell.rs b/crates/pumpkin/src/block/blocks/redstone/bell.rs index 001988c7a..cad0d3d83 100644 --- a/crates/pumpkin/src/block/blocks/redstone/bell.rs +++ b/crates/pumpkin/src/block/blocks/redstone/bell.rs @@ -21,7 +21,26 @@ use pumpkin_macros::pumpkin_block; use pumpkin_util::math::position::BlockPos; use pumpkin_world::world::BlockFlags; -fn ring_bell(position: BlockPos, world: &Arc, hit_direction: Option) { +async fn ring_bell( + position: BlockPos, + world: &Arc, + hit_direction: Option, + entity: Option>, +) -> bool { + let mut event = crate::plugin::block::bell_ring::BellRingEvent { + block_pos: position, + world: world.clone(), + direction: hit_direction.map(|d| d.to_block_direction()), + entity, + cancelled: false, + }; + if let Some(server) = world.server.upgrade() { + server.plugin_manager.fire(&server, &mut event).await; + } + if event.cancelled { + return false; + } + let (block, state_id) = world.get_block_and_state_id(&position); let props = BellLikeProperties::from_state_id(state_id, block); @@ -42,6 +61,7 @@ fn ring_bell(position: BlockPos, world: &Arc, hit_direction: Option Send block update Packet + true } fn is_point_on_bell( @@ -133,11 +153,16 @@ impl BlockBehaviour for BellBlock { if !is_point_on_bell(args.hit, props.attachment, props.facing) { return BlockActionResult::Pass; // Pass if Crosshair wasn't correctly positioned } - ring_bell( + if !ring_bell( *args.position, args.world, args.hit.face.to_horizontal_facing(), - ); + Some(args.player.clone()), + ) + .await + { + return BlockActionResult::Pass; + } args.player .increment_stat( @@ -202,7 +227,7 @@ impl BlockBehaviour for BellBlock { .await; if is_receiving_power { - ring_bell(*args.position, args.world, None); + ring_bell(*args.position, args.world, None, None).await; } } }) diff --git a/crates/pumpkin/src/block/entities/brewing_stand.rs b/crates/pumpkin/src/block/entities/brewing_stand.rs index ff832d5fd..b5d4256bc 100644 --- a/crates/pumpkin/src/block/entities/brewing_stand.rs +++ b/crates/pumpkin/src/block/entities/brewing_stand.rs @@ -436,9 +436,21 @@ impl crate::block::entities::BlockEntity for BrewingStandBlockEntity { .get_item() .has_tag(&tag::Item::MINECRAFT_BREWING_FUEL) { - self.fuel.store(20, Ordering::Relaxed); - items[4].decrement(1); - true + let mut fuel_event = crate::plugin::api::events::inventory::brewing_stand_fuel::BrewingStandFuelEvent::new( + self.position, + 20, + ); + if let Some(server) = world.server.upgrade() { + server.plugin_manager.fire(&server, &mut fuel_event).await; + } + if fuel_event.cancelled { + false + } else { + self.fuel + .store(fuel_event.fuel_power as i32, Ordering::Relaxed); + items[4].decrement(1); + true + } } else { false } diff --git a/crates/pumpkin/src/block/entities/furnace_like_block_entity.rs b/crates/pumpkin/src/block/entities/furnace_like_block_entity.rs index 97f8ea4ab..25c438333 100644 --- a/crates/pumpkin/src/block/entities/furnace_like_block_entity.rs +++ b/crates/pumpkin/src/block/entities/furnace_like_block_entity.rs @@ -446,6 +446,16 @@ macro_rules! impl_block_entity_for_cooking { } if self.is_burning() && can_accept_output { + if self.get_cooking_time_spent() == 0 { + let mut start_event = $crate::plugin::api::events::inventory::furnace_start_smelt::FurnaceStartSmeltEvent::new( + self.position, + top_item.item.registry_key.to_string(), + self.get_cooking_total_time() as u32, + ); + if let Some(server) = world.server.upgrade() { + server.plugin_manager.fire(&server, &mut start_event).await; + } + } self.cooking_time_spent.fetch_add(1, Ordering::Relaxed); if self.get_cooking_time_spent() == self.get_cooking_total_time() { diff --git a/crates/pumpkin/src/block/entities/hopper.rs b/crates/pumpkin/src/block/entities/hopper.rs index f70428e31..24abebf9a 100644 --- a/crates/pumpkin/src/block/entities/hopper.rs +++ b/crates/pumpkin/src/block/entities/hopper.rs @@ -172,6 +172,17 @@ impl HopperBlockEntity { async fn suck_in_items(&self, world: &Arc) -> bool { // TODO getEntityContainer let pos_up = &self.position.up(); + let mut search_event = crate::plugin::api::events::inventory::hopper_inventory_search::HopperInventorySearchEvent::new( + self.position, + *pos_up, + ); + if let Some(server) = world.server.upgrade() { + server.plugin_manager.fire(&server, &mut search_event).await; + } + if search_event.cancelled { + return false; + } + if let Some(entity) = world.get_block_entity(pos_up) && let Some(container) = entity.clone().get_inventory() { @@ -214,6 +225,17 @@ impl HopperBlockEntity { if let Some(item_entity) = entity_base.clone().get_item_entity() { let mut stack = item_entity.get_item_stack().lock().await; if !stack.is_empty() { + let mut pickup_event = crate::plugin::api::events::inventory::inventory_pickup_item::InventoryPickupItemEvent::new( + self.position, + item_entity.get_entity().entity_id, + stack.item.registry_key.to_string(), + ); + if let Some(server) = world.server.upgrade() { + server.plugin_manager.fire(&server, &mut pickup_event).await; + } + if pickup_event.cancelled { + continue; + } let backup = stack.clone(); let one_item = stack.split(1); if Self::add_one_item(self, self, one_item).await { @@ -248,9 +270,22 @@ impl HopperBlockEntity { if is_full { return false; } + let target_pos = self.position.offset(to_offset(&self.facing)); let items = self.items.read().await; for item in items.iter() { if !item.is_empty() { + let mut move_event = crate::plugin::api::events::inventory::inventory_move_item::InventoryMoveItemEvent::new( + self.position, + target_pos, + item.item.registry_key.to_string(), + 1, + ); + if let Some(server) = world.server.upgrade() { + server.plugin_manager.fire(&server, &mut move_event).await; + } + if move_event.cancelled { + continue; + } let mut item_clone = item.clone(); let one_item = item_clone.split(1); if Self::add_one_item(self, container.as_ref(), one_item).await { diff --git a/crates/pumpkin/src/block/mod.rs b/crates/pumpkin/src/block/mod.rs index c21158f18..53c46980b 100644 --- a/crates/pumpkin/src/block/mod.rs +++ b/crates/pumpkin/src/block/mod.rs @@ -466,8 +466,23 @@ pub async fn drop_loot( params: LootContextParameters, ) { if let Some(loot_table) = &block.loot_table { - for stack in loot_table.get_loot(params) { - world.drop_stack(pos, stack).await; + let items = loot_table.get_loot(params); + if !items.is_empty() { + let mut event = crate::plugin::block::block_drop_item::BlockDropItemEvent { + block_pos: *pos, + world: world.clone(), + player: None, + items, + cancelled: false, + }; + if let Some(server) = world.server.upgrade() { + server.plugin_manager.fire(&server, &mut event).await; + } + if !event.cancelled { + for stack in event.items { + world.drop_stack(pos, stack).await; + } + } } } @@ -476,7 +491,17 @@ pub async fn drop_loot( let amount = experience.experience.get(&mut random); // TODO: Silk touch gives no exp if amount > 0 { - ExperienceOrbEntity::spawn(world, pos.to_f64(), amount as u32).await; + let mut event = crate::plugin::block::block_exp::BlockExpEvent { + block_pos: *pos, + world: world.clone(), + exp: amount, + }; + if let Some(server) = world.server.upgrade() { + server.plugin_manager.fire(&server, &mut event).await; + } + if event.exp > 0 { + ExperienceOrbEntity::spawn(world, pos.to_f64(), event.exp as u32).await; + } } } } diff --git a/crates/pumpkin/src/entity/item.rs b/crates/pumpkin/src/entity/item.rs index 04786b234..667057f21 100644 --- a/crates/pumpkin/src/entity/item.rs +++ b/crates/pumpkin/src/entity/item.rs @@ -183,6 +183,18 @@ impl ItemEntity { (other, other_stack, self, self_stack) }; + let mut event = crate::plugin::api::events::entity::item_merge::ItemMergeEvent { + entity_id: target.entity.entity_id, + target_id: source.entity.entity_id, + cancelled: false, + }; + if let Some(server) = self.entity.world.load().server.upgrade() { + server.plugin_manager.fire(&server, &mut event).await; + } + if event.cancelled { + return; + } + // Vanilla code adds a .min(64). Not needed with Vanilla item data let max_size = stack1.get_max_stack_size(); diff --git a/crates/pumpkin/src/entity/player.rs b/crates/pumpkin/src/entity/player.rs index 78980b356..fdb840b0d 100644 --- a/crates/pumpkin/src/entity/player.rs +++ b/crates/pumpkin/src/entity/player.rs @@ -4861,6 +4861,21 @@ impl Player { } }} + let mut interact_event = + crate::plugin::api::events::inventory::inventory_interact::InventoryInteractEvent::new( + self.clone(), + ); + if let Some(server) = self.world().server.upgrade() { + server + .plugin_manager + .fire(&server, &mut interact_event) + .await; + } + if interact_event.cancelled { + screen_handler.cancel().await; + return; + } + if slot == 0 && let Some(ref stack) = clicked_item && !stack.is_empty() @@ -4870,15 +4885,96 @@ impl Player { self.clone(), stack.item.registry_key.to_string(), ); + let mut prep_craft = + crate::plugin::api::events::inventory::prepare_item_craft::PrepareItemCraftEvent::new( + self.clone(), + stack.item.registry_key.to_string(), + ); if let Some(server) = self.world().server.upgrade() { server.plugin_manager.fire(&server, &mut craft_event).await; + server.plugin_manager.fire(&server, &mut prep_craft).await; } - if craft_event.cancelled { + if craft_event.cancelled || prep_craft.cancelled { screen_handler.cancel().await; return; } } + if screen_handler.window_type() == Some(WindowType::Smithing) + && slot == 3 + && let Some(ref stack) = clicked_item + && !stack.is_empty() + { + let mut smith_event = + crate::plugin::api::events::inventory::smith_item::SmithItemEvent::new( + self.clone(), + stack.item.registry_key.to_string(), + ); + let mut prep_smith = + crate::plugin::api::events::inventory::prepare_smithing::PrepareSmithingEvent::new( + self.clone(), + Some(stack.item.registry_key.to_string()), + ); + if let Some(server) = self.world().server.upgrade() { + server.plugin_manager.fire(&server, &mut smith_event).await; + server.plugin_manager.fire(&server, &mut prep_smith).await; + } + if smith_event.cancelled { + screen_handler.cancel().await; + return; + } + } + + if (screen_handler.window_type() == Some(WindowType::Furnace) + || screen_handler.window_type() == Some(WindowType::BlastFurnace) + || screen_handler.window_type() == Some(WindowType::Smoker)) + && slot == 2 + && let Some(ref stack) = clicked_item + && !stack.is_empty() + { + let mut extract_event = + crate::plugin::api::events::inventory::furnace_extract::FurnaceExtractEvent::new( + self.clone(), + pumpkin_util::math::position::BlockPos::new(0, 0, 0), + stack.item.registry_key.to_string(), + stack.item_count as u32, + 0.0, + ); + if let Some(server) = self.world().server.upgrade() { + server + .plugin_manager + .fire(&server, &mut extract_event) + .await; + } + } + + if screen_handler.window_type() == Some(WindowType::Grindstone) + && let Some(ref stack) = clicked_item + { + let mut prep_grindstone = + crate::plugin::api::events::inventory::prepare_grindstone::PrepareGrindstoneEvent::new( + self.clone(), + if stack.is_empty() { None } else { Some(stack.item.registry_key.to_string()) }, + ); + if let Some(server) = self.world().server.upgrade() { + server + .plugin_manager + .fire(&server, &mut prep_grindstone) + .await; + } + } + + if let Some(ref stack) = clicked_item { + let mut prep_result = + crate::plugin::api::events::inventory::prepare_inventory_result::PrepareInventoryResultEvent::new( + self.clone(), + if stack.is_empty() { None } else { Some(stack.item.registry_key.to_string()) }, + ); + if let Some(server) = self.world().server.upgrade() { + server.plugin_manager.fire(&server, &mut prep_result).await; + } + } + if packet.mode == SlotActionType::QuickCraft { let mut drag_event = crate::plugin::api::events::inventory::inventory_drag::InventoryDragEvent::new( diff --git a/crates/pumpkin/src/entity/vehicle/vehicle.rs b/crates/pumpkin/src/entity/vehicle/vehicle.rs index ad0c91c38..b9e1b7767 100644 --- a/crates/pumpkin/src/entity/vehicle/vehicle.rs +++ b/crates/pumpkin/src/entity/vehicle/vehicle.rs @@ -79,11 +79,16 @@ impl VehicleEntity { } pub async fn collide_entity(&self, collided_entity_id: i32) { + let mut base_event = + crate::plugin::api::events::vehicle::vehicle_collision::VehicleCollisionEvent::new( + self.entity.entity_id, + ); let mut collide_event = crate::plugin::api::events::vehicle::vehicle_entity_collision::VehicleEntityCollisionEvent::new( self.entity.entity_id, collided_entity_id, ); if let Some(server) = self.entity.world.load().server.upgrade() { + server.plugin_manager.fire(&server, &mut base_event).await; server .plugin_manager .fire(&server, &mut collide_event) @@ -92,11 +97,16 @@ impl VehicleEntity { } pub async fn collide_block(&self, block_pos: pumpkin_util::math::position::BlockPos) { + let mut base_event = + crate::plugin::api::events::vehicle::vehicle_collision::VehicleCollisionEvent::new( + self.entity.entity_id, + ); let mut collide_event = crate::plugin::api::events::vehicle::vehicle_block_collision::VehicleBlockCollisionEvent::new( self.entity.entity_id, block_pos, ); if let Some(server) = self.entity.world.load().server.upgrade() { + server.plugin_manager.fire(&server, &mut base_event).await; server .plugin_manager .fire(&server, &mut collide_event) diff --git a/crates/pumpkin/src/net/java/mod.rs b/crates/pumpkin/src/net/java/mod.rs index 36c921d9e..f352cc7c5 100644 --- a/crates/pumpkin/src/net/java/mod.rs +++ b/crates/pumpkin/src/net/java/mod.rs @@ -949,6 +949,7 @@ impl JavaClient { } id if id == SRecipeBookChangeSettings::to_id(version) => { self.handle_recipe_book_change_settings( + server, player, SRecipeBookChangeSettings::read(&mut payload, &version)?, ) @@ -956,6 +957,7 @@ impl JavaClient { } id if id == SRecipeBookSeenRecipe::to_id(version) => { self.handle_recipe_book_seen_recipe( + server, player, SRecipeBookSeenRecipe::read(&mut payload, &version)?, ) diff --git a/crates/pumpkin/src/net/java/play/client_information.rs b/crates/pumpkin/src/net/java/play/client_information.rs index 374e61ecc..f61079741 100644 --- a/crates/pumpkin/src/net/java/play/client_information.rs +++ b/crates/pumpkin/src/net/java/play/client_information.rs @@ -20,12 +20,13 @@ impl JavaClient { return; } - let (update_settings, update_watched, main_hand_changed) = { + let (update_settings, update_watched, main_hand_changed, locale_changed) = { // 1. Load current snapshot let current_config = player.config.load(); // 2. Calculate if settings changed before we overwrite let main_hand_changed = current_config.main_hand != main_hand; + let locale_changed = current_config.locale != client_information.locale; let update_settings = main_hand_changed || current_config.skin_parts != client_information.skin_parts; @@ -62,7 +63,12 @@ impl JavaClient { // 4. Atomically swap the new config into the player player.config.store(std::sync::Arc::new(new_config)); - (update_settings, update_watched, main_hand_changed) + ( + update_settings, + update_watched, + main_hand_changed, + locale_changed, + ) }; if update_watched { @@ -74,6 +80,15 @@ impl JavaClient { server.plugin_manager.fire(server, &mut event).await; } + if locale_changed { + let mut event = crate::plugin::api::events::player::player_locale_change::PlayerLocaleChangeEvent { + player: player.clone(), + new_locale: client_information.locale.to_string(), + cancelled: false, + }; + server.plugin_manager.fire(server, &mut event).await; + } + if update_settings { debug!( "Player {} ({}) updated their skin.", diff --git a/crates/pumpkin/src/net/java/play/interact.rs b/crates/pumpkin/src/net/java/play/interact.rs index 529c0fa60..9a41b7948 100644 --- a/crates/pumpkin/src/net/java/play/interact.rs +++ b/crates/pumpkin/src/net/java/play/interact.rs @@ -86,6 +86,22 @@ impl JavaClient { player.attack(event.target).await; } ActionType::Interact | ActionType::InteractAt => { + if event.action == ActionType::InteractAt + && let Some(pos) = interact.target_position + { + let mut at_event = crate::plugin::api::events::player::player_interact_at_entity::PlayerInteractAtEntityEvent::new( + player.clone(), + entity_id.0, + pos.x, + pos.y, + pos.z, + u8::from(interact.hand.map_or(0, |h| h.0) != 0), + ); + server.plugin_manager.fire(server, &mut at_event).await; + if at_event.cancelled { + return; + } + } let mut stack = player.inventory().held_item().await; let target_entity = event.target.get_entity(); if target_entity.entity_type.resource_name == "zombie_villager" diff --git a/crates/pumpkin/src/net/java/play/place_recipe.rs b/crates/pumpkin/src/net/java/play/place_recipe.rs index 346fba000..b03331d14 100644 --- a/crates/pumpkin/src/net/java/play/place_recipe.rs +++ b/crates/pumpkin/src/net/java/play/place_recipe.rs @@ -20,6 +20,16 @@ impl JavaClient { let target_id = packet.recipe_display_id.0 as usize; let use_max = packet.use_max_items; + let mut click_event = crate::plugin::api::events::player::player_recipe_book_click::PlayerRecipeBookClickEvent::new( + player.clone(), + format!("display_{}", packet.recipe_display_id.0), + use_max, + ); + server.plugin_manager.fire(server, &mut click_event).await; + if click_event.cancelled { + return; + } + // Count crafting display IDs. let crafting_display_count = RECIPES_CRAFTING .iter() diff --git a/crates/pumpkin/src/net/java/play/player_input.rs b/crates/pumpkin/src/net/java/play/player_input.rs index 0f3a6cedd..6cc46b612 100644 --- a/crates/pumpkin/src/net/java/play/player_input.rs +++ b/crates/pumpkin/src/net/java/play/player_input.rs @@ -8,6 +8,16 @@ impl JavaClient { input: SPlayerInput, server: &Arc, ) { + let mut input_event = + crate::plugin::api::events::player::player_input::PlayerInputEvent::new( + player.clone(), + format!("{:b}", input.input), + ); + server.plugin_manager.fire(server, &mut input_event).await; + if input_event.cancelled { + return; + } + player.last_input.store(input.input, Ordering::Relaxed); let sneak = input.input & SPlayerInput::SNEAK != 0; diff --git a/crates/pumpkin/src/net/java/play/recipe_book_change_settings.rs b/crates/pumpkin/src/net/java/play/recipe_book_change_settings.rs index 457bae980..3b2fd9f09 100644 --- a/crates/pumpkin/src/net/java/play/recipe_book_change_settings.rs +++ b/crates/pumpkin/src/net/java/play/recipe_book_change_settings.rs @@ -2,12 +2,18 @@ use super::*; impl JavaClient { - #[allow(clippy::unused_async)] pub async fn handle_recipe_book_change_settings( &self, - _player: &Arc, - _packet: SRecipeBookChangeSettings, + server: &Arc, + player: &Arc, + packet: SRecipeBookChangeSettings, ) { - // Client is updating its recipe book filter/open state; no server action needed. + let mut event = crate::plugin::api::events::player::player_recipe_book_settings_change::PlayerRecipeBookSettingsChangeEvent::new( + player.clone(), + format!("{:?}", packet.book_type), + packet.is_open, + packet.is_filtering, + ); + server.plugin_manager.fire(server, &mut event).await; } } diff --git a/crates/pumpkin/src/net/java/play/recipe_book_seen_recipe.rs b/crates/pumpkin/src/net/java/play/recipe_book_seen_recipe.rs index 3e4677c9b..e90c90aa5 100644 --- a/crates/pumpkin/src/net/java/play/recipe_book_seen_recipe.rs +++ b/crates/pumpkin/src/net/java/play/recipe_book_seen_recipe.rs @@ -2,12 +2,16 @@ use super::*; impl JavaClient { - #[allow(clippy::unused_async)] pub async fn handle_recipe_book_seen_recipe( &self, - _player: &Arc, - _packet: SRecipeBookSeenRecipe, + server: &Arc, + player: &Arc, + packet: SRecipeBookSeenRecipe, ) { - // Client acknowledged a recipe display; no server action needed. + let mut event = crate::plugin::api::events::player::player_recipe_discover::PlayerRecipeDiscoverEvent::new( + player.clone(), + format!("display_{}", packet.recipe_display_id.0), + ); + server.plugin_manager.fire(server, &mut event).await; } } diff --git a/crates/pumpkin/src/net/java/play/set_creative_slot.rs b/crates/pumpkin/src/net/java/play/set_creative_slot.rs index 8c6e16de9..88e9a4f63 100644 --- a/crates/pumpkin/src/net/java/play/set_creative_slot.rs +++ b/crates/pumpkin/src/net/java/play/set_creative_slot.rs @@ -4,7 +4,7 @@ use super::*; impl JavaClient { pub async fn handle_set_creative_slot( &self, - player: &Player, + player: &Arc, packet: SSetCreativeSlot, ) -> Result<(), InventoryError> { if player.gamemode.load() != GameMode::Creative { @@ -15,6 +15,23 @@ impl JavaClient { let item_stack = packet .clicked_item .to_stack_for_version(&self.version.load()); + let mut creative_event = + crate::plugin::api::events::inventory::inventory_creative::InventoryCreativeEvent::new( + player.clone(), + packet.slot, + item_stack.item.registry_key.to_string(), + item_stack.item_count, + ); + if let Some(server) = player.world().server.upgrade() { + server + .plugin_manager + .fire(&server, &mut creative_event) + .await; + } + if creative_event.cancelled { + return Ok(()); + } + let is_legal = item_stack.is_empty() || item_stack.item_count <= item_stack.get_max_stack_size(); diff --git a/crates/pumpkin/src/plugin/api/events/block/bell_resonate.rs b/crates/pumpkin/src/plugin/api/events/block/bell_resonate.rs new file mode 100644 index 000000000..f3d3f73d6 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/block/bell_resonate.rs @@ -0,0 +1,24 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use crate::world::World; + +/// An event that occurs when a bell resonates and highlights nearby raiders. +#[cancellable] +#[derive(Event, Clone)] +pub struct BellResonateEvent { + pub block_pos: BlockPos, + pub world: Arc, +} + +impl BellResonateEvent { + #[must_use] + pub const fn new(block_pos: BlockPos, world: Arc) -> Self { + Self { + block_pos, + world, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/block/bell_ring.rs b/crates/pumpkin/src/plugin/api/events/block/bell_ring.rs new file mode 100644 index 000000000..751da54f7 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/block/bell_ring.rs @@ -0,0 +1,34 @@ +use pumpkin_data::BlockDirection; +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use crate::{entity::EntityBase, world::World}; + +/// An event that occurs when a bell is rung. +#[cancellable] +#[derive(Event, Clone)] +pub struct BellRingEvent { + pub block_pos: BlockPos, + pub world: Arc, + pub entity: Option>, + pub direction: Option, +} + +impl BellRingEvent { + #[must_use] + pub const fn new( + block_pos: BlockPos, + world: Arc, + entity: Option>, + direction: Option, + ) -> Self { + Self { + block_pos, + world, + entity, + direction, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/block/block_brush.rs b/crates/pumpkin/src/plugin/api/events/block/block_brush.rs new file mode 100644 index 000000000..4caa554d6 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/block/block_brush.rs @@ -0,0 +1,34 @@ +use pumpkin_data::item_stack::ItemStack; +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use crate::{entity::player::Player, world::World}; + +/// An event that occurs when a player brushes a brushable block (e.g. suspicious sand/gravel). +#[cancellable] +#[derive(Event, Clone)] +pub struct BlockBrushEvent { + pub block_pos: BlockPos, + pub world: Arc, + pub player: Arc, + pub item: ItemStack, +} + +impl BlockBrushEvent { + #[must_use] + pub const fn new( + block_pos: BlockPos, + world: Arc, + player: Arc, + item: ItemStack, + ) -> Self { + Self { + block_pos, + world, + player, + item, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/block/block_cook.rs b/crates/pumpkin/src/plugin/api/events/block/block_cook.rs new file mode 100644 index 000000000..c4c900c0e --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/block/block_cook.rs @@ -0,0 +1,34 @@ +use pumpkin_data::item_stack::ItemStack; +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use crate::world::World; + +/// An event that occurs when a block cooks an item (e.g. campfire). +#[cancellable] +#[derive(Event, Clone)] +pub struct BlockCookEvent { + pub block_pos: BlockPos, + pub world: Arc, + pub source: ItemStack, + pub result: ItemStack, +} + +impl BlockCookEvent { + #[must_use] + pub const fn new( + block_pos: BlockPos, + world: Arc, + source: ItemStack, + result: ItemStack, + ) -> Self { + Self { + block_pos, + world, + source, + result, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/block/block_damage_abort.rs b/crates/pumpkin/src/plugin/api/events/block/block_damage_abort.rs new file mode 100644 index 000000000..f1af35fe9 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/block/block_damage_abort.rs @@ -0,0 +1,32 @@ +use pumpkin_data::item_stack::ItemStack; +use pumpkin_macros::Event; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use crate::{entity::player::Player, world::World}; + +/// An event that occurs when a player stops damaging/mining a block before breaking it. +#[derive(Event, Clone)] +pub struct BlockDamageAbortEvent { + pub player: Arc, + pub block_pos: BlockPos, + pub world: Arc, + pub item_in_hand: ItemStack, +} + +impl BlockDamageAbortEvent { + #[must_use] + pub const fn new( + player: Arc, + block_pos: BlockPos, + world: Arc, + item_in_hand: ItemStack, + ) -> Self { + Self { + player, + block_pos, + world, + item_in_hand, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/block/block_dispense_armor.rs b/crates/pumpkin/src/plugin/api/events/block/block_dispense_armor.rs new file mode 100644 index 000000000..9da950702 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/block/block_dispense_armor.rs @@ -0,0 +1,34 @@ +use pumpkin_data::item_stack::ItemStack; +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use crate::{entity::EntityBase, world::World}; + +/// An event that occurs when a dispenser equips armor on an entity. +#[cancellable] +#[derive(Event, Clone)] +pub struct BlockDispenseArmorEvent { + pub block_pos: BlockPos, + pub world: Arc, + pub target: Arc, + pub item: ItemStack, +} + +impl BlockDispenseArmorEvent { + #[must_use] + pub const fn new( + block_pos: BlockPos, + world: Arc, + target: Arc, + item: ItemStack, + ) -> Self { + Self { + block_pos, + world, + target, + item, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/block/block_dispense_loot.rs b/crates/pumpkin/src/plugin/api/events/block/block_dispense_loot.rs new file mode 100644 index 000000000..339c2eb7d --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/block/block_dispense_loot.rs @@ -0,0 +1,27 @@ +use pumpkin_data::item_stack::ItemStack; +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use crate::world::World; + +/// An event that occurs when a block dispenses loot (e.g. vault, trial spawner). +#[cancellable] +#[derive(Event, Clone)] +pub struct BlockDispenseLootEvent { + pub block_pos: BlockPos, + pub world: Arc, + pub items: Vec, +} + +impl BlockDispenseLootEvent { + #[must_use] + pub const fn new(block_pos: BlockPos, world: Arc, items: Vec) -> Self { + Self { + block_pos, + world, + items, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/block/block_drop_item.rs b/crates/pumpkin/src/plugin/api/events/block/block_drop_item.rs new file mode 100644 index 000000000..8556891a2 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/block/block_drop_item.rs @@ -0,0 +1,34 @@ +use pumpkin_data::item_stack::ItemStack; +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use crate::{entity::player::Player, world::World}; + +/// An event that occurs when a block drops items into the world. +#[cancellable] +#[derive(Event, Clone)] +pub struct BlockDropItemEvent { + pub block_pos: BlockPos, + pub world: Arc, + pub player: Option>, + pub items: Vec, +} + +impl BlockDropItemEvent { + #[must_use] + pub const fn new( + block_pos: BlockPos, + world: Arc, + player: Option>, + items: Vec, + ) -> Self { + Self { + block_pos, + world, + player, + items, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/block/block_exp.rs b/crates/pumpkin/src/plugin/api/events/block/block_exp.rs new file mode 100644 index 000000000..8e46692d5 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/block/block_exp.rs @@ -0,0 +1,24 @@ +use pumpkin_macros::Event; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use crate::world::World; + +/// An event that occurs when a block gives experience (e.g. mining ore). +#[derive(Event, Clone)] +pub struct BlockExpEvent { + pub block_pos: BlockPos, + pub world: Arc, + pub exp: i32, +} + +impl BlockExpEvent { + #[must_use] + pub const fn new(block_pos: BlockPos, world: Arc, exp: i32) -> Self { + Self { + block_pos, + world, + exp, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/block/block_fertilize.rs b/crates/pumpkin/src/plugin/api/events/block/block_fertilize.rs new file mode 100644 index 000000000..6ab000dfb --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/block/block_fertilize.rs @@ -0,0 +1,34 @@ +use pumpkin_data::BlockStateId; +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use crate::{entity::player::Player, world::World}; + +/// An event that occurs when a block is fertilized. +#[cancellable] +#[derive(Event, Clone)] +pub struct BlockFertilizeEvent { + pub block_pos: BlockPos, + pub world: Arc, + pub player: Option>, + pub changed_blocks: Vec<(BlockPos, BlockStateId)>, +} + +impl BlockFertilizeEvent { + #[must_use] + pub const fn new( + block_pos: BlockPos, + world: Arc, + player: Option>, + changed_blocks: Vec<(BlockPos, BlockStateId)>, + ) -> Self { + Self { + block_pos, + world, + player, + changed_blocks, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/block/block_multi_place.rs b/crates/pumpkin/src/plugin/api/events/block/block_multi_place.rs new file mode 100644 index 000000000..57df48019 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/block/block_multi_place.rs @@ -0,0 +1,31 @@ +use pumpkin_data::BlockStateId; +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use crate::{entity::player::Player, world::World}; + +/// An event that occurs when multiple blocks are placed at once (e.g. bed, door). +#[cancellable] +#[derive(Event, Clone)] +pub struct BlockMultiPlaceEvent { + pub player: Arc, + pub world: Arc, + pub placed_blocks: Vec<(BlockPos, BlockStateId)>, +} + +impl BlockMultiPlaceEvent { + #[must_use] + pub const fn new( + player: Arc, + world: Arc, + placed_blocks: Vec<(BlockPos, BlockStateId)>, + ) -> Self { + Self { + player, + world, + placed_blocks, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/block/block_receive_game.rs b/crates/pumpkin/src/plugin/api/events/block/block_receive_game.rs new file mode 100644 index 000000000..a3e58f02c --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/block/block_receive_game.rs @@ -0,0 +1,33 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use crate::{entity::EntityBase, world::World}; + +/// An event that occurs when a block receives a game event (e.g. sculk sensor). +#[cancellable] +#[derive(Event, Clone)] +pub struct BlockReceiveGameEvent { + pub block_pos: BlockPos, + pub world: Arc, + pub game_event: String, + pub source_entity: Option>, +} + +impl BlockReceiveGameEvent { + #[must_use] + pub const fn new( + block_pos: BlockPos, + world: Arc, + game_event: String, + source_entity: Option>, + ) -> Self { + Self { + block_pos, + world, + game_event, + source_entity, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/block/block_shear_entity.rs b/crates/pumpkin/src/plugin/api/events/block/block_shear_entity.rs new file mode 100644 index 000000000..2cb169e36 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/block/block_shear_entity.rs @@ -0,0 +1,34 @@ +use pumpkin_data::item_stack::ItemStack; +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use crate::{entity::EntityBase, world::World}; + +/// An event that occurs when a dispenser shears an entity. +#[cancellable] +#[derive(Event, Clone)] +pub struct BlockShearEntityEvent { + pub block_pos: BlockPos, + pub world: Arc, + pub target: Arc, + pub item: ItemStack, +} + +impl BlockShearEntityEvent { + #[must_use] + pub const fn new( + block_pos: BlockPos, + world: Arc, + target: Arc, + item: ItemStack, + ) -> Self { + Self { + block_pos, + world, + target, + item, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/block/block_spread.rs b/crates/pumpkin/src/plugin/api/events/block/block_spread.rs new file mode 100644 index 000000000..640b34d77 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/block/block_spread.rs @@ -0,0 +1,34 @@ +use pumpkin_data::BlockStateId; +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use crate::world::World; + +/// An event that occurs when a block spreads to another position based on world conditions (e.g. grass, mycelium, fire). +#[cancellable] +#[derive(Event, Clone)] +pub struct BlockSpreadEvent { + pub source_pos: BlockPos, + pub target_pos: BlockPos, + pub world: Arc, + pub new_state_id: BlockStateId, +} + +impl BlockSpreadEvent { + #[must_use] + pub const fn new( + source_pos: BlockPos, + target_pos: BlockPos, + world: Arc, + new_state_id: BlockStateId, + ) -> Self { + Self { + source_pos, + target_pos, + world, + new_state_id, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/block/brewing_start.rs b/crates/pumpkin/src/plugin/api/events/block/brewing_start.rs new file mode 100644 index 000000000..a2168b06a --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/block/brewing_start.rs @@ -0,0 +1,26 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use crate::world::World; + +/// An event that occurs when a brewing stand starts brewing. +#[cancellable] +#[derive(Event, Clone)] +pub struct BrewingStartEvent { + pub block_pos: BlockPos, + pub world: Arc, + pub brewing_time: i32, +} + +impl BrewingStartEvent { + #[must_use] + pub const fn new(block_pos: BlockPos, world: Arc, brewing_time: i32) -> Self { + Self { + block_pos, + world, + brewing_time, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/block/campfire_start.rs b/crates/pumpkin/src/plugin/api/events/block/campfire_start.rs new file mode 100644 index 000000000..f8e0b9a6a --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/block/campfire_start.rs @@ -0,0 +1,37 @@ +use pumpkin_data::item_stack::ItemStack; +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use crate::world::World; + +/// An event that occurs when a campfire starts cooking an item. +#[cancellable] +#[derive(Event, Clone)] +pub struct CampfireStartEvent { + pub block_pos: BlockPos, + pub world: Arc, + pub item: ItemStack, + pub slot: u8, + pub cooking_time: i32, +} + +impl CampfireStartEvent { + #[must_use] + pub const fn new( + block_pos: BlockPos, + world: Arc, + item: ItemStack, + slot: u8, + cooking_time: i32, + ) -> Self { + Self { + block_pos, + world, + item, + slot, + cooking_time, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/block/cauldron_level_change.rs b/crates/pumpkin/src/plugin/api/events/block/cauldron_level_change.rs new file mode 100644 index 000000000..af674b365 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/block/cauldron_level_change.rs @@ -0,0 +1,51 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use crate::{entity::EntityBase, world::World}; + +/// Reason why a cauldron's fluid level changed. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CauldronChangeReason { + BucketEmpty, + BucketFill, + BottleEmpty, + BottleFill, + NaturalFill, + Extinguish, + Unknown, +} + +/// An event that occurs when a cauldron's level changes. +#[cancellable] +#[derive(Event, Clone)] +pub struct CauldronLevelChangeEvent { + pub block_pos: BlockPos, + pub world: Arc, + pub old_level: i32, + pub new_level: i32, + pub reason: CauldronChangeReason, + pub entity: Option>, +} + +impl CauldronLevelChangeEvent { + #[must_use] + pub const fn new( + block_pos: BlockPos, + world: Arc, + old_level: i32, + new_level: i32, + reason: CauldronChangeReason, + entity: Option>, + ) -> Self { + Self { + block_pos, + world, + old_level, + new_level, + reason, + entity, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/block/crafter_craft.rs b/crates/pumpkin/src/plugin/api/events/block/crafter_craft.rs new file mode 100644 index 000000000..8d86c5edb --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/block/crafter_craft.rs @@ -0,0 +1,27 @@ +use pumpkin_data::item_stack::ItemStack; +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use crate::world::World; + +/// An event that occurs when an automated crafter crafts an item. +#[cancellable] +#[derive(Event, Clone)] +pub struct CrafterCraftEvent { + pub block_pos: BlockPos, + pub world: Arc, + pub result: ItemStack, +} + +impl CrafterCraftEvent { + #[must_use] + pub const fn new(block_pos: BlockPos, world: Arc, result: ItemStack) -> Self { + Self { + block_pos, + world, + result, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/block/entity_block_form.rs b/crates/pumpkin/src/plugin/api/events/block/entity_block_form.rs new file mode 100644 index 000000000..5fcca6dd9 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/block/entity_block_form.rs @@ -0,0 +1,34 @@ +use pumpkin_data::BlockStateId; +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use crate::{entity::EntityBase, world::World}; + +/// An event that occurs when a block forms as a result of an entity's actions (e.g. frost walker, snow golem). +#[cancellable] +#[derive(Event, Clone)] +pub struct EntityBlockFormEvent { + pub entity: Arc, + pub block_pos: BlockPos, + pub world: Arc, + pub new_state_id: BlockStateId, +} + +impl EntityBlockFormEvent { + #[must_use] + pub const fn new( + entity: Arc, + block_pos: BlockPos, + world: Arc, + new_state_id: BlockStateId, + ) -> Self { + Self { + entity, + block_pos, + world, + new_state_id, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/block/fluid_level_change.rs b/crates/pumpkin/src/plugin/api/events/block/fluid_level_change.rs new file mode 100644 index 000000000..5b9deb416 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/block/fluid_level_change.rs @@ -0,0 +1,27 @@ +use pumpkin_data::BlockStateId; +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use crate::world::World; + +/// An event that occurs when a fluid's level changes. +#[cancellable] +#[derive(Event, Clone)] +pub struct FluidLevelChangeEvent { + pub block_pos: BlockPos, + pub world: Arc, + pub new_state_id: BlockStateId, +} + +impl FluidLevelChangeEvent { + #[must_use] + pub const fn new(block_pos: BlockPos, world: Arc, new_state_id: BlockStateId) -> Self { + Self { + block_pos, + world, + new_state_id, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/block/inventory_block_start.rs b/crates/pumpkin/src/plugin/api/events/block/inventory_block_start.rs new file mode 100644 index 000000000..47d5d3497 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/block/inventory_block_start.rs @@ -0,0 +1,19 @@ +use pumpkin_macros::Event; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use crate::world::World; + +/// An event that occurs when an inventory block starts an operation. +#[derive(Event, Clone)] +pub struct InventoryBlockStartEvent { + pub block_pos: BlockPos, + pub world: Arc, +} + +impl InventoryBlockStartEvent { + #[must_use] + pub const fn new(block_pos: BlockPos, world: Arc) -> Self { + Self { block_pos, world } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/block/leaves_decay.rs b/crates/pumpkin/src/plugin/api/events/block/leaves_decay.rs new file mode 100644 index 000000000..05ee6dc5d --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/block/leaves_decay.rs @@ -0,0 +1,24 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use crate::world::World; + +/// An event that occurs when leaves decay naturally. +#[cancellable] +#[derive(Event, Clone)] +pub struct LeavesDecayEvent { + pub block_pos: BlockPos, + pub world: Arc, +} + +impl LeavesDecayEvent { + #[must_use] + pub const fn new(block_pos: BlockPos, world: Arc) -> Self { + Self { + block_pos, + world, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/block/mod.rs b/crates/pumpkin/src/plugin/api/events/block/mod.rs index 5dfd366a0..bb3b1b559 100644 --- a/crates/pumpkin/src/plugin/api/events/block/mod.rs +++ b/crates/pumpkin/src/plugin/api/events/block/mod.rs @@ -1,42 +1,92 @@ +pub mod bell_resonate; +pub mod bell_ring; pub mod block_break; +pub mod block_brush; pub mod block_burn; pub mod block_can_build; +pub mod block_cook; pub mod block_damage; +pub mod block_damage_abort; pub mod block_dispense; +pub mod block_dispense_armor; +pub mod block_dispense_loot; +pub mod block_drop_item; +pub mod block_exp; pub mod block_explode; pub mod block_fade; +pub mod block_fertilize; pub mod block_form; pub mod block_from_to; pub mod block_grow; pub mod block_ignite; +pub mod block_multi_place; pub mod block_physics; pub mod block_piston; pub mod block_place; +pub mod block_receive_game; pub mod block_redstone; +pub mod block_shear_entity; +pub mod block_spread; +pub mod brewing_start; +pub mod campfire_start; +pub mod cauldron_level_change; +pub mod crafter_craft; +pub mod entity_block_form; +pub mod fluid_level_change; +pub mod inventory_block_start; +pub mod leaves_decay; +pub mod moisture_change; pub mod note_play; +pub mod sculk_bloom; pub mod sign_change; pub mod sponge_absorb; pub mod tnt_prime; +pub mod vault_display_item; +pub use bell_resonate::*; +pub use bell_ring::*; pub use block_break::*; +pub use block_brush::*; pub use block_burn::*; pub use block_can_build::*; +pub use block_cook::*; pub use block_damage::*; +pub use block_damage_abort::*; pub use block_dispense::*; +pub use block_dispense_armor::*; +pub use block_dispense_loot::*; +pub use block_drop_item::*; +pub use block_exp::*; pub use block_explode::*; pub use block_fade::*; +pub use block_fertilize::*; pub use block_form::*; pub use block_from_to::*; pub use block_grow::*; pub use block_ignite::*; +pub use block_multi_place::*; pub use block_physics::*; pub use block_piston::*; pub use block_place::*; +pub use block_receive_game::*; pub use block_redstone::*; +pub use block_shear_entity::*; +pub use block_spread::*; +pub use brewing_start::*; +pub use campfire_start::*; +pub use cauldron_level_change::*; +pub use crafter_craft::*; +pub use entity_block_form::*; +pub use fluid_level_change::*; +pub use inventory_block_start::*; +pub use leaves_decay::*; +pub use moisture_change::*; pub use note_play::*; +pub use sculk_bloom::*; pub use sign_change::*; pub use sponge_absorb::*; pub use tnt_prime::*; +pub use vault_display_item::*; use pumpkin_data::Block; diff --git a/crates/pumpkin/src/plugin/api/events/block/moisture_change.rs b/crates/pumpkin/src/plugin/api/events/block/moisture_change.rs new file mode 100644 index 000000000..fc77f68b3 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/block/moisture_change.rs @@ -0,0 +1,26 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use crate::world::World; + +/// An event that occurs when farmland moisture level changes. +#[cancellable] +#[derive(Event, Clone)] +pub struct MoistureChangeEvent { + pub block_pos: BlockPos, + pub world: Arc, + pub new_moisture: i32, +} + +impl MoistureChangeEvent { + #[must_use] + pub const fn new(block_pos: BlockPos, world: Arc, new_moisture: i32) -> Self { + Self { + block_pos, + world, + new_moisture, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/block/sculk_bloom.rs b/crates/pumpkin/src/plugin/api/events/block/sculk_bloom.rs new file mode 100644 index 000000000..c31c48461 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/block/sculk_bloom.rs @@ -0,0 +1,26 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use crate::world::World; + +/// An event that occurs when a sculk catalyst blooms. +#[cancellable] +#[derive(Event, Clone)] +pub struct SculkBloomEvent { + pub block_pos: BlockPos, + pub world: Arc, + pub charge: i32, +} + +impl SculkBloomEvent { + #[must_use] + pub const fn new(block_pos: BlockPos, world: Arc, charge: i32) -> Self { + Self { + block_pos, + world, + charge, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/block/vault_display_item.rs b/crates/pumpkin/src/plugin/api/events/block/vault_display_item.rs new file mode 100644 index 000000000..92db891cc --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/block/vault_display_item.rs @@ -0,0 +1,27 @@ +use pumpkin_data::item_stack::ItemStack; +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use crate::world::World; + +/// An event that occurs when a vault displays an item. +#[cancellable] +#[derive(Event, Clone)] +pub struct VaultDisplayItemEvent { + pub block_pos: BlockPos, + pub world: Arc, + pub item: ItemStack, +} + +impl VaultDisplayItemEvent { + #[must_use] + pub const fn new(block_pos: BlockPos, world: Arc, item: ItemStack) -> Self { + Self { + block_pos, + world, + item, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/area_effect_cloud_apply.rs b/crates/pumpkin/src/plugin/api/events/entity/area_effect_cloud_apply.rs new file mode 100644 index 000000000..c26ef1f98 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/area_effect_cloud_apply.rs @@ -0,0 +1,22 @@ +use pumpkin_macros::{Event, cancellable}; + +/// An event that occurs when an area effect cloud applies its effect to entities. +#[cancellable] +#[derive(Event, Clone)] +pub struct AreaEffectCloudApplyEvent { + /// Entity ID of the area effect cloud. + pub entity_id: i32, + /// List of affected entity IDs. + pub affected_entities: Vec, +} + +impl AreaEffectCloudApplyEvent { + #[must_use] + pub const fn new(entity_id: i32, affected_entities: Vec) -> Self { + Self { + entity_id, + affected_entities, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/arrow_body_count_change.rs b/crates/pumpkin/src/plugin/api/events/entity/arrow_body_count_change.rs new file mode 100644 index 000000000..4061bd96e --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/arrow_body_count_change.rs @@ -0,0 +1,25 @@ +use pumpkin_macros::{Event, cancellable}; + +/// An event that occurs when the number of arrows stuck in an entity changes. +#[cancellable] +#[derive(Event, Clone)] +pub struct ArrowBodyCountChangeEvent { + /// Entity ID. + pub entity_id: i32, + /// Old arrow count. + pub old_amount: u32, + /// New arrow count. + pub new_amount: u32, +} + +impl ArrowBodyCountChangeEvent { + #[must_use] + pub const fn new(entity_id: i32, old_amount: u32, new_amount: u32) -> Self { + Self { + entity_id, + old_amount, + new_amount, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/bat_toggle_sleep.rs b/crates/pumpkin/src/plugin/api/events/entity/bat_toggle_sleep.rs new file mode 100644 index 000000000..434bf59e8 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/bat_toggle_sleep.rs @@ -0,0 +1,22 @@ +use pumpkin_macros::{Event, cancellable}; + +/// An event that occurs when a bat toggles its sleep state. +#[cancellable] +#[derive(Event, Clone)] +pub struct BatToggleSleepEvent { + /// Bat entity ID. + pub entity_id: i32, + /// Whether the bat is now awake. + pub is_awake: bool, +} + +impl BatToggleSleepEvent { + #[must_use] + pub const fn new(entity_id: i32, is_awake: bool) -> Self { + Self { + entity_id, + is_awake, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/creature_spawn.rs b/crates/pumpkin/src/plugin/api/events/entity/creature_spawn.rs new file mode 100644 index 000000000..d76f98b6d --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/creature_spawn.rs @@ -0,0 +1,24 @@ +use crate::world::World; +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::vector3::Vector3; +use std::sync::Arc; + +/// An event that occurs when a creature spawns. +#[cancellable] +#[derive(Event, Clone)] +pub struct CreatureSpawnEvent { + /// The ID of the spawned creature. + pub entity_id: i32, + + /// The registry name of the entity type. + pub entity_type: String, + + /// The position where the creature spawned. + pub position: Vector3, + + /// The world in which the creature spawned. + pub world: Arc, + + /// The reason why the creature spawned. + pub spawn_reason: String, +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/creeper_power.rs b/crates/pumpkin/src/plugin/api/events/entity/creeper_power.rs new file mode 100644 index 000000000..d36101fde --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/creeper_power.rs @@ -0,0 +1,25 @@ +use pumpkin_macros::{Event, cancellable}; + +/// An event that occurs when a creeper is powered. +#[cancellable] +#[derive(Event, Clone)] +pub struct CreeperPowerEvent { + /// Creeper entity ID. + pub entity_id: i32, + /// Lightning bolt entity ID if caused by lightning. + pub lightning_id: Option, + /// Power cause. + pub cause: String, +} + +impl CreeperPowerEvent { + #[must_use] + pub const fn new(entity_id: i32, lightning_id: Option, cause: String) -> Self { + Self { + entity_id, + lightning_id, + cause, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/ender_dragon_change_phase.rs b/crates/pumpkin/src/plugin/api/events/entity/ender_dragon_change_phase.rs new file mode 100644 index 000000000..d911f0881 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/ender_dragon_change_phase.rs @@ -0,0 +1,15 @@ +use pumpkin_macros::{Event, cancellable}; + +/// An event that occurs when an Ender Dragon changes its phase. +#[cancellable] +#[derive(Event, Clone)] +pub struct EnderDragonChangePhaseEvent { + /// The ID of the Ender Dragon. + pub entity_id: i32, + + /// The current dragon phase. + pub current_phase: String, + + /// The new dragon phase. + pub new_phase: String, +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/entity_combust_by_block.rs b/crates/pumpkin/src/plugin/api/events/entity/entity_combust_by_block.rs new file mode 100644 index 000000000..5338b474f --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/entity_combust_by_block.rs @@ -0,0 +1,26 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; + +/// An event that occurs when an entity is set on fire by a block. +#[cancellable] +#[derive(Event, Clone)] +pub struct EntityCombustByBlockEvent { + /// Entity ID. + pub entity_id: i32, + /// Combuster block pos. + pub combuster: BlockPos, + /// Combust duration in seconds. + pub duration: f32, +} + +impl EntityCombustByBlockEvent { + #[must_use] + pub const fn new(entity_id: i32, combuster: BlockPos, duration: f32) -> Self { + Self { + entity_id, + combuster, + duration, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/entity_combust_by_entity.rs b/crates/pumpkin/src/plugin/api/events/entity/entity_combust_by_entity.rs new file mode 100644 index 000000000..e4bcffaac --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/entity_combust_by_entity.rs @@ -0,0 +1,25 @@ +use pumpkin_macros::{Event, cancellable}; + +/// An event that occurs when an entity is set on fire by another entity. +#[cancellable] +#[derive(Event, Clone)] +pub struct EntityCombustByEntityEvent { + /// Entity ID being combusted. + pub entity_id: i32, + /// Combuster entity ID. + pub combuster_id: i32, + /// Combust duration in seconds. + pub duration: f32, +} + +impl EntityCombustByEntityEvent { + #[must_use] + pub const fn new(entity_id: i32, combuster_id: i32, duration: f32) -> Self { + Self { + entity_id, + combuster_id, + duration, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/entity_damage_by_block.rs b/crates/pumpkin/src/plugin/api/events/entity/entity_damage_by_block.rs new file mode 100644 index 000000000..5083b3fb2 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/entity_damage_by_block.rs @@ -0,0 +1,19 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; + +/// An event that occurs when an entity takes damage from a block. +#[cancellable] +#[derive(Event, Clone)] +pub struct EntityDamageByBlockEvent { + /// The ID of the entity taking damage. + pub entity_id: i32, + + /// The position of the damaging block, if known. + pub damager_pos: Option, + + /// The amount of damage dealt. + pub damage: f32, + + /// The damage cause. + pub cause: String, +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/entity_damage_by_entity.rs b/crates/pumpkin/src/plugin/api/events/entity/entity_damage_by_entity.rs new file mode 100644 index 000000000..3b9987a49 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/entity_damage_by_entity.rs @@ -0,0 +1,18 @@ +use pumpkin_macros::{Event, cancellable}; + +/// An event that occurs when an entity takes damage from another entity. +#[cancellable] +#[derive(Event, Clone)] +pub struct EntityDamageByEntityEvent { + /// The ID of the entity taking damage. + pub entity_id: i32, + + /// The ID of the damaging entity. + pub damager_id: i32, + + /// The amount of damage dealt. + pub damage: f32, + + /// The damage cause. + pub cause: String, +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/entity_knockback.rs b/crates/pumpkin/src/plugin/api/events/entity/entity_knockback.rs new file mode 100644 index 000000000..9f2258d8c --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/entity_knockback.rs @@ -0,0 +1,16 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::vector3::Vector3; + +/// An event that occurs when an entity receives knockback. +#[cancellable] +#[derive(Event, Clone)] +pub struct EntityKnockbackEvent { + /// The ID of the entity receiving knockback. + pub entity_id: i32, + + /// The ID of the entity that caused the knockback, if any. + pub hit_by_id: Option, + + /// The knockback vector. + pub knockback: Vector3, +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/entity_knockback_by_entity.rs b/crates/pumpkin/src/plugin/api/events/entity/entity_knockback_by_entity.rs new file mode 100644 index 000000000..d42c2f555 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/entity_knockback_by_entity.rs @@ -0,0 +1,31 @@ +use pumpkin_macros::{Event, cancellable}; + +/// An event that occurs when an entity is knocked back by another entity. +#[cancellable] +#[derive(Event, Clone)] +pub struct EntityKnockbackByEntityEvent { + /// Entity ID receiving knockback. + pub entity_id: i32, + /// Entity ID causing knockback. + pub hit_by_id: i32, + /// Knockback force. + pub force: f64, + /// X velocity change. + pub x: f64, + /// Z velocity change. + pub z: f64, +} + +impl EntityKnockbackByEntityEvent { + #[must_use] + pub const fn new(entity_id: i32, hit_by_id: i32, force: f64, x: f64, z: f64) -> Self { + Self { + entity_id, + hit_by_id, + force, + x, + z, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/entity_portal_enter.rs b/crates/pumpkin/src/plugin/api/events/entity/entity_portal_enter.rs new file mode 100644 index 000000000..1641af36d --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/entity_portal_enter.rs @@ -0,0 +1,23 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; + +/// An event that occurs when an entity enters a portal. +#[cancellable] +#[derive(Event, Clone)] +pub struct EntityPortalEnterEvent { + /// Entity ID. + pub entity_id: i32, + /// Location of the portal block entered. + pub location: BlockPos, +} + +impl EntityPortalEnterEvent { + #[must_use] + pub const fn new(entity_id: i32, location: BlockPos) -> Self { + Self { + entity_id, + location, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/entity_portal_exit.rs b/crates/pumpkin/src/plugin/api/events/entity/entity_portal_exit.rs new file mode 100644 index 000000000..cb5d1c49a --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/entity_portal_exit.rs @@ -0,0 +1,26 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; + +/// An event that occurs when an entity exits a portal. +#[cancellable] +#[derive(Event, Clone)] +pub struct EntityPortalExitEvent { + /// Entity ID. + pub entity_id: i32, + /// Portal from position. + pub from_pos: BlockPos, + /// Destination position. + pub to_pos: Option, +} + +impl EntityPortalExitEvent { + #[must_use] + pub const fn new(entity_id: i32, from_pos: BlockPos, to_pos: Option) -> Self { + Self { + entity_id, + from_pos, + to_pos, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/entity_remove.rs b/crates/pumpkin/src/plugin/api/events/entity/entity_remove.rs new file mode 100644 index 000000000..47238621d --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/entity_remove.rs @@ -0,0 +1,22 @@ +use pumpkin_macros::{Event, cancellable}; + +/// An event that occurs when an entity is removed from the world. +#[cancellable] +#[derive(Event, Clone)] +pub struct EntityRemoveEvent { + /// Entity ID. + pub entity_id: i32, + /// Removal cause. + pub cause: String, +} + +impl EntityRemoveEvent { + #[must_use] + pub const fn new(entity_id: i32, cause: String) -> Self { + Self { + entity_id, + cause, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/entity_spell_cast.rs b/crates/pumpkin/src/plugin/api/events/entity/entity_spell_cast.rs new file mode 100644 index 000000000..f4264b8c9 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/entity_spell_cast.rs @@ -0,0 +1,12 @@ +use pumpkin_macros::{Event, cancellable}; + +/// An event that occurs when a spellcasting entity casts a spell. +#[cancellable] +#[derive(Event, Clone)] +pub struct EntitySpellCastEvent { + /// The ID of the spellcaster entity. + pub entity_id: i32, + + /// The spell name being cast. + pub spell: String, +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/entity_target_block.rs b/crates/pumpkin/src/plugin/api/events/entity/entity_target_block.rs new file mode 100644 index 000000000..501b1ecfd --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/entity_target_block.rs @@ -0,0 +1,23 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; + +/// An event that occurs when an entity targets a block. +#[cancellable] +#[derive(Event, Clone)] +pub struct EntityTargetBlockEvent { + /// Entity ID. + pub entity_id: i32, + /// Targeted block position. + pub block_pos: BlockPos, +} + +impl EntityTargetBlockEvent { + #[must_use] + pub const fn new(entity_id: i32, block_pos: BlockPos) -> Self { + Self { + entity_id, + block_pos, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/entity_target_living_entity.rs b/crates/pumpkin/src/plugin/api/events/entity/entity_target_living_entity.rs new file mode 100644 index 000000000..59769f3fa --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/entity_target_living_entity.rs @@ -0,0 +1,15 @@ +use pumpkin_macros::{Event, cancellable}; + +/// An event that occurs when an entity targets a living entity. +#[cancellable] +#[derive(Event, Clone)] +pub struct EntityTargetLivingEntityEvent { + /// The ID of the targeting entity. + pub entity_id: i32, + + /// The ID of the target living entity, if any. + pub target_id: Option, + + /// The targeting reason. + pub reason: String, +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/entity_unleash.rs b/crates/pumpkin/src/plugin/api/events/entity/entity_unleash.rs new file mode 100644 index 000000000..d2681ba11 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/entity_unleash.rs @@ -0,0 +1,22 @@ +use pumpkin_macros::{Event, cancellable}; + +/// An event that occurs when an entity is unleashed. +#[cancellable] +#[derive(Event, Clone)] +pub struct EntityUnleashEvent { + /// Entity ID being unleashed. + pub entity_id: i32, + /// Unleash reason. + pub reason: String, +} + +impl EntityUnleashEvent { + #[must_use] + pub const fn new(entity_id: i32, reason: String) -> Self { + Self { + entity_id, + reason, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/exp_bottle.rs b/crates/pumpkin/src/plugin/api/events/entity/exp_bottle.rs new file mode 100644 index 000000000..287d1ea50 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/exp_bottle.rs @@ -0,0 +1,34 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; + +/// An event that occurs when an experience bottle breaks. +#[cancellable] +#[derive(Event, Clone)] +pub struct ExpBottleEvent { + /// Bottle entity ID. + pub entity_id: i32, + /// Experience amount. + pub experience: i32, + /// Location of the bottle break. + pub location: BlockPos, + /// Whether to show the particle effect. + pub show_effect: bool, +} + +impl ExpBottleEvent { + #[must_use] + pub const fn new( + entity_id: i32, + experience: i32, + location: BlockPos, + show_effect: bool, + ) -> Self { + Self { + entity_id, + experience, + location, + show_effect, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/firework_explode.rs b/crates/pumpkin/src/plugin/api/events/entity/firework_explode.rs new file mode 100644 index 000000000..52ade3620 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/firework_explode.rs @@ -0,0 +1,9 @@ +use pumpkin_macros::{Event, cancellable}; + +/// An event that occurs when a firework rocket explodes. +#[cancellable] +#[derive(Event, Clone)] +pub struct FireworkExplodeEvent { + /// The ID of the firework entity. + pub entity_id: i32, +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/horse_jump.rs b/crates/pumpkin/src/plugin/api/events/entity/horse_jump.rs new file mode 100644 index 000000000..e6ae8d136 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/horse_jump.rs @@ -0,0 +1,22 @@ +use pumpkin_macros::{Event, cancellable}; + +/// An event that occurs when a horse jumps. +#[cancellable] +#[derive(Event, Clone)] +pub struct HorseJumpEvent { + /// Horse entity ID. + pub entity_id: i32, + /// Jump power. + pub power: f32, +} + +impl HorseJumpEvent { + #[must_use] + pub const fn new(entity_id: i32, power: f32) -> Self { + Self { + entity_id, + power, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/item_merge.rs b/crates/pumpkin/src/plugin/api/events/entity/item_merge.rs new file mode 100644 index 000000000..6e0c6bf33 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/item_merge.rs @@ -0,0 +1,12 @@ +use pumpkin_macros::{Event, cancellable}; + +/// An event that occurs when two item entities merge. +#[cancellable] +#[derive(Event, Clone)] +pub struct ItemMergeEvent { + /// The ID of the primary item entity. + pub entity_id: i32, + + /// The ID of the target item entity being merged into the primary. + pub target_id: i32, +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/lingering_potion_splash.rs b/crates/pumpkin/src/plugin/api/events/entity/lingering_potion_splash.rs new file mode 100644 index 000000000..bcec8bb64 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/lingering_potion_splash.rs @@ -0,0 +1,26 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; + +/// An event that occurs when a lingering potion splashes. +#[cancellable] +#[derive(Event, Clone)] +pub struct LingeringPotionSplashEvent { + /// Potion entity ID. + pub entity_id: i32, + /// Location of the splash. + pub location: BlockPos, + /// Potion item name. + pub potion_item: String, +} + +impl LingeringPotionSplashEvent { + #[must_use] + pub const fn new(entity_id: i32, location: BlockPos, potion_item: String) -> Self { + Self { + entity_id, + location, + potion_item, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/mod.rs b/crates/pumpkin/src/plugin/api/events/entity/mod.rs index 60906add3..21f492054 100644 --- a/crates/pumpkin/src/plugin/api/events/entity/mod.rs +++ b/crates/pumpkin/src/plugin/api/events/entity/mod.rs @@ -1,9 +1,19 @@ +pub mod area_effect_cloud_apply; +pub mod arrow_body_count_change; +pub mod bat_toggle_sleep; +pub mod creature_spawn; +pub mod creeper_power; +pub mod ender_dragon_change_phase; pub mod entity_air_change; pub mod entity_break_door; pub mod entity_breed; pub mod entity_change_block; pub mod entity_combust; +pub mod entity_combust_by_block; +pub mod entity_combust_by_entity; pub mod entity_damage; +pub mod entity_damage_by_block; +pub mod entity_damage_by_entity; pub mod entity_death; pub mod entity_dismount; pub mod entity_drop_item; @@ -13,35 +23,74 @@ pub mod entity_enter_love_mode; pub mod entity_exhaustion; pub mod entity_explode; pub mod entity_interact; +pub mod entity_knockback; +pub mod entity_knockback_by_entity; pub mod entity_mount; pub mod entity_pickup_item; pub mod entity_place; pub mod entity_portal; +pub mod entity_portal_enter; +pub mod entity_portal_exit; pub mod entity_pose_change; pub mod entity_potion_effect; pub mod entity_regain_health; +pub mod entity_remove; pub mod entity_resurrect; pub mod entity_shoot_bow; pub mod entity_spawn; +pub mod entity_spell_cast; pub mod entity_tame; pub mod entity_target; +pub mod entity_target_block; +pub mod entity_target_living_entity; pub mod entity_teleport; pub mod entity_toggle_glide; pub mod entity_toggle_swim; pub mod entity_transform; +pub mod entity_unleash; +pub mod exp_bottle; pub mod explosion_prime; +pub mod firework_explode; pub mod food_level_change; +pub mod horse_jump; pub mod item_despawn; +pub mod item_merge; pub mod item_spawn; +pub mod lingering_potion_splash; +pub mod pig_zap; +pub mod pig_zombie_anger; +pub mod piglin_barter; +pub mod potion_splash; pub mod projectile_hit; pub mod projectile_launch; +pub mod sheep_dye_wool; +pub mod sheep_regrow_wool; +pub mod slime_split; +pub mod spawner_spawn; +pub mod strider_temperature_change; +pub mod trial_spawner_spawn; +pub mod villager_acquire_trade; +pub mod villager_career_change; +pub mod villager_replenish_trade; +pub mod villager_reputation_change; +pub mod warden_anger_change; +pub use area_effect_cloud_apply::*; +pub use arrow_body_count_change::*; +pub use bat_toggle_sleep::*; +pub use creature_spawn::*; +pub use creeper_power::*; +pub use ender_dragon_change_phase::*; pub use entity_air_change::*; pub use entity_break_door::*; pub use entity_breed::*; pub use entity_change_block::*; pub use entity_combust::*; +pub use entity_combust_by_block::*; +pub use entity_combust_by_entity::*; pub use entity_damage::*; +pub use entity_damage_by_block::*; +pub use entity_damage_by_entity::*; pub use entity_death::*; pub use entity_dismount::*; pub use entity_drop_item::*; @@ -51,25 +100,54 @@ pub use entity_enter_love_mode::*; pub use entity_exhaustion::*; pub use entity_explode::*; pub use entity_interact::*; +pub use entity_knockback::*; +pub use entity_knockback_by_entity::*; pub use entity_mount::*; pub use entity_pickup_item::*; pub use entity_place::*; pub use entity_portal::*; +pub use entity_portal_enter::*; +pub use entity_portal_exit::*; pub use entity_pose_change::*; pub use entity_potion_effect::*; pub use entity_regain_health::*; +pub use entity_remove::*; pub use entity_resurrect::*; pub use entity_shoot_bow::*; pub use entity_spawn::*; +pub use entity_spell_cast::*; pub use entity_tame::*; pub use entity_target::*; +pub use entity_target_block::*; +pub use entity_target_living_entity::*; pub use entity_teleport::*; pub use entity_toggle_glide::*; pub use entity_toggle_swim::*; pub use entity_transform::*; +pub use entity_unleash::*; +pub use exp_bottle::*; pub use explosion_prime::*; +pub use firework_explode::*; pub use food_level_change::*; +pub use horse_jump::*; pub use item_despawn::*; +pub use item_merge::*; pub use item_spawn::*; +pub use lingering_potion_splash::*; +pub use pig_zap::*; +pub use pig_zombie_anger::*; +pub use piglin_barter::*; +pub use potion_splash::*; pub use projectile_hit::*; pub use projectile_launch::*; +pub use sheep_dye_wool::*; +pub use sheep_regrow_wool::*; +pub use slime_split::*; +pub use spawner_spawn::*; +pub use strider_temperature_change::*; +pub use trial_spawner_spawn::*; +pub use villager_acquire_trade::*; +pub use villager_career_change::*; +pub use villager_replenish_trade::*; +pub use villager_reputation_change::*; +pub use warden_anger_change::*; diff --git a/crates/pumpkin/src/plugin/api/events/entity/pig_zap.rs b/crates/pumpkin/src/plugin/api/events/entity/pig_zap.rs new file mode 100644 index 000000000..f54834a50 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/pig_zap.rs @@ -0,0 +1,25 @@ +use pumpkin_macros::{Event, cancellable}; + +/// An event that occurs when a pig is struck by lightning and transforms. +#[cancellable] +#[derive(Event, Clone)] +pub struct PigZapEvent { + /// Pig entity ID. + pub entity_id: i32, + /// Lightning bolt entity ID. + pub lightning_id: i32, + /// Resulting pig zombie entity ID. + pub pig_zombie_id: i32, +} + +impl PigZapEvent { + #[must_use] + pub const fn new(entity_id: i32, lightning_id: i32, pig_zombie_id: i32) -> Self { + Self { + entity_id, + lightning_id, + pig_zombie_id, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/pig_zombie_anger.rs b/crates/pumpkin/src/plugin/api/events/entity/pig_zombie_anger.rs new file mode 100644 index 000000000..bd4d3b5ba --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/pig_zombie_anger.rs @@ -0,0 +1,25 @@ +use pumpkin_macros::{Event, cancellable}; + +/// An event that occurs when a pig zombie becomes angry. +#[cancellable] +#[derive(Event, Clone)] +pub struct PigZombieAngerEvent { + /// Pig zombie entity ID. + pub entity_id: i32, + /// Target entity ID that caused anger. + pub target_id: Option, + /// New anger level. + pub new_anger: i32, +} + +impl PigZombieAngerEvent { + #[must_use] + pub const fn new(entity_id: i32, target_id: Option, new_anger: i32) -> Self { + Self { + entity_id, + target_id, + new_anger, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/piglin_barter.rs b/crates/pumpkin/src/plugin/api/events/entity/piglin_barter.rs new file mode 100644 index 000000000..86ba341b5 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/piglin_barter.rs @@ -0,0 +1,16 @@ +use pumpkin_data::item_stack::ItemStack; +use pumpkin_macros::{Event, cancellable}; + +/// An event that occurs when a piglin barters. +#[cancellable] +#[derive(Event, Clone)] +pub struct PiglinBarterEvent { + /// The ID of the piglin entity. + pub entity_id: i32, + + /// The item given to the piglin. + pub input_item: ItemStack, + + /// The outcome item stacks produced by the barter. + pub outcome: Vec, +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/potion_splash.rs b/crates/pumpkin/src/plugin/api/events/entity/potion_splash.rs new file mode 100644 index 000000000..6ca5e09f9 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/potion_splash.rs @@ -0,0 +1,34 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; + +/// An event that occurs when a splash potion impacts and applies effects. +#[cancellable] +#[derive(Event, Clone)] +pub struct PotionSplashEvent { + /// Potion entity ID. + pub entity_id: i32, + /// Splash location. + pub location: BlockPos, + /// Potion item name. + pub potion_item: String, + /// Affected entity IDs. + pub affected_entities: Vec, +} + +impl PotionSplashEvent { + #[must_use] + pub const fn new( + entity_id: i32, + location: BlockPos, + potion_item: String, + affected_entities: Vec, + ) -> Self { + Self { + entity_id, + location, + potion_item, + affected_entities, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/sheep_dye_wool.rs b/crates/pumpkin/src/plugin/api/events/entity/sheep_dye_wool.rs new file mode 100644 index 000000000..470c67296 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/sheep_dye_wool.rs @@ -0,0 +1,15 @@ +use pumpkin_macros::{Event, cancellable}; + +/// An event that occurs when a sheep has its wool dyed. +#[cancellable] +#[derive(Event, Clone)] +pub struct SheepDyeWoolEvent { + /// The ID of the sheep. + pub entity_id: i32, + + /// The new dye color index. + pub dye_color: u8, + + /// The player ID who dyed the sheep, if any. + pub player_id: Option, +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/sheep_regrow_wool.rs b/crates/pumpkin/src/plugin/api/events/entity/sheep_regrow_wool.rs new file mode 100644 index 000000000..a96c896de --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/sheep_regrow_wool.rs @@ -0,0 +1,9 @@ +use pumpkin_macros::{Event, cancellable}; + +/// An event that occurs when a sheep regrows its wool. +#[cancellable] +#[derive(Event, Clone)] +pub struct SheepRegrowWoolEvent { + /// The ID of the sheep entity. + pub entity_id: i32, +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/slime_split.rs b/crates/pumpkin/src/plugin/api/events/entity/slime_split.rs new file mode 100644 index 000000000..f1da0159f --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/slime_split.rs @@ -0,0 +1,12 @@ +use pumpkin_macros::{Event, cancellable}; + +/// An event that occurs when a slime splits into smaller slimes. +#[cancellable] +#[derive(Event, Clone)] +pub struct SlimeSplitEvent { + /// The ID of the parent slime entity. + pub entity_id: i32, + + /// The number of smaller slimes created. + pub count: i32, +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/spawner_spawn.rs b/crates/pumpkin/src/plugin/api/events/entity/spawner_spawn.rs new file mode 100644 index 000000000..33b45bc18 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/spawner_spawn.rs @@ -0,0 +1,23 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; + +/// An event that occurs when a monster spawner spawns an entity. +#[cancellable] +#[derive(Event, Clone)] +pub struct SpawnerSpawnEvent { + /// Spawned entity ID. + pub entity_id: i32, + /// Spawner block position. + pub spawner_pos: BlockPos, +} + +impl SpawnerSpawnEvent { + #[must_use] + pub const fn new(entity_id: i32, spawner_pos: BlockPos) -> Self { + Self { + entity_id, + spawner_pos, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/strider_temperature_change.rs b/crates/pumpkin/src/plugin/api/events/entity/strider_temperature_change.rs new file mode 100644 index 000000000..bc09db912 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/strider_temperature_change.rs @@ -0,0 +1,12 @@ +use pumpkin_macros::{Event, cancellable}; + +/// An event that occurs when a strider's shivering status changes. +#[cancellable] +#[derive(Event, Clone)] +pub struct StriderTemperatureChangeEvent { + /// The ID of the strider entity. + pub entity_id: i32, + + /// Whether the strider is now shivering. + pub is_shivering: bool, +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/trial_spawner_spawn.rs b/crates/pumpkin/src/plugin/api/events/entity/trial_spawner_spawn.rs new file mode 100644 index 000000000..4a912bbe5 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/trial_spawner_spawn.rs @@ -0,0 +1,23 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; + +/// An event that occurs when a trial spawner spawns an entity. +#[cancellable] +#[derive(Event, Clone)] +pub struct TrialSpawnerSpawnEvent { + /// Spawned entity ID. + pub entity_id: i32, + /// Trial spawner block position. + pub spawner_pos: BlockPos, +} + +impl TrialSpawnerSpawnEvent { + #[must_use] + pub const fn new(entity_id: i32, spawner_pos: BlockPos) -> Self { + Self { + entity_id, + spawner_pos, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/villager_acquire_trade.rs b/crates/pumpkin/src/plugin/api/events/entity/villager_acquire_trade.rs new file mode 100644 index 000000000..a0f33bde0 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/villager_acquire_trade.rs @@ -0,0 +1,12 @@ +use pumpkin_macros::{Event, cancellable}; + +/// An event that occurs when a villager acquires a new trade. +#[cancellable] +#[derive(Event, Clone)] +pub struct VillagerAcquireTradeEvent { + /// The ID of the villager entity. + pub entity_id: i32, + + /// The trade recipe index. + pub recipe_index: i32, +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/villager_career_change.rs b/crates/pumpkin/src/plugin/api/events/entity/villager_career_change.rs new file mode 100644 index 000000000..397029f33 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/villager_career_change.rs @@ -0,0 +1,15 @@ +use pumpkin_macros::{Event, cancellable}; + +/// An event that occurs when a villager changes its profession. +#[cancellable] +#[derive(Event, Clone)] +pub struct VillagerCareerChangeEvent { + /// The ID of the villager entity. + pub entity_id: i32, + + /// The new profession name. + pub profession: String, + + /// The reason for the change. + pub reason: String, +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/villager_replenish_trade.rs b/crates/pumpkin/src/plugin/api/events/entity/villager_replenish_trade.rs new file mode 100644 index 000000000..e955b68ec --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/villager_replenish_trade.rs @@ -0,0 +1,12 @@ +use pumpkin_macros::{Event, cancellable}; + +/// An event that occurs when a villager replenishes its trades. +#[cancellable] +#[derive(Event, Clone)] +pub struct VillagerReplenishTradeEvent { + /// The ID of the villager entity. + pub entity_id: i32, + + /// The number of times the trade was restocked. + pub restock_quantity: i32, +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/villager_reputation_change.rs b/crates/pumpkin/src/plugin/api/events/entity/villager_reputation_change.rs new file mode 100644 index 000000000..d32b3c53d --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/villager_reputation_change.rs @@ -0,0 +1,25 @@ +use pumpkin_macros::{Event, cancellable}; + +/// An event that occurs when a villager's reputation changes for a player. +#[cancellable] +#[derive(Event, Clone)] +pub struct VillagerReputationChangeEvent { + /// Villager entity ID. + pub entity_id: i32, + /// Target player entity ID. + pub target_id: i32, + /// Reputation change amount. + pub reputation_change: i32, +} + +impl VillagerReputationChangeEvent { + #[must_use] + pub const fn new(entity_id: i32, target_id: i32, reputation_change: i32) -> Self { + Self { + entity_id, + target_id, + reputation_change, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/entity/warden_anger_change.rs b/crates/pumpkin/src/plugin/api/events/entity/warden_anger_change.rs new file mode 100644 index 000000000..75470ad7c --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/entity/warden_anger_change.rs @@ -0,0 +1,18 @@ +use pumpkin_macros::{Event, cancellable}; + +/// An event that occurs when a warden's anger towards an entity changes. +#[cancellable] +#[derive(Event, Clone)] +pub struct WardenAngerChangeEvent { + /// The ID of the warden entity. + pub entity_id: i32, + + /// The ID of the target entity. + pub target_id: i32, + + /// The previous anger level. + pub old_anger: i32, + + /// The new anger level. + pub new_anger: i32, +} diff --git a/crates/pumpkin/src/plugin/api/events/hanging/hanging_break.rs b/crates/pumpkin/src/plugin/api/events/hanging/hanging_break.rs new file mode 100644 index 000000000..8ea1af0fb --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/hanging/hanging_break.rs @@ -0,0 +1,25 @@ +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +use crate::entity::EntityBase; + +/// An event that occurs when a hanging entity (e.g. painting, item frame) is broken. +#[cancellable] +#[derive(Event, Clone)] +pub struct HangingBreakEvent { + /// The hanging entity that was broken. + pub entity: Arc, + /// The entity that caused the break, if any. + pub remover: Option>, +} + +impl HangingBreakEvent { + #[must_use] + pub const fn new(entity: Arc, remover: Option>) -> Self { + Self { + entity, + remover, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/hanging/hanging_break_by_entity.rs b/crates/pumpkin/src/plugin/api/events/hanging/hanging_break_by_entity.rs new file mode 100644 index 000000000..bfe332d4d --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/hanging/hanging_break_by_entity.rs @@ -0,0 +1,25 @@ +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +use crate::entity::EntityBase; + +/// An event that occurs when a hanging entity is broken by another entity. +#[cancellable] +#[derive(Event, Clone)] +pub struct HangingBreakByEntityEvent { + /// The hanging entity that was broken. + pub entity: Arc, + /// The entity that broke the hanging entity. + pub remover: Arc, +} + +impl HangingBreakByEntityEvent { + #[must_use] + pub const fn new(entity: Arc, remover: Arc) -> Self { + Self { + entity, + remover, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/hanging/hanging_place.rs b/crates/pumpkin/src/plugin/api/events/hanging/hanging_place.rs new file mode 100644 index 000000000..e010c4642 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/hanging/hanging_place.rs @@ -0,0 +1,38 @@ +use pumpkin_data::BlockDirection; +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use crate::entity::{EntityBase, player::Player}; + +/// An event that occurs when a hanging entity is placed. +#[cancellable] +#[derive(Event, Clone)] +pub struct HangingPlaceEvent { + /// The hanging entity being placed. + pub entity: Arc, + /// The player placing the entity, if placed by a player. + pub player: Option>, + /// The position of the block against which the entity is placed. + pub block_pos: BlockPos, + /// The face of the block where the entity is placed. + pub block_face: BlockDirection, +} + +impl HangingPlaceEvent { + #[must_use] + pub const fn new( + entity: Arc, + player: Option>, + block_pos: BlockPos, + block_face: BlockDirection, + ) -> Self { + Self { + entity, + player, + block_pos, + block_face, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/hanging/mod.rs b/crates/pumpkin/src/plugin/api/events/hanging/mod.rs new file mode 100644 index 000000000..beae1bb43 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/hanging/mod.rs @@ -0,0 +1,7 @@ +pub mod hanging_break; +pub mod hanging_break_by_entity; +pub mod hanging_place; + +pub use hanging_break::*; +pub use hanging_break_by_entity::*; +pub use hanging_place::*; diff --git a/crates/pumpkin/src/plugin/api/events/inventory/brewing_stand_fuel.rs b/crates/pumpkin/src/plugin/api/events/inventory/brewing_stand_fuel.rs new file mode 100644 index 000000000..2f24e7c1b --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/inventory/brewing_stand_fuel.rs @@ -0,0 +1,24 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; + +/// An event that occurs when fuel is refilled or consumed in a brewing stand. +#[cancellable] +#[derive(Event, Clone)] +pub struct BrewingStandFuelEvent { + /// The block position of the brewing stand. + pub block_pos: BlockPos, + + /// The fuel power amount. + pub fuel_power: u16, +} + +impl BrewingStandFuelEvent { + #[must_use] + pub const fn new(block_pos: BlockPos, fuel_power: u16) -> Self { + Self { + block_pos, + fuel_power, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/inventory/furnace_extract.rs b/crates/pumpkin/src/plugin/api/events/inventory/furnace_extract.rs new file mode 100644 index 000000000..a0ef45a63 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/inventory/furnace_extract.rs @@ -0,0 +1,42 @@ +use crate::entity::player::Player; +use pumpkin_macros::Event; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +/// An event that occurs when a player extracts items from a furnace output slot. +#[derive(Event, Clone)] +pub struct FurnaceExtractEvent { + /// The player taking the item. + pub player: Arc, + + /// The position of the furnace block. + pub block_pos: BlockPos, + + /// The registry key of the extracted item. + pub item_id: String, + + /// The amount of item extracted. + pub item_amount: u32, + + /// The experience gained from extracting. + pub exp_gained: f32, +} + +impl FurnaceExtractEvent { + #[must_use] + pub const fn new( + player: Arc, + block_pos: BlockPos, + item_id: String, + item_amount: u32, + exp_gained: f32, + ) -> Self { + Self { + player, + block_pos, + item_id, + item_amount, + exp_gained, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/inventory/furnace_start_smelt.rs b/crates/pumpkin/src/plugin/api/events/inventory/furnace_start_smelt.rs new file mode 100644 index 000000000..7ff2b882a --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/inventory/furnace_start_smelt.rs @@ -0,0 +1,28 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; + +/// An event that occurs when a furnace starts smelting an item. +#[cancellable] +#[derive(Event, Clone)] +pub struct FurnaceStartSmeltEvent { + /// The position of the furnace block. + pub block_pos: BlockPos, + + /// The registry key of the item to smelt. + pub source_item: String, + + /// Total cooking time required in ticks. + pub cooking_time: u32, +} + +impl FurnaceStartSmeltEvent { + #[must_use] + pub const fn new(block_pos: BlockPos, source_item: String, cooking_time: u32) -> Self { + Self { + block_pos, + source_item, + cooking_time, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/inventory/hopper_inventory_search.rs b/crates/pumpkin/src/plugin/api/events/inventory/hopper_inventory_search.rs new file mode 100644 index 000000000..b1e2854ec --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/inventory/hopper_inventory_search.rs @@ -0,0 +1,24 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; + +/// An event that occurs when a hopper searches for a container inventory. +#[cancellable] +#[derive(Event, Clone)] +pub struct HopperInventorySearchEvent { + /// The block position of the hopper. + pub block_pos: BlockPos, + + /// The target search position. + pub search_pos: BlockPos, +} + +impl HopperInventorySearchEvent { + #[must_use] + pub const fn new(block_pos: BlockPos, search_pos: BlockPos) -> Self { + Self { + block_pos, + search_pos, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/inventory/inventory_creative.rs b/crates/pumpkin/src/plugin/api/events/inventory/inventory_creative.rs new file mode 100644 index 000000000..af75cd6de --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/inventory/inventory_creative.rs @@ -0,0 +1,33 @@ +use crate::entity::player::Player; +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +/// An event that occurs when a creative mode player sets an inventory slot. +#[cancellable] +#[derive(Event, Clone)] +pub struct InventoryCreativeEvent { + /// The player taking creative action. + pub player: Arc, + + /// The target slot index. + pub slot: i16, + + /// The item ID set into the slot. + pub item_id: String, + + /// The item count set. + pub item_count: u8, +} + +impl InventoryCreativeEvent { + #[must_use] + pub const fn new(player: Arc, slot: i16, item_id: String, item_count: u8) -> Self { + Self { + player, + slot, + item_id, + item_count, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/inventory/inventory_interact.rs b/crates/pumpkin/src/plugin/api/events/inventory/inventory_interact.rs new file mode 100644 index 000000000..24776ed57 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/inventory/inventory_interact.rs @@ -0,0 +1,21 @@ +use crate::entity::player::Player; +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +/// Base event triggered during inventory interaction. +#[cancellable] +#[derive(Event, Clone)] +pub struct InventoryInteractEvent { + /// The player interacting with the inventory. + pub player: Arc, +} + +impl InventoryInteractEvent { + #[must_use] + pub const fn new(player: Arc) -> Self { + Self { + player, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/inventory/inventory_move_item.rs b/crates/pumpkin/src/plugin/api/events/inventory/inventory_move_item.rs new file mode 100644 index 000000000..d54ba9959 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/inventory/inventory_move_item.rs @@ -0,0 +1,37 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; + +/// An event that occurs when an item is moved between inventories. +#[cancellable] +#[derive(Event, Clone)] +pub struct InventoryMoveItemEvent { + /// The source inventory position. + pub source_pos: BlockPos, + + /// The destination inventory position. + pub target_pos: BlockPos, + + /// The registry key of the item moved. + pub item_id: String, + + /// The quantity of item moved. + pub item_amount: u32, +} + +impl InventoryMoveItemEvent { + #[must_use] + pub const fn new( + source_pos: BlockPos, + target_pos: BlockPos, + item_id: String, + item_amount: u32, + ) -> Self { + Self { + source_pos, + target_pos, + item_id, + item_amount, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/inventory/inventory_pickup_item.rs b/crates/pumpkin/src/plugin/api/events/inventory/inventory_pickup_item.rs new file mode 100644 index 000000000..b9743af58 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/inventory/inventory_pickup_item.rs @@ -0,0 +1,28 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; + +/// An event that occurs when a container (like a hopper) picks up an item entity. +#[cancellable] +#[derive(Event, Clone)] +pub struct InventoryPickupItemEvent { + /// The block position of the container. + pub block_pos: BlockPos, + + /// The entity ID of the picked up item. + pub item_entity_id: i32, + + /// The registry key of the item. + pub item_id: String, +} + +impl InventoryPickupItemEvent { + #[must_use] + pub const fn new(block_pos: BlockPos, item_entity_id: i32, item_id: String) -> Self { + Self { + block_pos, + item_entity_id, + item_id, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/inventory/mod.rs b/crates/pumpkin/src/plugin/api/events/inventory/mod.rs index 75dc92afc..3695fbf4b 100644 --- a/crates/pumpkin/src/plugin/api/events/inventory/mod.rs +++ b/crates/pumpkin/src/plugin/api/events/inventory/mod.rs @@ -1,17 +1,43 @@ pub mod brew; +pub mod brewing_stand_fuel; pub mod craft_item; pub mod furnace_burn; +pub mod furnace_extract; pub mod furnace_smelt; +pub mod furnace_start_smelt; +pub mod hopper_inventory_search; +pub mod inventory_creative; pub mod inventory_drag; +pub mod inventory_interact; +pub mod inventory_move_item; pub mod inventory_open; +pub mod inventory_pickup_item; pub mod prepare_anvil; +pub mod prepare_grindstone; +pub mod prepare_inventory_result; +pub mod prepare_item_craft; +pub mod prepare_smithing; +pub mod smith_item; pub mod trade_select; pub use brew::*; +pub use brewing_stand_fuel::*; pub use craft_item::*; pub use furnace_burn::*; +pub use furnace_extract::*; pub use furnace_smelt::*; +pub use furnace_start_smelt::*; +pub use hopper_inventory_search::*; +pub use inventory_creative::*; pub use inventory_drag::*; +pub use inventory_interact::*; +pub use inventory_move_item::*; pub use inventory_open::*; +pub use inventory_pickup_item::*; pub use prepare_anvil::*; +pub use prepare_grindstone::*; +pub use prepare_inventory_result::*; +pub use prepare_item_craft::*; +pub use prepare_smithing::*; +pub use smith_item::*; pub use trade_select::*; diff --git a/crates/pumpkin/src/plugin/api/events/inventory/prepare_grindstone.rs b/crates/pumpkin/src/plugin/api/events/inventory/prepare_grindstone.rs new file mode 100644 index 000000000..b2e348caf --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/inventory/prepare_grindstone.rs @@ -0,0 +1,23 @@ +use crate::entity::player::Player; +use pumpkin_macros::Event; +use std::sync::Arc; + +/// An event that occurs when items are placed into a grindstone. +#[derive(Event, Clone)] +pub struct PrepareGrindstoneEvent { + /// The player using the grindstone. + pub player: Arc, + + /// The resulting item ID prepared in the output slot. + pub result_item: Option, +} + +impl PrepareGrindstoneEvent { + #[must_use] + pub const fn new(player: Arc, result_item: Option) -> Self { + Self { + player, + result_item, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/inventory/prepare_inventory_result.rs b/crates/pumpkin/src/plugin/api/events/inventory/prepare_inventory_result.rs new file mode 100644 index 000000000..a23dbffcd --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/inventory/prepare_inventory_result.rs @@ -0,0 +1,23 @@ +use crate::entity::player::Player; +use pumpkin_macros::Event; +use std::sync::Arc; + +/// Generalized event that occurs when an inventory result slot item is prepared. +#[derive(Event, Clone)] +pub struct PrepareInventoryResultEvent { + /// The player interacting with the inventory. + pub player: Arc, + + /// The result item ID, if any. + pub result_item: Option, +} + +impl PrepareInventoryResultEvent { + #[must_use] + pub const fn new(player: Arc, result_item: Option) -> Self { + Self { + player, + result_item, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/inventory/prepare_item_craft.rs b/crates/pumpkin/src/plugin/api/events/inventory/prepare_item_craft.rs new file mode 100644 index 000000000..1147c4a22 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/inventory/prepare_item_craft.rs @@ -0,0 +1,25 @@ +use crate::entity::player::Player; +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +/// An event that occurs when a recipe is prepared in a crafting matrix. +#[cancellable] +#[derive(Event, Clone)] +pub struct PrepareItemCraftEvent { + /// The player crafting the item. + pub player: Arc, + + /// The recipe ID prepared. + pub recipe_id: String, +} + +impl PrepareItemCraftEvent { + #[must_use] + pub const fn new(player: Arc, recipe_id: String) -> Self { + Self { + player, + recipe_id, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/inventory/prepare_smithing.rs b/crates/pumpkin/src/plugin/api/events/inventory/prepare_smithing.rs new file mode 100644 index 000000000..1bd86b168 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/inventory/prepare_smithing.rs @@ -0,0 +1,23 @@ +use crate::entity::player::Player; +use pumpkin_macros::Event; +use std::sync::Arc; + +/// An event that occurs when items are placed into a smithing table. +#[derive(Event, Clone)] +pub struct PrepareSmithingEvent { + /// The player using the smithing table. + pub player: Arc, + + /// The resulting item ID prepared in the output slot. + pub result_item: Option, +} + +impl PrepareSmithingEvent { + #[must_use] + pub const fn new(player: Arc, result_item: Option) -> Self { + Self { + player, + result_item, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/inventory/smith_item.rs b/crates/pumpkin/src/plugin/api/events/inventory/smith_item.rs new file mode 100644 index 000000000..838babe81 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/inventory/smith_item.rs @@ -0,0 +1,25 @@ +use crate::entity::player::Player; +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +/// An event that occurs when an item is crafted/upgraded in a smithing table. +#[cancellable] +#[derive(Event, Clone)] +pub struct SmithItemEvent { + /// The player taking the item from the smithing output. + pub player: Arc, + + /// The recipe ID used for smithing. + pub recipe_id: String, +} + +impl SmithItemEvent { + #[must_use] + pub const fn new(player: Arc, recipe_id: String) -> Self { + Self { + player, + recipe_id, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/mod.rs b/crates/pumpkin/src/plugin/api/events/mod.rs index 6eb211c3d..6cc83a8fc 100644 --- a/crates/pumpkin/src/plugin/api/events/mod.rs +++ b/crates/pumpkin/src/plugin/api/events/mod.rs @@ -4,6 +4,7 @@ use std::sync::Arc; pub mod block; pub mod enchantment; pub mod entity; +pub mod hanging; pub mod inventory; pub mod player; pub mod raid; diff --git a/crates/pumpkin/src/plugin/api/events/player/async_player_chat.rs b/crates/pumpkin/src/plugin/api/events/player/async_player_chat.rs new file mode 100644 index 000000000..59fbb4bc7 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/async_player_chat.rs @@ -0,0 +1,26 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::text::TextComponent; +use std::sync::Arc; + +use super::PlayerEvent; +use crate::entity::player::Player; + +/// An asynchronous event that occurs when a player sends a chat message. +#[cancellable] +#[derive(Event, Clone)] +pub struct AsyncPlayerChatEvent { + /// The player sending the message. + pub player: Arc, + + /// The chat message content. + pub message: String, + + /// The formatted chat message. + pub format: TextComponent, +} + +impl PlayerEvent for AsyncPlayerChatEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/async_player_pre_login.rs b/crates/pumpkin/src/plugin/api/events/player/async_player_pre_login.rs new file mode 100644 index 000000000..2e5769239 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/async_player_pre_login.rs @@ -0,0 +1,21 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::text::TextComponent; +use std::net::SocketAddr; +use uuid::Uuid; + +/// An asynchronous event that occurs when a connection attempts to pre-login. +#[cancellable] +#[derive(Event, Clone)] +pub struct AsyncPlayerPreLoginEvent { + /// The player username. + pub player_name: String, + + /// The player unique ID. + pub player_uuid: Uuid, + + /// The remote IP address. + pub ip_address: SocketAddr, + + /// The kick message if the connection is rejected. + pub kick_message: TextComponent, +} diff --git a/crates/pumpkin/src/plugin/api/events/player/mod.rs b/crates/pumpkin/src/plugin/api/events/player/mod.rs index 9e26b371c..face5fcd7 100644 --- a/crates/pumpkin/src/plugin/api/events/player/mod.rs +++ b/crates/pumpkin/src/plugin/api/events/player/mod.rs @@ -1,3 +1,5 @@ +pub mod async_player_chat; +pub mod async_player_pre_login; pub mod bedrock_form_response; pub mod changed_main_hand; pub mod custom_click_action; @@ -7,35 +9,74 @@ pub mod fish; pub mod inventory_close; pub mod inventory_interact; pub mod item_held; +pub mod player_advancement_done; pub mod player_animation; +pub mod player_armor_stand_manipulate; pub mod player_bed; pub mod player_bucket; +pub mod player_bucket_entity; pub mod player_change_world; +pub mod player_changed_world; +pub mod player_channel; pub mod player_chat; +pub mod player_command_preprocess; pub mod player_command_send; pub mod player_custom_payload; pub mod player_drop_item; +pub mod player_edit_book; +pub mod player_elytra_boost; +pub mod player_exp_cooldown_change; pub mod player_gamemode_change; +pub mod player_harvest_block; +pub mod player_hide_entity; +pub mod player_input; +pub mod player_interact_at_entity; pub mod player_interact_entity_event; pub mod player_interact_event; pub mod player_interact_unknown_entity_event; pub mod player_item_break; pub mod player_item_consume; pub mod player_item_damage; +pub mod player_item_mend; pub mod player_join; pub mod player_kick; +pub mod player_leash_entity; pub mod player_leave; pub mod player_level_change; +pub mod player_links_send; +pub mod player_locale_change; pub mod player_login; pub mod player_move; +pub mod player_name_entity; +pub mod player_open_sign; pub mod player_permission_check; +pub mod player_pickup_arrow; +pub mod player_portal; +pub mod player_pre_login; +pub mod player_recipe_book_click; +pub mod player_recipe_book_settings_change; +pub mod player_recipe_discover; +pub mod player_register_channel; +pub mod player_resource_pack_status; pub mod player_respawn; +pub mod player_riptide; +pub mod player_shear_entity; +pub mod player_show_entity; +pub mod player_spawn_change; +pub mod player_spawn_location; +pub mod player_statistic_increment; pub mod player_swap_hands; +pub mod player_take_lectern_book; pub mod player_teleport; pub mod player_toggle_flight_event; pub mod player_toggle_sneak_event; pub mod player_toggle_sprint_event; +pub mod player_unleash_entity; +pub mod player_unregister_channel; +pub mod player_velocity; +pub use async_player_chat::*; +pub use async_player_pre_login::*; pub use bedrock_form_response::*; pub use changed_main_hand::*; pub use custom_click_action::*; @@ -45,34 +86,71 @@ pub use fish::*; pub use inventory_close::*; pub use inventory_interact::*; pub use item_held::*; +pub use player_advancement_done::*; pub use player_animation::*; +pub use player_armor_stand_manipulate::*; pub use player_bed::*; pub use player_bucket::*; +pub use player_bucket_entity::*; pub use player_change_world::*; +pub use player_changed_world::*; +pub use player_channel::*; pub use player_chat::*; +pub use player_command_preprocess::*; pub use player_command_send::*; pub use player_custom_payload::*; pub use player_drop_item::*; +pub use player_edit_book::*; +pub use player_elytra_boost::*; +pub use player_exp_cooldown_change::*; pub use player_gamemode_change::*; +pub use player_harvest_block::*; +pub use player_hide_entity::*; +pub use player_input::*; +pub use player_interact_at_entity::*; pub use player_interact_entity_event::*; pub use player_interact_event::*; pub use player_interact_unknown_entity_event::*; pub use player_item_break::*; pub use player_item_consume::*; pub use player_item_damage::*; +pub use player_item_mend::*; pub use player_join::*; pub use player_kick::*; +pub use player_leash_entity::*; pub use player_leave::*; pub use player_level_change::*; +pub use player_links_send::*; +pub use player_locale_change::*; pub use player_login::*; pub use player_move::*; +pub use player_name_entity::*; +pub use player_open_sign::*; pub use player_permission_check::*; +pub use player_pickup_arrow::*; +pub use player_portal::*; +pub use player_pre_login::*; +pub use player_recipe_book_click::*; +pub use player_recipe_book_settings_change::*; +pub use player_recipe_discover::*; +pub use player_register_channel::*; +pub use player_resource_pack_status::*; pub use player_respawn::*; +pub use player_riptide::*; +pub use player_shear_entity::*; +pub use player_show_entity::*; +pub use player_spawn_change::*; +pub use player_spawn_location::*; +pub use player_statistic_increment::*; pub use player_swap_hands::*; +pub use player_take_lectern_book::*; pub use player_teleport::*; pub use player_toggle_flight_event::*; pub use player_toggle_sneak_event::*; pub use player_toggle_sprint_event::*; +pub use player_unleash_entity::*; +pub use player_unregister_channel::*; +pub use player_velocity::*; use std::sync::Arc; diff --git a/crates/pumpkin/src/plugin/api/events/player/player_advancement_done.rs b/crates/pumpkin/src/plugin/api/events/player/player_advancement_done.rs new file mode 100644 index 000000000..b346efb0a --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_advancement_done.rs @@ -0,0 +1,22 @@ +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +use super::PlayerEvent; +use crate::entity::player::Player; + +/// An event that occurs when a player completes an advancement. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerAdvancementDoneEvent { + /// The player who completed the advancement. + pub player: Arc, + + /// The advancement identifier. + pub advancement_id: String, +} + +impl PlayerEvent for PlayerAdvancementDoneEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_armor_stand_manipulate.rs b/crates/pumpkin/src/plugin/api/events/player/player_armor_stand_manipulate.rs new file mode 100644 index 000000000..fd2bbd07c --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_armor_stand_manipulate.rs @@ -0,0 +1,25 @@ +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +use super::PlayerEvent; +use crate::entity::player::Player; + +/// An event that occurs when a player manipulates an armor stand. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerArmorStandManipulateEvent { + /// The player manipulating the armor stand. + pub player: Arc, + + /// The ID of the armor stand entity. + pub armor_stand_id: i32, + + /// The armor stand slot. + pub slot: u8, +} + +impl PlayerEvent for PlayerArmorStandManipulateEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_bucket_entity.rs b/crates/pumpkin/src/plugin/api/events/player/player_bucket_entity.rs new file mode 100644 index 000000000..7ce1970f0 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_bucket_entity.rs @@ -0,0 +1,25 @@ +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +use super::PlayerEvent; +use crate::entity::player::Player; + +/// An event that occurs when a player captures an entity with a bucket. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerBucketEntityEvent { + /// The player using the bucket. + pub player: Arc, + + /// The ID of the captured entity. + pub entity_id: i32, + + /// The resulting bucket item name. + pub bucket_item: String, +} + +impl PlayerEvent for PlayerBucketEntityEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_changed_world.rs b/crates/pumpkin/src/plugin/api/events/player/player_changed_world.rs new file mode 100644 index 000000000..5b15adc79 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_changed_world.rs @@ -0,0 +1,26 @@ +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +use super::PlayerEvent; +use crate::entity::player::Player; +use crate::world::World; + +/// An event that occurs after a player has changed worlds. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerChangedWorldEvent { + /// The player who changed worlds. + pub player: Arc, + + /// The world the player came from. + pub from_world: Arc, + + /// The world the player arrived in. + pub to_world: Arc, +} + +impl PlayerEvent for PlayerChangedWorldEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_channel.rs b/crates/pumpkin/src/plugin/api/events/player/player_channel.rs new file mode 100644 index 000000000..49fa4b465 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_channel.rs @@ -0,0 +1,22 @@ +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +use super::PlayerEvent; +use crate::entity::player::Player; + +/// An event that occurs when a player changes/registers a plugin messaging channel. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerChannelEvent { + /// The player involved. + pub player: Arc, + + /// The plugin message channel name. + pub channel: String, +} + +impl PlayerEvent for PlayerChannelEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_command_preprocess.rs b/crates/pumpkin/src/plugin/api/events/player/player_command_preprocess.rs new file mode 100644 index 000000000..28f8f95c6 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_command_preprocess.rs @@ -0,0 +1,22 @@ +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +use super::PlayerEvent; +use crate::entity::player::Player; + +/// An event that occurs before a player command is executed. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerCommandPreprocessEvent { + /// The player sending the command. + pub player: Arc, + + /// The raw command string. + pub command: String, +} + +impl PlayerEvent for PlayerCommandPreprocessEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_edit_book.rs b/crates/pumpkin/src/plugin/api/events/player/player_edit_book.rs new file mode 100644 index 000000000..25d5fd7ea --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_edit_book.rs @@ -0,0 +1,31 @@ +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +use super::PlayerEvent; +use crate::entity::player::Player; + +/// An event that occurs when a player edits or signs a book. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerEditBookEvent { + /// The player editing the book. + pub player: Arc, + + /// The inventory slot of the book. + pub slot: u32, + + /// The book pages. + pub pages: Vec, + + /// The book title, if signing. + pub title: Option, + + /// Whether the book is being signed. + pub signing: bool, +} + +impl PlayerEvent for PlayerEditBookEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_elytra_boost.rs b/crates/pumpkin/src/plugin/api/events/player/player_elytra_boost.rs new file mode 100644 index 000000000..353807b73 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_elytra_boost.rs @@ -0,0 +1,22 @@ +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +use super::PlayerEvent; +use crate::entity::player::Player; + +/// An event that occurs when a player boosts their elytra flight using a firework. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerElytraBoostEvent { + /// The gliding player. + pub player: Arc, + + /// The ID of the firework entity. + pub firework_id: i32, +} + +impl PlayerEvent for PlayerElytraBoostEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_exp_cooldown_change.rs b/crates/pumpkin/src/plugin/api/events/player/player_exp_cooldown_change.rs new file mode 100644 index 000000000..3b348293a --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_exp_cooldown_change.rs @@ -0,0 +1,22 @@ +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +use super::PlayerEvent; +use crate::entity::player::Player; + +/// An event that occurs when a player's experience cooldown changes. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerExpCooldownChangeEvent { + /// The player involved. + pub player: Arc, + + /// The new cooldown ticks. + pub new_cooldown: i32, +} + +impl PlayerEvent for PlayerExpCooldownChangeEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_harvest_block.rs b/crates/pumpkin/src/plugin/api/events/player/player_harvest_block.rs new file mode 100644 index 000000000..6637d941e --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_harvest_block.rs @@ -0,0 +1,27 @@ +use pumpkin_data::item_stack::ItemStack; +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use super::PlayerEvent; +use crate::entity::player::Player; + +/// An event that occurs when a player harvests a block (e.g. sweet berry bush, bee hive). +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerHarvestBlockEvent { + /// The player harvesting the block. + pub player: Arc, + + /// The position of the harvested block. + pub block_pos: BlockPos, + + /// The items harvested. + pub harvested_items: Vec, +} + +impl PlayerEvent for PlayerHarvestBlockEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_hide_entity.rs b/crates/pumpkin/src/plugin/api/events/player/player_hide_entity.rs new file mode 100644 index 000000000..f0c933f3f --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_hide_entity.rs @@ -0,0 +1,22 @@ +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +use super::PlayerEvent; +use crate::entity::player::Player; + +/// An event that occurs when an entity is hidden from a player. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerHideEntityEvent { + /// The player from whom the entity is hidden. + pub player: Arc, + + /// The ID of the hidden entity. + pub entity_id: i32, +} + +impl PlayerEvent for PlayerHideEntityEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_input.rs b/crates/pumpkin/src/plugin/api/events/player/player_input.rs new file mode 100644 index 000000000..508d4c8f7 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_input.rs @@ -0,0 +1,31 @@ +use super::PlayerEvent; +use crate::entity::player::Player; +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +/// An event that occurs when player inputs are received. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerInputEvent { + /// The player. + pub player: Arc, + /// Input descriptor. + pub input: String, +} + +impl PlayerInputEvent { + #[must_use] + pub const fn new(player: Arc, input: String) -> Self { + Self { + player, + input, + cancelled: false, + } + } +} + +impl PlayerEvent for PlayerInputEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_interact_at_entity.rs b/crates/pumpkin/src/plugin/api/events/player/player_interact_at_entity.rs new file mode 100644 index 000000000..0a71216c7 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_interact_at_entity.rs @@ -0,0 +1,50 @@ +use super::PlayerEvent; +use crate::entity::player::Player; +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +/// An event that occurs when a player interacts at a specific location on an entity. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerInteractAtEntityEvent { + /// The player. + pub player: Arc, + /// Target entity ID. + pub entity_id: i32, + /// Clicked X. + pub clicked_x: f64, + /// Clicked Y. + pub clicked_y: f64, + /// Clicked Z. + pub clicked_z: f64, + /// Hand used (0 = main hand, 1 = off hand). + pub hand: u8, +} + +impl PlayerInteractAtEntityEvent { + #[must_use] + pub const fn new( + player: Arc, + entity_id: i32, + clicked_x: f64, + clicked_y: f64, + clicked_z: f64, + hand: u8, + ) -> Self { + Self { + player, + entity_id, + clicked_x, + clicked_y, + clicked_z, + hand, + cancelled: false, + } + } +} + +impl PlayerEvent for PlayerInteractAtEntityEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_item_mend.rs b/crates/pumpkin/src/plugin/api/events/player/player_item_mend.rs new file mode 100644 index 000000000..759a5e489 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_item_mend.rs @@ -0,0 +1,28 @@ +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +use super::PlayerEvent; +use crate::entity::player::Player; + +/// An event that occurs when a player's item is mended with experience. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerItemMendEvent { + /// The player owning the item. + pub player: Arc, + + /// The name of the item repaired. + pub item_name: String, + + /// The durability points repaired. + pub repair_amount: i32, + + /// The experience points consumed. + pub exp_consumed: i32, +} + +impl PlayerEvent for PlayerItemMendEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_leash_entity.rs b/crates/pumpkin/src/plugin/api/events/player/player_leash_entity.rs new file mode 100644 index 000000000..827457881 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_leash_entity.rs @@ -0,0 +1,25 @@ +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +use super::PlayerEvent; +use crate::entity::player::Player; + +/// An event that occurs when a player leashes an entity. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerLeashEntityEvent { + /// The player leashing the entity. + pub player: Arc, + + /// The ID of the leashed entity. + pub entity_id: i32, + + /// The ID of the holder entity or fence. + pub holder_id: i32, +} + +impl PlayerEvent for PlayerLeashEntityEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_links_send.rs b/crates/pumpkin/src/plugin/api/events/player/player_links_send.rs new file mode 100644 index 000000000..22d3c7952 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_links_send.rs @@ -0,0 +1,31 @@ +use super::PlayerEvent; +use crate::entity::player::Player; +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +/// An event that occurs when server links are sent to a player. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerLinksSendEvent { + /// The player. + pub player: Arc, + /// Links sent. + pub links: Vec, +} + +impl PlayerLinksSendEvent { + #[must_use] + pub const fn new(player: Arc, links: Vec) -> Self { + Self { + player, + links, + cancelled: false, + } + } +} + +impl PlayerEvent for PlayerLinksSendEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_locale_change.rs b/crates/pumpkin/src/plugin/api/events/player/player_locale_change.rs new file mode 100644 index 000000000..75c52e29c --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_locale_change.rs @@ -0,0 +1,22 @@ +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +use super::PlayerEvent; +use crate::entity::player::Player; + +/// An event that occurs when a player changes their client language/locale setting. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerLocaleChangeEvent { + /// The player involved. + pub player: Arc, + + /// The new locale code (e.g. "`en_us`"). + pub new_locale: String, +} + +impl PlayerEvent for PlayerLocaleChangeEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_name_entity.rs b/crates/pumpkin/src/plugin/api/events/player/player_name_entity.rs new file mode 100644 index 000000000..3c9be0996 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_name_entity.rs @@ -0,0 +1,26 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::text::TextComponent; +use std::sync::Arc; + +use super::PlayerEvent; +use crate::entity::player::Player; + +/// An event that occurs when a player names an entity using a name tag. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerNameEntityEvent { + /// The player naming the entity. + pub player: Arc, + + /// The ID of the named entity. + pub entity_id: i32, + + /// The custom name applied. + pub name: TextComponent, +} + +impl PlayerEvent for PlayerNameEntityEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_open_sign.rs b/crates/pumpkin/src/plugin/api/events/player/player_open_sign.rs new file mode 100644 index 000000000..bdfdceccb --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_open_sign.rs @@ -0,0 +1,26 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use super::PlayerEvent; +use crate::entity::player::Player; + +/// An event that occurs when a sign editor is opened for a player. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerOpenSignEvent { + /// The player opening the sign. + pub player: Arc, + + /// The sign block position. + pub block_pos: BlockPos, + + /// Whether the front side is being edited. + pub is_front: bool, +} + +impl PlayerEvent for PlayerOpenSignEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_pickup_arrow.rs b/crates/pumpkin/src/plugin/api/events/player/player_pickup_arrow.rs new file mode 100644 index 000000000..bc1a644f1 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_pickup_arrow.rs @@ -0,0 +1,31 @@ +use super::PlayerEvent; +use crate::entity::player::Player; +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +/// An event that occurs when a player picks up an arrow. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerPickupArrowEvent { + /// The player. + pub player: Arc, + /// Arrow entity ID. + pub arrow_id: i32, +} + +impl PlayerPickupArrowEvent { + #[must_use] + pub const fn new(player: Arc, arrow_id: i32) -> Self { + Self { + player, + arrow_id, + cancelled: false, + } + } +} + +impl PlayerEvent for PlayerPickupArrowEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_portal.rs b/crates/pumpkin/src/plugin/api/events/player/player_portal.rs new file mode 100644 index 000000000..756e22d77 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_portal.rs @@ -0,0 +1,26 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use super::PlayerEvent; +use crate::entity::player::Player; + +/// An event that occurs when a player uses a portal. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerPortalEvent { + /// The player using the portal. + pub player: Arc, + + /// The portal position where the player entered. + pub from_pos: BlockPos, + + /// The destination position, if known. + pub to_pos: Option, +} + +impl PlayerEvent for PlayerPortalEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_pre_login.rs b/crates/pumpkin/src/plugin/api/events/player/player_pre_login.rs new file mode 100644 index 000000000..12c4e09cb --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_pre_login.rs @@ -0,0 +1,21 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::text::TextComponent; +use std::net::SocketAddr; +use uuid::Uuid; + +/// An event that occurs synchronously when a player pre-logins. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerPreLoginEvent { + /// The player username. + pub player_name: String, + + /// The player unique ID. + pub player_uuid: Uuid, + + /// The remote IP address. + pub ip_address: SocketAddr, + + /// The kick message if rejected. + pub kick_message: TextComponent, +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_recipe_book_click.rs b/crates/pumpkin/src/plugin/api/events/player/player_recipe_book_click.rs new file mode 100644 index 000000000..5600ef4ff --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_recipe_book_click.rs @@ -0,0 +1,34 @@ +use super::PlayerEvent; +use crate::entity::player::Player; +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +/// An event that occurs when a player clicks a recipe in the recipe book. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerRecipeBookClickEvent { + /// The player. + pub player: Arc, + /// Recipe identifier. + pub recipe_id: String, + /// Whether Shift was held (craft max). + pub make_all: bool, +} + +impl PlayerRecipeBookClickEvent { + #[must_use] + pub const fn new(player: Arc, recipe_id: String, make_all: bool) -> Self { + Self { + player, + recipe_id, + make_all, + cancelled: false, + } + } +} + +impl PlayerEvent for PlayerRecipeBookClickEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_recipe_book_settings_change.rs b/crates/pumpkin/src/plugin/api/events/player/player_recipe_book_settings_change.rs new file mode 100644 index 000000000..256963c96 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_recipe_book_settings_change.rs @@ -0,0 +1,42 @@ +use super::PlayerEvent; +use crate::entity::player::Player; +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +/// An event that occurs when a player changes recipe book settings. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerRecipeBookSettingsChangeEvent { + /// The player. + pub player: Arc, + /// Recipe book type (crafting, furnace, etc.). + pub book_type: String, + /// Whether book is open. + pub is_open: bool, + /// Whether filter is active. + pub is_filtering: bool, +} + +impl PlayerRecipeBookSettingsChangeEvent { + #[must_use] + pub const fn new( + player: Arc, + book_type: String, + is_open: bool, + is_filtering: bool, + ) -> Self { + Self { + player, + book_type, + is_open, + is_filtering, + cancelled: false, + } + } +} + +impl PlayerEvent for PlayerRecipeBookSettingsChangeEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_recipe_discover.rs b/crates/pumpkin/src/plugin/api/events/player/player_recipe_discover.rs new file mode 100644 index 000000000..588bd3b43 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_recipe_discover.rs @@ -0,0 +1,31 @@ +use super::PlayerEvent; +use crate::entity::player::Player; +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +/// An event that occurs when a player discovers a recipe. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerRecipeDiscoverEvent { + /// The player. + pub player: Arc, + /// Recipe ID. + pub recipe_id: String, +} + +impl PlayerRecipeDiscoverEvent { + #[must_use] + pub const fn new(player: Arc, recipe_id: String) -> Self { + Self { + player, + recipe_id, + cancelled: false, + } + } +} + +impl PlayerEvent for PlayerRecipeDiscoverEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_register_channel.rs b/crates/pumpkin/src/plugin/api/events/player/player_register_channel.rs new file mode 100644 index 000000000..ad3b2c836 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_register_channel.rs @@ -0,0 +1,31 @@ +use super::PlayerEvent; +use crate::entity::player::Player; +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +/// An event that occurs when a plugin channel is registered for a player. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerRegisterChannelEvent { + /// The player. + pub player: Arc, + /// Channel name. + pub channel: String, +} + +impl PlayerRegisterChannelEvent { + #[must_use] + pub const fn new(player: Arc, channel: String) -> Self { + Self { + player, + channel, + cancelled: false, + } + } +} + +impl PlayerEvent for PlayerRegisterChannelEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_resource_pack_status.rs b/crates/pumpkin/src/plugin/api/events/player/player_resource_pack_status.rs new file mode 100644 index 000000000..d47784b88 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_resource_pack_status.rs @@ -0,0 +1,34 @@ +use super::PlayerEvent; +use crate::entity::player::Player; +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +/// An event that occurs when a player responds to a resource pack request. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerResourcePackStatusEvent { + /// The player. + pub player: Arc, + /// Pack ID. + pub pack_id: String, + /// Status description. + pub status: String, +} + +impl PlayerResourcePackStatusEvent { + #[must_use] + pub const fn new(player: Arc, pack_id: String, status: String) -> Self { + Self { + player, + pack_id, + status, + cancelled: false, + } + } +} + +impl PlayerEvent for PlayerResourcePackStatusEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_riptide.rs b/crates/pumpkin/src/plugin/api/events/player/player_riptide.rs new file mode 100644 index 000000000..f7721e14c --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_riptide.rs @@ -0,0 +1,22 @@ +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +use super::PlayerEvent; +use crate::entity::player::Player; + +/// An event that occurs when a player activates the riptide trident enchantment. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerRiptideEvent { + /// The player activating riptide. + pub player: Arc, + + /// The riptide item name. + pub item_name: String, +} + +impl PlayerEvent for PlayerRiptideEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_shear_entity.rs b/crates/pumpkin/src/plugin/api/events/player/player_shear_entity.rs new file mode 100644 index 000000000..f40c5a3ca --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_shear_entity.rs @@ -0,0 +1,25 @@ +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +use super::PlayerEvent; +use crate::entity::player::Player; + +/// An event that occurs when a player shears an entity. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerShearEntityEvent { + /// The shearing player. + pub player: Arc, + + /// The sheared entity ID. + pub entity_id: i32, + + /// Hand used (0 = main hand, 1 = off hand). + pub hand: u8, +} + +impl PlayerEvent for PlayerShearEntityEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_show_entity.rs b/crates/pumpkin/src/plugin/api/events/player/player_show_entity.rs new file mode 100644 index 000000000..21de7ddbc --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_show_entity.rs @@ -0,0 +1,22 @@ +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +use super::PlayerEvent; +use crate::entity::player::Player; + +/// An event that occurs when an entity is made visible to a player. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerShowEntityEvent { + /// The observing player. + pub player: Arc, + + /// The entity ID revealed. + pub entity_id: i32, +} + +impl PlayerEvent for PlayerShowEntityEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_spawn_change.rs b/crates/pumpkin/src/plugin/api/events/player/player_spawn_change.rs new file mode 100644 index 000000000..4e274e359 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_spawn_change.rs @@ -0,0 +1,26 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use super::PlayerEvent; +use crate::entity::player::Player; + +/// An event that occurs when a player's spawn location changes (e.g. bed/respawn anchor). +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerSpawnChangeEvent { + /// The player whose spawn changed. + pub player: Arc, + + /// The new spawn position, if set. + pub new_spawn: Option, + + /// Whether this spawn point is forced. + pub forced: bool, +} + +impl PlayerEvent for PlayerSpawnChangeEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_spawn_location.rs b/crates/pumpkin/src/plugin/api/events/player/player_spawn_location.rs new file mode 100644 index 000000000..00193fc7f --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_spawn_location.rs @@ -0,0 +1,32 @@ +use super::PlayerEvent; +use crate::entity::player::Player; +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::vector3::Vector3; +use std::sync::Arc; + +/// An event that occurs when determining player spawn position. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerSpawnLocationEvent { + /// The player. + pub player: Arc, + /// Spawn position. + pub spawn_pos: Vector3, +} + +impl PlayerSpawnLocationEvent { + #[must_use] + pub const fn new(player: Arc, spawn_pos: Vector3) -> Self { + Self { + player, + spawn_pos, + cancelled: false, + } + } +} + +impl PlayerEvent for PlayerSpawnLocationEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_statistic_increment.rs b/crates/pumpkin/src/plugin/api/events/player/player_statistic_increment.rs new file mode 100644 index 000000000..0e7990516 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_statistic_increment.rs @@ -0,0 +1,25 @@ +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +use super::PlayerEvent; +use crate::entity::player::Player; + +/// An event that occurs when a player's statistic is incremented. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerStatisticIncrementEvent { + /// The player whose statistic changed. + pub player: Arc, + + /// The statistic identifier name. + pub statistic_id: String, + + /// The amount incremented. + pub amount: i32, +} + +impl PlayerEvent for PlayerStatisticIncrementEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_take_lectern_book.rs b/crates/pumpkin/src/plugin/api/events/player/player_take_lectern_book.rs new file mode 100644 index 000000000..3d7a0ca93 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_take_lectern_book.rs @@ -0,0 +1,27 @@ +use pumpkin_data::item_stack::ItemStack; +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; +use std::sync::Arc; + +use super::PlayerEvent; +use crate::entity::player::Player; + +/// An event that occurs when a player takes a book from a lectern. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerTakeLecternBookEvent { + /// The player taking the book. + pub player: Arc, + + /// The position of the lectern. + pub block_pos: BlockPos, + + /// The book item stack. + pub book: ItemStack, +} + +impl PlayerEvent for PlayerTakeLecternBookEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_unleash_entity.rs b/crates/pumpkin/src/plugin/api/events/player/player_unleash_entity.rs new file mode 100644 index 000000000..d853f38c6 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_unleash_entity.rs @@ -0,0 +1,22 @@ +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +use super::PlayerEvent; +use crate::entity::player::Player; + +/// An event that occurs when a player unleashes an entity. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerUnleashEntityEvent { + /// The player unleashing the entity. + pub player: Arc, + + /// The ID of the unleashed entity. + pub entity_id: i32, +} + +impl PlayerEvent for PlayerUnleashEntityEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_unregister_channel.rs b/crates/pumpkin/src/plugin/api/events/player/player_unregister_channel.rs new file mode 100644 index 000000000..a8d2e2343 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_unregister_channel.rs @@ -0,0 +1,31 @@ +use super::PlayerEvent; +use crate::entity::player::Player; +use pumpkin_macros::{Event, cancellable}; +use std::sync::Arc; + +/// An event that occurs when a plugin channel is unregistered for a player. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerUnregisterChannelEvent { + /// The player. + pub player: Arc, + /// Channel name. + pub channel: String, +} + +impl PlayerUnregisterChannelEvent { + #[must_use] + pub const fn new(player: Arc, channel: String) -> Self { + Self { + player, + channel, + cancelled: false, + } + } +} + +impl PlayerEvent for PlayerUnregisterChannelEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/player/player_velocity.rs b/crates/pumpkin/src/plugin/api/events/player/player_velocity.rs new file mode 100644 index 000000000..1bf0ab7be --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/player/player_velocity.rs @@ -0,0 +1,23 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::vector3::Vector3; +use std::sync::Arc; + +use super::PlayerEvent; +use crate::entity::player::Player; + +/// An event that occurs when a player's velocity changes. +#[cancellable] +#[derive(Event, Clone)] +pub struct PlayerVelocityEvent { + /// The player involved. + pub player: Arc, + + /// The new velocity vector. + pub velocity: Vector3, +} + +impl PlayerEvent for PlayerVelocityEvent { + fn get_player(&self) -> &Arc { + &self.player + } +} diff --git a/crates/pumpkin/src/plugin/api/events/server/map_initialize.rs b/crates/pumpkin/src/plugin/api/events/server/map_initialize.rs new file mode 100644 index 000000000..ce6e9366e --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/server/map_initialize.rs @@ -0,0 +1,15 @@ +use pumpkin_macros::Event; + +/// An event that occurs when a map is initialized. +#[derive(Event, Clone)] +pub struct MapInitializeEvent { + /// The ID of the initialized map. + pub map_id: i32, +} + +impl MapInitializeEvent { + #[must_use] + pub const fn new(map_id: i32) -> Self { + Self { map_id } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/server/mod.rs b/crates/pumpkin/src/plugin/api/events/server/mod.rs index 82ee82da7..58ef02cd4 100644 --- a/crates/pumpkin/src/plugin/api/events/server/mod.rs +++ b/crates/pumpkin/src/plugin/api/events/server/mod.rs @@ -1,4 +1,5 @@ pub mod list_ping; +pub mod map_initialize; pub mod packet; pub mod plugin_disable; pub mod plugin_enable; @@ -13,6 +14,7 @@ pub mod service_unregister; pub mod tab_complete; pub use list_ping::*; +pub use map_initialize::*; pub use packet::*; pub use plugin_disable::*; pub use plugin_enable::*; diff --git a/crates/pumpkin/src/plugin/api/events/vehicle/mod.rs b/crates/pumpkin/src/plugin/api/events/vehicle/mod.rs index 436c9734e..27d9381c1 100644 --- a/crates/pumpkin/src/plugin/api/events/vehicle/mod.rs +++ b/crates/pumpkin/src/plugin/api/events/vehicle/mod.rs @@ -1,4 +1,5 @@ pub mod vehicle_block_collision; +pub mod vehicle_collision; pub mod vehicle_create; pub mod vehicle_damage; pub mod vehicle_destroy; @@ -9,6 +10,7 @@ pub mod vehicle_move; pub mod vehicle_update; pub use vehicle_block_collision::*; +pub use vehicle_collision::*; pub use vehicle_create::*; pub use vehicle_damage::*; pub use vehicle_destroy::*; diff --git a/crates/pumpkin/src/plugin/api/events/vehicle/vehicle_collision.rs b/crates/pumpkin/src/plugin/api/events/vehicle/vehicle_collision.rs new file mode 100644 index 000000000..0782a155b --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/vehicle/vehicle_collision.rs @@ -0,0 +1,19 @@ +use pumpkin_macros::{Event, cancellable}; + +/// Base event triggered when a vehicle collides. +#[cancellable] +#[derive(Event, Clone)] +pub struct VehicleCollisionEvent { + /// The ID of the vehicle entity. + pub vehicle_id: i32, +} + +impl VehicleCollisionEvent { + #[must_use] + pub const fn new(vehicle_id: i32) -> Self { + Self { + vehicle_id, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/world/async_structure_generate.rs b/crates/pumpkin/src/plugin/api/events/world/async_structure_generate.rs new file mode 100644 index 000000000..34c78ed86 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/world/async_structure_generate.rs @@ -0,0 +1,23 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; + +/// An event that occurs when a structure is asynchronously generated. +#[cancellable] +#[derive(Event, Clone)] +pub struct AsyncStructureGenerateEvent { + pub world_name: String, + pub structure_name: String, + pub pos: BlockPos, +} + +impl AsyncStructureGenerateEvent { + #[must_use] + pub const fn new(world_name: String, structure_name: String, pos: BlockPos) -> Self { + Self { + world_name, + structure_name, + pos, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/world/async_structure_spawn.rs b/crates/pumpkin/src/plugin/api/events/world/async_structure_spawn.rs new file mode 100644 index 000000000..c886991f5 --- /dev/null +++ b/crates/pumpkin/src/plugin/api/events/world/async_structure_spawn.rs @@ -0,0 +1,23 @@ +use pumpkin_macros::{Event, cancellable}; +use pumpkin_util::math::position::BlockPos; + +/// An event that occurs when a structure is asynchronously spawned. +#[cancellable] +#[derive(Event, Clone)] +pub struct AsyncStructureSpawnEvent { + pub world_name: String, + pub structure_name: String, + pub pos: BlockPos, +} + +impl AsyncStructureSpawnEvent { + #[must_use] + pub const fn new(world_name: String, structure_name: String, pos: BlockPos) -> Self { + Self { + world_name, + structure_name, + pos, + cancelled: false, + } + } +} diff --git a/crates/pumpkin/src/plugin/api/events/world/mod.rs b/crates/pumpkin/src/plugin/api/events/world/mod.rs index 2d5ba941e..403d721bb 100644 --- a/crates/pumpkin/src/plugin/api/events/world/mod.rs +++ b/crates/pumpkin/src/plugin/api/events/world/mod.rs @@ -1,3 +1,5 @@ +pub mod async_structure_generate; +pub mod async_structure_spawn; pub mod chunk_load; pub mod chunk_populate; pub mod chunk_save; @@ -17,6 +19,8 @@ pub mod world_init; pub mod world_load; pub mod world_save; +pub use async_structure_generate::*; +pub use async_structure_spawn::*; pub use chunk_load::*; pub use chunk_populate::*; pub use chunk_save::*; diff --git a/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/context.rs b/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/context.rs index 5daf88eaa..01af84aef 100644 --- a/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/context.rs +++ b/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/context.rs @@ -219,6 +219,270 @@ async fn register_player_event( >(resource, handler, priority, blocking) .await; } + EventType::AsyncPlayerChatEvent => { + register_typed_event::< + crate::plugin::api::events::player::async_player_chat::AsyncPlayerChatEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::AsyncPlayerPreLoginEvent => { + register_typed_event::< + crate::plugin::api::events::player::async_player_pre_login::AsyncPlayerPreLoginEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerAdvancementDoneEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_advancement_done::PlayerAdvancementDoneEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerAnimationEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_animation::PlayerAnimationEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerArmorStandManipulateEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_armor_stand_manipulate::PlayerArmorStandManipulateEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerBucketEntityEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_bucket_entity::PlayerBucketEntityEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerChangedWorldEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_changed_world::PlayerChangedWorldEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerChannelEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_channel::PlayerChannelEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerCommandPreprocessEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_command_preprocess::PlayerCommandPreprocessEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerEditBookEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_edit_book::PlayerEditBookEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerElytraBoostEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_elytra_boost::PlayerElytraBoostEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerExpCooldownChangeEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_exp_cooldown_change::PlayerExpCooldownChangeEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerHarvestBlockEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_harvest_block::PlayerHarvestBlockEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerHideEntityEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_hide_entity::PlayerHideEntityEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerItemBreakEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_item_break::PlayerItemBreakEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerItemMendEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_item_mend::PlayerItemMendEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerKickEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_kick::PlayerKickEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerLeashEntityEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_leash_entity::PlayerLeashEntityEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerLevelChangeEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_level_change::PlayerLevelChangeEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerLocaleChangeEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_locale_change::PlayerLocaleChangeEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerNameEntityEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_name_entity::PlayerNameEntityEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerOpenSignEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_open_sign::PlayerOpenSignEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerPortalEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_portal::PlayerPortalEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerPreLoginEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_pre_login::PlayerPreLoginEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerRiptideEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_riptide::PlayerRiptideEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerShearEntityEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_shear_entity::PlayerShearEntityEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerShowEntityEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_show_entity::PlayerShowEntityEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerSpawnChangeEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_spawn_change::PlayerSpawnChangeEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerStatisticIncrementEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_statistic_increment::PlayerStatisticIncrementEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerSwapHandsEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_swap_hands::PlayerSwapHandItemsEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerTakeLecternBookEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_take_lectern_book::PlayerTakeLecternBookEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerUnleashEntityEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_unleash_entity::PlayerUnleashEntityEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerVelocityEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_velocity::PlayerVelocityEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerInputEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_input::PlayerInputEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerInteractAtEntityEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_interact_at_entity::PlayerInteractAtEntityEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerLinksSendEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_links_send::PlayerLinksSendEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerPickupArrowEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_pickup_arrow::PlayerPickupArrowEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerRecipeBookClickEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_recipe_book_click::PlayerRecipeBookClickEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerRecipeBookSettingsChangeEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_recipe_book_settings_change::PlayerRecipeBookSettingsChangeEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerRecipeDiscoverEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_recipe_discover::PlayerRecipeDiscoverEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerRegisterChannelEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_register_channel::PlayerRegisterChannelEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerResourcePackStatusEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_resource_pack_status::PlayerResourcePackStatusEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerSpawnLocationEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_spawn_location::PlayerSpawnLocationEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PlayerUnregisterChannelEvent => { + register_typed_event::< + crate::plugin::api::events::player::player_unregister_channel::PlayerUnregisterChannelEvent, + >(resource, handler, priority, blocking) + .await; + } _ => { tracing::error!("non-player event should not be routed to register_player_event"); } @@ -249,27 +513,82 @@ async fn register_entity_event( event_type: EventType, ) { use crate::plugin::entity::{ + area_effect_cloud_apply::AreaEffectCloudApplyEvent, + arrow_body_count_change::ArrowBodyCountChangeEvent, + bat_toggle_sleep::BatToggleSleepEvent, + creature_spawn::CreatureSpawnEvent, + creeper_power::CreeperPowerEvent, + ender_dragon_change_phase::EnderDragonChangePhaseEvent, entity_air_change::EntityAirChangeEvent, + entity_break_door::EntityBreakDoorEvent, entity_breed::EntityBreedEvent, + entity_change_block::EntityChangeBlockEvent, entity_combust::EntityCombustEvent, + entity_combust_by_block::EntityCombustByBlockEvent, + entity_combust_by_entity::EntityCombustByEntityEvent, entity_damage::EntityDamageEvent, + entity_damage_by_block::EntityDamageByBlockEvent, + entity_damage_by_entity::EntityDamageByEntityEvent, entity_death::{EntityDeathEvent, PlayerDeathEvent}, entity_dismount::EntityDismountEvent, + entity_drop_item::EntityDropItemEvent, entity_dye::EntityDyeEvent, + entity_enter_block::EntityEnterBlockEvent, entity_enter_love_mode::EntityEnterLoveModeEvent, + entity_exhaustion::EntityExhaustionEvent, entity_explode::EntityExplodeEvent, + entity_interact::EntityInteractEvent, + entity_knockback::EntityKnockbackEvent, + entity_knockback_by_entity::EntityKnockbackByEntityEvent, entity_mount::EntityMountEvent, entity_pickup_item::EntityPickupItemEvent, + entity_place::EntityPlaceEvent, entity_portal::EntityPortalEvent, + entity_portal_enter::EntityPortalEnterEvent, + entity_portal_exit::EntityPortalExitEvent, + entity_pose_change::EntityPoseChangeEvent, + entity_potion_effect::EntityPotionEffectEvent, entity_regain_health::EntityRegainHealthEvent, + entity_remove::EntityRemoveEvent, entity_resurrect::EntityResurrectEvent, entity_shoot_bow::EntityShootBowEvent, entity_spawn::EntitySpawnEvent, + entity_spell_cast::EntitySpellCastEvent, entity_tame::EntityTameEvent, entity_target::EntityTargetEvent, + entity_target_block::EntityTargetBlockEvent, + entity_target_living_entity::EntityTargetLivingEntityEvent, entity_teleport::EntityTeleportEvent, entity_toggle_glide::EntityToggleGlideEvent, + entity_toggle_swim::EntityToggleSwimEvent, entity_transform::EntityTransformEvent, + entity_unleash::EntityUnleashEvent, + exp_bottle::ExpBottleEvent, + explosion_prime::ExplosionPrimeEvent, + firework_explode::FireworkExplodeEvent, + food_level_change::FoodLevelChangeEvent, + horse_jump::HorseJumpEvent, + item_despawn::ItemDespawnEvent, + item_merge::ItemMergeEvent, + item_spawn::ItemSpawnEvent, + lingering_potion_splash::LingeringPotionSplashEvent, + pig_zap::PigZapEvent, + pig_zombie_anger::PigZombieAngerEvent, + piglin_barter::PiglinBarterEvent, + potion_splash::PotionSplashEvent, + projectile_hit::ProjectileHitEvent, + projectile_launch::ProjectileLaunchEvent, + sheep_dye_wool::SheepDyeWoolEvent, + sheep_regrow_wool::SheepRegrowWoolEvent, + slime_split::SlimeSplitEvent, + spawner_spawn::SpawnerSpawnEvent, + strider_temperature_change::StriderTemperatureChangeEvent, + trial_spawner_spawn::TrialSpawnerSpawnEvent, + villager_acquire_trade::VillagerAcquireTradeEvent, + villager_career_change::VillagerCareerChangeEvent, + villager_replenish_trade::VillagerReplenishTradeEvent, + villager_reputation_change::VillagerReputationChangeEvent, + warden_anger_change::WardenAngerChangeEvent, }; match event_type { @@ -349,6 +668,237 @@ async fn register_entity_event( register_typed_event::(resource, handler, priority, blocking) .await; } + EventType::CreatureSpawnEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::EnderDragonChangePhaseEvent => { + register_typed_event::( + resource, handler, priority, blocking, + ) + .await; + } + EventType::EntityBreakDoorEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::EntityChangeBlockEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::EntityDamageByBlockEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::EntityDamageByEntityEvent => { + register_typed_event::( + resource, handler, priority, blocking, + ) + .await; + } + EventType::EntityDropItemEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::EntityEnterBlockEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::EntityExhaustionEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::EntityInteractEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::EntityKnockbackEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::EntityPlaceEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::EntityPoseChangeEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::EntityPotionEffectEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::EntitySpellCastEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::EntityTargetLivingEntityEvent => { + register_typed_event::( + resource, handler, priority, blocking, + ) + .await; + } + EventType::EntityToggleSwimEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::ExplosionPrimeEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::FireworkExplodeEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::FoodLevelChangeEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::ItemDespawnEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::ItemMergeEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::ItemSpawnEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::PiglinBarterEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::ProjectileHitEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::ProjectileLaunchEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::SheepDyeWoolEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::SheepRegrowWoolEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::SlimeSplitEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::StriderTemperatureChangeEvent => { + register_typed_event::( + resource, handler, priority, blocking, + ) + .await; + } + EventType::VillagerAcquireTradeEvent => { + register_typed_event::( + resource, handler, priority, blocking, + ) + .await; + } + EventType::VillagerCareerChangeEvent => { + register_typed_event::( + resource, handler, priority, blocking, + ) + .await; + } + EventType::VillagerReplenishTradeEvent => { + register_typed_event::( + resource, handler, priority, blocking, + ) + .await; + } + EventType::WardenAngerChangeEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::AreaEffectCloudApplyEvent => { + register_typed_event::( + resource, handler, priority, blocking, + ) + .await; + } + EventType::ArrowBodyCountChangeEvent => { + register_typed_event::( + resource, handler, priority, blocking, + ) + .await; + } + EventType::BatToggleSleepEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::CreeperPowerEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::EntityCombustByBlockEvent => { + register_typed_event::( + resource, handler, priority, blocking, + ) + .await; + } + EventType::EntityCombustByEntityEvent => { + register_typed_event::( + resource, handler, priority, blocking, + ) + .await; + } + EventType::EntityKnockbackByEntityEvent => { + register_typed_event::( + resource, handler, priority, blocking, + ) + .await; + } + EventType::EntityPortalEnterEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::EntityPortalExitEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::EntityRemoveEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::EntityTargetBlockEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::EntityUnleashEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::ExpBottleEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::HorseJumpEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::LingeringPotionSplashEvent => { + register_typed_event::( + resource, handler, priority, blocking, + ) + .await; + } + EventType::PigZapEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::PigZombieAngerEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::PotionSplashEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::SpawnerSpawnEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::TrialSpawnerSpawnEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::VillagerReputationChangeEvent => { + register_typed_event::( + resource, handler, priority, blocking, + ) + .await; + } _ => { tracing::error!("non-entity event should not be routed to register_entity_event"); } @@ -363,8 +913,17 @@ async fn register_inventory_event( event_type: EventType, ) { use crate::plugin::inventory::{ - craft_item::CraftItemEvent, furnace_smelt::FurnaceSmeltEvent, - inventory_drag::InventoryDragEvent, inventory_open::InventoryOpenEvent, + brew::BrewEvent, brewing_stand_fuel::BrewingStandFuelEvent, craft_item::CraftItemEvent, + furnace_burn::FurnaceBurnEvent, furnace_extract::FurnaceExtractEvent, + furnace_smelt::FurnaceSmeltEvent, furnace_start_smelt::FurnaceStartSmeltEvent, + hopper_inventory_search::HopperInventorySearchEvent, + inventory_creative::InventoryCreativeEvent, inventory_drag::InventoryDragEvent, + inventory_interact::InventoryInteractEvent, inventory_move_item::InventoryMoveItemEvent, + inventory_open::InventoryOpenEvent, inventory_pickup_item::InventoryPickupItemEvent, + prepare_anvil::PrepareAnvilEvent, prepare_grindstone::PrepareGrindstoneEvent, + prepare_inventory_result::PrepareInventoryResultEvent, + prepare_item_craft::PrepareItemCraftEvent, prepare_smithing::PrepareSmithingEvent, + smith_item::SmithItemEvent, trade_select::TradeSelectEvent, }; match event_type { @@ -380,12 +939,140 @@ async fn register_inventory_event( EventType::FurnaceSmeltEvent => { register_typed_event::(resource, handler, priority, blocking).await; } + EventType::BrewEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::BrewingStandFuelEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::FurnaceBurnEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::FurnaceExtractEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::FurnaceStartSmeltEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::HopperInventorySearchEvent => { + register_typed_event::( + resource, handler, priority, blocking, + ) + .await; + } + EventType::InventoryCreativeEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::InventoryInteractEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::InventoryMoveItemEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::InventoryPickupItemEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::PrepareAnvilEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::PrepareGrindstoneEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::PrepareInventoryResultEvent => { + register_typed_event::( + resource, handler, priority, blocking, + ) + .await; + } + EventType::PrepareItemCraftEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::PrepareSmithingEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::SmithItemEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::TradeSelectEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } _ => { tracing::error!("non-inventory event should not be routed to register_inventory_event"); } } } +async fn register_vehicle_event( + resource: &ContextResource, + handler: &Arc, + priority: crate::plugin::EventPriority, + blocking: bool, + event_type: EventType, +) { + use crate::plugin::vehicle::{ + vehicle_block_collision::VehicleBlockCollisionEvent, + vehicle_collision::VehicleCollisionEvent, vehicle_create::VehicleCreateEvent, + vehicle_damage::VehicleDamageEvent, vehicle_destroy::VehicleDestroyEvent, + vehicle_enter::VehicleEnterEvent, vehicle_entity_collision::VehicleEntityCollisionEvent, + vehicle_exit::VehicleExitEvent, vehicle_move::VehicleMoveEvent, + vehicle_update::VehicleUpdateEvent, + }; + + match event_type { + EventType::VehicleBlockCollisionEvent => { + register_typed_event::( + resource, handler, priority, blocking, + ) + .await; + } + EventType::VehicleCollisionEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::VehicleCreateEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::VehicleDamageEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::VehicleDestroyEvent => { + register_typed_event::(resource, handler, priority, blocking) + .await; + } + EventType::VehicleEnterEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::VehicleEntityCollisionEvent => { + register_typed_event::( + resource, handler, priority, blocking, + ) + .await; + } + EventType::VehicleExitEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::VehicleMoveEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::VehicleUpdateEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + _ => { + tracing::error!("non-vehicle event should not be routed to register_vehicle_event"); + } + } +} + async fn register_enchantment_event( resource: &ContextResource, handler: &Arc, @@ -413,6 +1100,7 @@ async fn register_enchantment_event( } } +#[allow(clippy::too_many_lines)] async fn register_world_event( resource: &ContextResource, handler: &Arc, @@ -462,6 +1150,90 @@ async fn register_world_event( >(resource, handler, priority, blocking) .await; } + EventType::AsyncStructureGenerateEvent => { + register_typed_event::< + crate::plugin::api::events::world::async_structure_generate::AsyncStructureGenerateEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::AsyncStructureSpawnEvent => { + register_typed_event::< + crate::plugin::api::events::world::async_structure_spawn::AsyncStructureSpawnEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::ChunkPopulateEvent => { + register_typed_event::< + crate::plugin::api::events::world::chunk_populate::ChunkPopulateEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::ChunkUnloadEvent => { + register_typed_event::< + crate::plugin::api::events::world::chunk_unload::ChunkUnloadEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::EntitiesLoadEvent => { + register_typed_event::< + crate::plugin::api::events::world::entities_load::EntitiesLoadEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::EntitiesUnloadEvent => { + register_typed_event::< + crate::plugin::api::events::world::entities_unload::EntitiesUnloadEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::GenericGameEvent => { + register_typed_event::< + crate::plugin::api::events::world::generic_game::GenericGameEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::LootGenerateEvent => { + register_typed_event::< + crate::plugin::api::events::world::loot_generate::LootGenerateEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::PortalCreateEvent => { + register_typed_event::< + crate::plugin::api::events::world::portal_create::PortalCreateEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::StructureGrowEvent => { + register_typed_event::< + crate::plugin::api::events::world::structure_grow::StructureGrowEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::TimeSkipEvent => { + register_typed_event::( + resource, handler, priority, blocking, + ) + .await; + } + EventType::WorldInitEvent => { + register_typed_event::( + resource, handler, priority, blocking, + ) + .await; + } + EventType::WorldSaveEvent => { + register_typed_event::( + resource, handler, priority, blocking, + ) + .await; + } + EventType::LightningStrikeEvent => { + register_typed_event::< + crate::plugin::api::events::world::lightning_strike::LightningStrikeEvent, + >(resource, handler, priority, blocking) + .await; + } _ => { tracing::error!("non-world event should not be routed to register_world_event"); } @@ -585,12 +1357,194 @@ async fn register_block_event( ) .await; } + EventType::BellResonateEvent => { + register_typed_event::< + crate::plugin::api::events::block::bell_resonate::BellResonateEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::BellRingEvent => { + register_typed_event::( + resource, handler, priority, blocking, + ) + .await; + } + EventType::BlockBrushEvent => { + register_typed_event::( + resource, handler, priority, blocking, + ) + .await; + } + EventType::BlockCookEvent => { + register_typed_event::( + resource, handler, priority, blocking, + ) + .await; + } + EventType::BlockDamageAbortEvent => { + register_typed_event::< + crate::plugin::api::events::block::block_damage_abort::BlockDamageAbortEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::BlockDispenseArmorEvent => { + register_typed_event::< + crate::plugin::api::events::block::block_dispense_armor::BlockDispenseArmorEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::BlockDispenseLootEvent => { + register_typed_event::< + crate::plugin::api::events::block::block_dispense_loot::BlockDispenseLootEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::BlockDropItemEvent => { + register_typed_event::< + crate::plugin::api::events::block::block_drop_item::BlockDropItemEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::BlockExpEvent => { + register_typed_event::( + resource, handler, priority, blocking, + ) + .await; + } + EventType::BlockFertilizeEvent => { + register_typed_event::< + crate::plugin::api::events::block::block_fertilize::BlockFertilizeEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::BlockMultiPlaceEvent => { + register_typed_event::< + crate::plugin::api::events::block::block_multi_place::BlockMultiPlaceEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::BlockReceiveGameEvent => { + register_typed_event::< + crate::plugin::api::events::block::block_receive_game::BlockReceiveGameEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::BlockShearEntityEvent => { + register_typed_event::< + crate::plugin::api::events::block::block_shear_entity::BlockShearEntityEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::BlockSpreadEvent => { + register_typed_event::< + crate::plugin::api::events::block::block_spread::BlockSpreadEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::BrewingStartEvent => { + register_typed_event::< + crate::plugin::api::events::block::brewing_start::BrewingStartEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::CampfireStartEvent => { + register_typed_event::< + crate::plugin::api::events::block::campfire_start::CampfireStartEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::CauldronLevelChangeEvent => { + register_typed_event::< + crate::plugin::api::events::block::cauldron_level_change::CauldronLevelChangeEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::CrafterCraftEvent => { + register_typed_event::< + crate::plugin::api::events::block::crafter_craft::CrafterCraftEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::EntityBlockFormEvent => { + register_typed_event::< + crate::plugin::api::events::block::entity_block_form::EntityBlockFormEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::FluidLevelChangeEvent => { + register_typed_event::< + crate::plugin::api::events::block::fluid_level_change::FluidLevelChangeEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::InventoryBlockStartEvent => { + register_typed_event::< + crate::plugin::api::events::block::inventory_block_start::InventoryBlockStartEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::LeavesDecayEvent => { + register_typed_event::< + crate::plugin::api::events::block::leaves_decay::LeavesDecayEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::MoistureChangeEvent => { + register_typed_event::< + crate::plugin::api::events::block::moisture_change::MoistureChangeEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::SculkBloomEvent => { + register_typed_event::< + crate::plugin::api::events::block::sculk_bloom::SculkBloomEvent, + >(resource, handler, priority, blocking) + .await; + } + EventType::VaultDisplayItemEvent => { + register_typed_event::< + crate::plugin::api::events::block::vault_display_item::VaultDisplayItemEvent, + >(resource, handler, priority, blocking) + .await; + } _ => { tracing::error!("non-block event should not be routed to register_block_event"); } } } + +async fn register_raid_event( + resource: &ContextResource, + handler: &Arc, + priority: crate::plugin::EventPriority, + blocking: bool, + event_type: EventType, +) { + use crate::plugin::raid::{ + raid_finish::RaidFinishEvent, raid_spawn_wave::RaidSpawnWaveEvent, + raid_stop::RaidStopEvent, raid_trigger::RaidTriggerEvent, + }; + + match event_type { + EventType::RaidFinishEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::RaidSpawnWaveEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::RaidStopEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::RaidTriggerEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + _ => { + tracing::error!("non-raid event should not be routed to register_raid_event"); + } + } +} + async fn register_server_event( resource: &ContextResource, handler: &Arc, @@ -637,12 +1591,49 @@ async fn register_server_event( register_typed_event::(resource, handler, priority, blocking) .await; } + EventType::MapInitializeEvent => { + register_typed_event::< + crate::plugin::api::events::server::map_initialize::MapInitializeEvent, + >(resource, handler, priority, blocking) + .await; + } _ => { tracing::error!("non-server event should not be routed to register_server_event"); } } } +async fn register_hanging_event( + resource: &ContextResource, + handler: &Arc, + priority: crate::plugin::EventPriority, + blocking: bool, + event_type: EventType, +) { + use crate::plugin::hanging::{ + hanging_break::HangingBreakEvent, hanging_break_by_entity::HangingBreakByEntityEvent, + hanging_place::HangingPlaceEvent, + }; + + match event_type { + EventType::HangingBreakEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + EventType::HangingBreakByEntityEvent => { + register_typed_event::( + resource, handler, priority, blocking, + ) + .await; + } + EventType::HangingPlaceEvent => { + register_typed_event::(resource, handler, priority, blocking).await; + } + _ => { + tracing::error!("non-hanging event should not be routed to register_hanging_event"); + } + } +} + impl DowncastResourceExt for Resource { fn downcast_ref<'a>(&'a self, state: &'a mut PluginHostState) -> &'a ContextResource { state @@ -673,6 +1664,7 @@ impl DowncastResourceExt for Resource { impl pumpkin::plugin::context::Host for PluginHostState {} impl pumpkin::plugin::context::HostContext for PluginHostState { + #[allow(clippy::too_many_lines)] async fn register_event( &mut self, context: Resource, @@ -709,9 +1701,15 @@ impl pumpkin::plugin::context::HostContext for PluginHostState { | EventType::ServerBroadcastEvent | EventType::ServerLoadEvent | EventType::ServerTickEndEvent - | EventType::ServerTickStartEvent) => { + | EventType::ServerTickStartEvent + | EventType::MapInitializeEvent) => { register_server_event(resource, &handler, priority, blocking, event_type).await; } + event_type @ (EventType::HangingBreakEvent + | EventType::HangingBreakByEntityEvent + | EventType::HangingPlaceEvent) => { + register_hanging_event(resource, &handler, priority, blocking, event_type).await; + } event_type @ (EventType::SpawnChangeEvent | EventType::ChunkLoadEvent | EventType::ChunkSaveEvent @@ -719,7 +1717,21 @@ impl pumpkin::plugin::context::HostContext for PluginHostState { | EventType::WeatherChangeEvent | EventType::ThunderChangeEvent | EventType::WorldLoadEvent - | EventType::WorldUnloadEvent) => { + | EventType::WorldUnloadEvent + | EventType::AsyncStructureGenerateEvent + | EventType::AsyncStructureSpawnEvent + | EventType::ChunkPopulateEvent + | EventType::ChunkUnloadEvent + | EventType::EntitiesLoadEvent + | EventType::EntitiesUnloadEvent + | EventType::GenericGameEvent + | EventType::LootGenerateEvent + | EventType::PortalCreateEvent + | EventType::StructureGrowEvent + | EventType::TimeSkipEvent + | EventType::WorldInitEvent + | EventType::WorldSaveEvent + | EventType::LightningStrikeEvent) => { register_world_event(resource, &handler, priority, blocking, event_type).await; } event_type @ (EventType::EntityDamageEvent @@ -743,7 +1755,62 @@ impl pumpkin::plugin::context::HostContext for PluginHostState { | EventType::EntityTargetEvent | EventType::EntityTeleportEvent | EventType::EntityToggleGlideEvent - | EventType::EntityTransformEvent) => { + | EventType::EntityTransformEvent + | EventType::CreatureSpawnEvent + | EventType::EnderDragonChangePhaseEvent + | EventType::EntityBreakDoorEvent + | EventType::EntityChangeBlockEvent + | EventType::EntityDamageByBlockEvent + | EventType::EntityDamageByEntityEvent + | EventType::EntityDropItemEvent + | EventType::EntityEnterBlockEvent + | EventType::EntityExhaustionEvent + | EventType::EntityInteractEvent + | EventType::EntityKnockbackEvent + | EventType::EntityPlaceEvent + | EventType::EntityPoseChangeEvent + | EventType::EntityPotionEffectEvent + | EventType::EntitySpellCastEvent + | EventType::EntityTargetLivingEntityEvent + | EventType::EntityToggleSwimEvent + | EventType::ExplosionPrimeEvent + | EventType::FireworkExplodeEvent + | EventType::FoodLevelChangeEvent + | EventType::ItemDespawnEvent + | EventType::ItemMergeEvent + | EventType::ItemSpawnEvent + | EventType::PiglinBarterEvent + | EventType::ProjectileHitEvent + | EventType::ProjectileLaunchEvent + | EventType::SheepDyeWoolEvent + | EventType::SheepRegrowWoolEvent + | EventType::SlimeSplitEvent + | EventType::StriderTemperatureChangeEvent + | EventType::VillagerAcquireTradeEvent + | EventType::VillagerCareerChangeEvent + | EventType::VillagerReplenishTradeEvent + | EventType::WardenAngerChangeEvent + | EventType::AreaEffectCloudApplyEvent + | EventType::ArrowBodyCountChangeEvent + | EventType::BatToggleSleepEvent + | EventType::CreeperPowerEvent + | EventType::EntityCombustByBlockEvent + | EventType::EntityCombustByEntityEvent + | EventType::EntityKnockbackByEntityEvent + | EventType::EntityPortalEnterEvent + | EventType::EntityPortalExitEvent + | EventType::EntityRemoveEvent + | EventType::EntityTargetBlockEvent + | EventType::EntityUnleashEvent + | EventType::ExpBottleEvent + | EventType::HorseJumpEvent + | EventType::LingeringPotionSplashEvent + | EventType::PigZapEvent + | EventType::PigZombieAngerEvent + | EventType::PotionSplashEvent + | EventType::SpawnerSpawnEvent + | EventType::TrialSpawnerSpawnEvent + | EventType::VillagerReputationChangeEvent) => { register_entity_event(resource, &handler, priority, blocking, event_type).await; } event_type @ (EventType::BlockRedstoneEvent @@ -765,19 +1832,79 @@ impl pumpkin::plugin::context::HostContext for PluginHostState { | EventType::NotePlayEvent | EventType::SignChangeEvent | EventType::SpongeAbsorbEvent - | EventType::TntPrimeEvent) => { + | EventType::TntPrimeEvent + | EventType::BellResonateEvent + | EventType::BellRingEvent + | EventType::BlockBrushEvent + | EventType::BlockCookEvent + | EventType::BlockDamageAbortEvent + | EventType::BlockDispenseArmorEvent + | EventType::BlockDispenseLootEvent + | EventType::BlockDropItemEvent + | EventType::BlockExpEvent + | EventType::BlockFertilizeEvent + | EventType::BlockMultiPlaceEvent + | EventType::BlockReceiveGameEvent + | EventType::BlockShearEntityEvent + | EventType::BlockSpreadEvent + | EventType::BrewingStartEvent + | EventType::CampfireStartEvent + | EventType::CauldronLevelChangeEvent + | EventType::CrafterCraftEvent + | EventType::EntityBlockFormEvent + | EventType::FluidLevelChangeEvent + | EventType::InventoryBlockStartEvent + | EventType::LeavesDecayEvent + | EventType::MoistureChangeEvent + | EventType::SculkBloomEvent + | EventType::VaultDisplayItemEvent) => { register_block_event(resource, &handler, priority, blocking, event_type).await; } event_type @ (EventType::InventoryOpenEvent | EventType::InventoryDragEvent | EventType::CraftItemEvent - | EventType::FurnaceSmeltEvent) => { + | EventType::FurnaceSmeltEvent + | EventType::BrewEvent + | EventType::BrewingStandFuelEvent + | EventType::FurnaceBurnEvent + | EventType::FurnaceExtractEvent + | EventType::FurnaceStartSmeltEvent + | EventType::HopperInventorySearchEvent + | EventType::InventoryCreativeEvent + | EventType::InventoryInteractEvent + | EventType::InventoryMoveItemEvent + | EventType::InventoryPickupItemEvent + | EventType::PrepareAnvilEvent + | EventType::PrepareGrindstoneEvent + | EventType::PrepareInventoryResultEvent + | EventType::PrepareItemCraftEvent + | EventType::PrepareSmithingEvent + | EventType::SmithItemEvent + | EventType::TradeSelectEvent) => { register_inventory_event(resource, &handler, priority, blocking, event_type).await; } event_type @ (EventType::PrepareItemEnchantEvent | EventType::EnchantItemEvent) => { register_enchantment_event(resource, &handler, priority, blocking, event_type) .await; } + event_type @ (EventType::VehicleBlockCollisionEvent + | EventType::VehicleCollisionEvent + | EventType::VehicleCreateEvent + | EventType::VehicleDamageEvent + | EventType::VehicleDestroyEvent + | EventType::VehicleEnterEvent + | EventType::VehicleEntityCollisionEvent + | EventType::VehicleExitEvent + | EventType::VehicleMoveEvent + | EventType::VehicleUpdateEvent) => { + register_vehicle_event(resource, &handler, priority, blocking, event_type).await; + } + event_type @ (EventType::RaidFinishEvent + | EventType::RaidSpawnWaveEvent + | EventType::RaidStopEvent + | EventType::RaidTriggerEvent) => { + register_raid_event(resource, &handler, priority, blocking, event_type).await; + } event_type => { register_player_event(resource, &handler, priority, blocking, event_type).await; } diff --git a/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/block.rs b/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/block.rs index 6c523cc88..b9315c63a 100644 --- a/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/block.rs +++ b/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/block.rs @@ -1,21 +1,53 @@ use pumpkin_data::BlockStateId; +use std::sync::Arc; +use tokio::sync::Mutex; use crate::plugin::{ block::{ + bell_resonate::BellResonateEvent, + bell_ring::BellRingEvent, block_break::BlockBreakEvent, + block_brush::BlockBrushEvent, block_burn::BlockBurnEvent, block_can_build::BlockCanBuildEvent, + block_cook::BlockCookEvent, + block_damage::BlockDamageEvent, + block_damage_abort::BlockDamageAbortEvent, block_dispense::BlockDispenseEvent, + block_dispense_armor::BlockDispenseArmorEvent, + block_dispense_loot::BlockDispenseLootEvent, + block_drop_item::BlockDropItemEvent, + block_exp::BlockExpEvent, block_explode::BlockExplodeEvent, + block_fade::BlockFadeEvent, + block_fertilize::BlockFertilizeEvent, + block_form::BlockFormEvent, + block_from_to::BlockFromToEvent, block_grow::BlockGrowEvent, + block_ignite::BlockIgniteEvent, + block_multi_place::BlockMultiPlaceEvent, block_physics::BlockPhysicsEvent, block_piston::{BlockPistonExtendEvent, BlockPistonRetractEvent}, block_place::BlockPlaceEvent, + block_receive_game::BlockReceiveGameEvent, block_redstone::BlockRedstoneEvent, + block_shear_entity::BlockShearEntityEvent, + block_spread::BlockSpreadEvent, + brewing_start::BrewingStartEvent, + campfire_start::CampfireStartEvent, + cauldron_level_change::CauldronLevelChangeEvent, + crafter_craft::CrafterCraftEvent, + entity_block_form::EntityBlockFormEvent, + fluid_level_change::FluidLevelChangeEvent, + inventory_block_start::InventoryBlockStartEvent, + leaves_decay::LeavesDecayEvent, + moisture_change::MoistureChangeEvent, note_play::NotePlayEvent, + sculk_bloom::SculkBloomEvent, sign_change::SignChangeEvent, sponge_absorb::SpongeAbsorbEvent, tnt_prime::TNTPrimeEvent, + vault_display_item::VaultDisplayItemEvent, }, loader::wasm::wasm_host::{ state::PluginHostState, @@ -25,12 +57,21 @@ use crate::plugin::{ from_wasm_block_position, to_wasm_block_name, to_wasm_block_position, }, pumpkin::plugin::event::{ - BlockBreakEventData, BlockBurnEventData, BlockCanBuildEventData, - BlockDamageEventData, BlockDispenseEventData, BlockExplodeEventData, - BlockFadeEventData, BlockFormEventData, BlockFromToEventData, BlockGrowEventData, - BlockIgniteEventData, BlockPhysicsEventData, BlockPistonExtendEventData, - BlockPistonRetractEventData, BlockPlaceEventData, BlockRedstoneEventData, Event, - NotePlayEventData, SignChangeEventData, SpongeAbsorbEventData, TntPrimeEventData, + BellResonateEventData, BellRingEventData, BlockBreakEventData, BlockBrushEventData, + BlockBurnEventData, BlockCanBuildEventData, BlockCookEventData, + BlockDamageAbortEventData, BlockDamageEventData, BlockDispenseArmorEventData, + BlockDispenseEventData, BlockDispenseLootEventData, BlockDropItemEventData, + BlockExpEventData, BlockExplodeEventData, BlockFadeEventData, + BlockFertilizeEventData, BlockFormEventData, BlockFromToEventData, + BlockGrowEventData, BlockIgniteEventData, BlockMultiPlaceEventData, + BlockPhysicsEventData, BlockPistonExtendEventData, BlockPistonRetractEventData, + BlockPlaceEventData, BlockReceiveGameEventData, BlockRedstoneEventData, + BlockShearEntityEventData, BlockSpreadEventData, BrewingStartEventData, + CampfireStartEventData, CauldronLevelChangeEventData, CrafterCraftEventData, + EntityBlockFormEventData, Event, FluidLevelChangeEventData, + InventoryBlockStartEventData, LeavesDecayEventData, MoistureChangeEventData, + NotePlayEventData, SculkBloomEventData, SignChangeEventData, SpongeAbsorbEventData, + TntPrimeEventData, VaultDisplayItemEventData, }, }, }, @@ -214,7 +255,7 @@ impl ToFromWasmEvent for BlockPlaceEvent { } } -impl ToFromWasmEvent for crate::plugin::api::events::block::block_damage::BlockDamageEvent { +impl ToFromWasmEvent for BlockDamageEvent { fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { let player = state .add_player(self.player.clone()) @@ -242,7 +283,7 @@ impl ToFromWasmEvent for crate::plugin::api::events::block::block_damage::BlockD } } -impl ToFromWasmEvent for crate::plugin::api::events::block::block_ignite::BlockIgniteEvent { +impl ToFromWasmEvent for BlockIgniteEvent { fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { Event::BlockIgniteEvent(BlockIgniteEventData { block_pos: to_wasm_block_position(self.block_pos), @@ -263,7 +304,7 @@ impl ToFromWasmEvent for crate::plugin::api::events::block::block_ignite::BlockI } } -impl ToFromWasmEvent for crate::plugin::api::events::block::block_from_to::BlockFromToEvent { +impl ToFromWasmEvent for BlockFromToEvent { fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { Event::BlockFromToEvent(BlockFromToEventData { from_pos: to_wasm_block_position(self.from_pos), @@ -285,7 +326,7 @@ impl ToFromWasmEvent for crate::plugin::api::events::block::block_from_to::Block } } -impl ToFromWasmEvent for crate::plugin::api::events::block::block_form::BlockFormEvent { +impl ToFromWasmEvent for BlockFormEvent { fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { Event::BlockFormEvent(BlockFormEventData { block_pos: to_wasm_block_position(self.block_pos), @@ -305,7 +346,7 @@ impl ToFromWasmEvent for crate::plugin::api::events::block::block_form::BlockFor } } -impl ToFromWasmEvent for crate::plugin::api::events::block::block_fade::BlockFadeEvent { +impl ToFromWasmEvent for BlockFadeEvent { fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { Event::BlockFadeEvent(BlockFadeEventData { block_pos: to_wasm_block_position(self.block_pos), @@ -518,3 +559,822 @@ impl ToFromWasmEvent for TNTPrimeEvent { } } } + +impl ToFromWasmEvent for BellResonateEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let target_world = state + .add_world(self.world.clone()) + .expect("failed to add world resource"); + Event::BellResonateEvent(BellResonateEventData { + block_pos: to_wasm_block_position(self.block_pos), + target_world, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::BellResonateEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::BellResonateEvent(data) => Self { + block_pos: from_wasm_block_position(data.block_pos), + world: consume_world(state, &data.target_world), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for BellRingEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let target_world = state + .add_world(self.world.clone()) + .expect("failed to add world resource"); + Event::BellRingEvent(BellRingEventData { + block_pos: to_wasm_block_position(self.block_pos), + target_world, + entity_id: self.entity.as_ref().map(|e| e.get_entity().entity_id), + direction: self.direction.map(|d| format!("{d:?}")), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::BellRingEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::BellRingEvent(_) => panic!("Cannot construct BellRingEvent from WASM"), + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for BlockBrushEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let target_world = state + .add_world(self.world.clone()) + .expect("failed to add world resource"); + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + let item = state + .add_item_stack(Arc::new(Mutex::new(self.item.clone()))) + .expect("failed to add item stack resource"); + Event::BlockBrushEvent(BlockBrushEventData { + block_pos: to_wasm_block_position(self.block_pos), + target_world, + player, + item, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::BlockBrushEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::BlockBrushEvent(_) => panic!("Cannot construct BlockBrushEvent from WASM"), + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for BlockCookEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let target_world = state + .add_world(self.world.clone()) + .expect("failed to add world resource"); + let source = state + .add_item_stack(Arc::new(Mutex::new(self.source.clone()))) + .expect("failed to add item stack resource"); + let result = state + .add_item_stack(Arc::new(Mutex::new(self.result.clone()))) + .expect("failed to add item stack resource"); + Event::BlockCookEvent(BlockCookEventData { + block_pos: to_wasm_block_position(self.block_pos), + target_world, + source, + result, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::BlockCookEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::BlockCookEvent(_) => panic!("Cannot construct BlockCookEvent from WASM"), + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for BlockDamageAbortEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + let target_world = state + .add_world(self.world.clone()) + .expect("failed to add world resource"); + let item_in_hand = state + .add_item_stack(Arc::new(Mutex::new(self.item_in_hand.clone()))) + .expect("failed to add item stack resource"); + Event::BlockDamageAbortEvent(BlockDamageAbortEventData { + player, + block_pos: to_wasm_block_position(self.block_pos), + target_world, + item_in_hand, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::BlockDamageAbortEvent(_) => { + panic!("Cannot construct BlockDamageAbortEvent from WASM") + } + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for BlockDispenseArmorEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let target_world = state + .add_world(self.world.clone()) + .expect("failed to add world resource"); + let item = state + .add_item_stack(Arc::new(Mutex::new(self.item.clone()))) + .expect("failed to add item stack resource"); + Event::BlockDispenseArmorEvent(BlockDispenseArmorEventData { + block_pos: to_wasm_block_position(self.block_pos), + target_world, + target_entity_id: self.target.get_entity().entity_id, + item, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::BlockDispenseArmorEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::BlockDispenseArmorEvent(_) => { + panic!("Cannot construct BlockDispenseArmorEvent from WASM") + } + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for BlockDispenseLootEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let target_world = state + .add_world(self.world.clone()) + .expect("failed to add world resource"); + let items = self + .items + .iter() + .map(|i| { + state + .add_item_stack(Arc::new(Mutex::new(i.clone()))) + .expect("failed to add item stack resource") + }) + .collect(); + Event::BlockDispenseLootEvent(BlockDispenseLootEventData { + block_pos: to_wasm_block_position(self.block_pos), + target_world, + items, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::BlockDispenseLootEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::BlockDispenseLootEvent(_) => { + panic!("Cannot construct BlockDispenseLootEvent from WASM") + } + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for BlockDropItemEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let target_world = state + .add_world(self.world.clone()) + .expect("failed to add world resource"); + let player = self.player.as_ref().map(|p| { + state + .add_player(p.clone()) + .expect("failed to add player resource") + }); + let items = self + .items + .iter() + .map(|i| { + state + .add_item_stack(Arc::new(Mutex::new(i.clone()))) + .expect("failed to add item stack resource") + }) + .collect(); + Event::BlockDropItemEvent(BlockDropItemEventData { + block_pos: to_wasm_block_position(self.block_pos), + target_world, + player, + items, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::BlockDropItemEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::BlockDropItemEvent(_) => panic!("Cannot construct BlockDropItemEvent from WASM"), + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for BlockExpEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let target_world = state + .add_world(self.world.clone()) + .expect("failed to add world resource"); + Event::BlockExpEvent(BlockExpEventData { + block_pos: to_wasm_block_position(self.block_pos), + target_world, + exp: self.exp, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::BlockExpEvent(data) = event { + self.exp = data.exp; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::BlockExpEvent(data) => Self { + block_pos: from_wasm_block_position(data.block_pos), + world: consume_world(state, &data.target_world), + exp: data.exp, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for BlockFertilizeEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let target_world = state + .add_world(self.world.clone()) + .expect("failed to add world resource"); + let player = self.player.as_ref().map(|p| { + state + .add_player(p.clone()) + .expect("failed to add player resource") + }); + let changed_blocks = self + .changed_blocks + .iter() + .map(|(pos, id)| (to_wasm_block_position(*pos), id.as_u16())) + .collect(); + Event::BlockFertilizeEvent(BlockFertilizeEventData { + block_pos: to_wasm_block_position(self.block_pos), + target_world, + player, + changed_blocks, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::BlockFertilizeEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::BlockFertilizeEvent(_) => { + panic!("Cannot construct BlockFertilizeEvent from WASM") + } + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for BlockMultiPlaceEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + let target_world = state + .add_world(self.world.clone()) + .expect("failed to add world resource"); + let placed_blocks = self + .placed_blocks + .iter() + .map(|(pos, id)| (to_wasm_block_position(*pos), id.as_u16())) + .collect(); + Event::BlockMultiPlaceEvent(BlockMultiPlaceEventData { + player, + target_world, + placed_blocks, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::BlockMultiPlaceEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::BlockMultiPlaceEvent(_) => { + panic!("Cannot construct BlockMultiPlaceEvent from WASM") + } + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for BlockReceiveGameEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let target_world = state + .add_world(self.world.clone()) + .expect("failed to add world resource"); + Event::BlockReceiveGameEvent(BlockReceiveGameEventData { + block_pos: to_wasm_block_position(self.block_pos), + target_world, + game_event: self.game_event.clone(), + source_entity_id: self + .source_entity + .as_ref() + .map(|e| e.get_entity().entity_id), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::BlockReceiveGameEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::BlockReceiveGameEvent(_) => { + panic!("Cannot construct BlockReceiveGameEvent from WASM") + } + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for BlockShearEntityEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let target_world = state + .add_world(self.world.clone()) + .expect("failed to add world resource"); + let item = state + .add_item_stack(Arc::new(Mutex::new(self.item.clone()))) + .expect("failed to add item stack resource"); + Event::BlockShearEntityEvent(BlockShearEntityEventData { + block_pos: to_wasm_block_position(self.block_pos), + target_world, + target_entity_id: self.target.get_entity().entity_id, + item, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::BlockShearEntityEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::BlockShearEntityEvent(_) => { + panic!("Cannot construct BlockShearEntityEvent from WASM") + } + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for BlockSpreadEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let target_world = state + .add_world(self.world.clone()) + .expect("failed to add world resource"); + Event::BlockSpreadEvent(BlockSpreadEventData { + source_pos: to_wasm_block_position(self.source_pos), + target_pos: to_wasm_block_position(self.target_pos), + target_world, + new_state_id: self.new_state_id.as_u16(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::BlockSpreadEvent(data) = event { + self.new_state_id = BlockStateId::new_or_air(data.new_state_id); + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::BlockSpreadEvent(data) => Self { + source_pos: from_wasm_block_position(data.source_pos), + target_pos: from_wasm_block_position(data.target_pos), + world: consume_world(state, &data.target_world), + new_state_id: BlockStateId::new_or_air(data.new_state_id), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for BrewingStartEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let target_world = state + .add_world(self.world.clone()) + .expect("failed to add world resource"); + Event::BrewingStartEvent(BrewingStartEventData { + block_pos: to_wasm_block_position(self.block_pos), + target_world, + brewing_time: self.brewing_time, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::BrewingStartEvent(data) = event { + self.brewing_time = data.brewing_time; + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::BrewingStartEvent(data) => Self { + block_pos: from_wasm_block_position(data.block_pos), + world: consume_world(state, &data.target_world), + brewing_time: data.brewing_time, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for CampfireStartEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let target_world = state + .add_world(self.world.clone()) + .expect("failed to add world resource"); + let item = state + .add_item_stack(Arc::new(Mutex::new(self.item.clone()))) + .expect("failed to add item stack resource"); + Event::CampfireStartEvent(CampfireStartEventData { + block_pos: to_wasm_block_position(self.block_pos), + target_world, + item, + slot: self.slot, + cooking_time: self.cooking_time, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::CampfireStartEvent(data) = event { + self.cooking_time = data.cooking_time; + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::CampfireStartEvent(_) => panic!("Cannot construct CampfireStartEvent from WASM"), + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for CauldronLevelChangeEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let target_world = state + .add_world(self.world.clone()) + .expect("failed to add world resource"); + Event::CauldronLevelChangeEvent(CauldronLevelChangeEventData { + block_pos: to_wasm_block_position(self.block_pos), + target_world, + old_level: self.old_level, + new_level: self.new_level, + reason: format!("{:?}", self.reason), + entity_id: self.entity.as_ref().map(|e| e.get_entity().entity_id), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::CauldronLevelChangeEvent(data) = event { + self.new_level = data.new_level; + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::CauldronLevelChangeEvent(_) => { + panic!("Cannot construct CauldronLevelChangeEvent from WASM") + } + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for CrafterCraftEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let target_world = state + .add_world(self.world.clone()) + .expect("failed to add world resource"); + let result = state + .add_item_stack(Arc::new(Mutex::new(self.result.clone()))) + .expect("failed to add item stack resource"); + Event::CrafterCraftEvent(CrafterCraftEventData { + block_pos: to_wasm_block_position(self.block_pos), + target_world, + result, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::CrafterCraftEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::CrafterCraftEvent(_) => panic!("Cannot construct CrafterCraftEvent from WASM"), + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for EntityBlockFormEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let target_world = state + .add_world(self.world.clone()) + .expect("failed to add world resource"); + Event::EntityBlockFormEvent(EntityBlockFormEventData { + entity_id: self.entity.get_entity().entity_id, + block_pos: to_wasm_block_position(self.block_pos), + target_world, + new_state_id: self.new_state_id.as_u16(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::EntityBlockFormEvent(data) = event { + self.new_state_id = BlockStateId::new_or_air(data.new_state_id); + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::EntityBlockFormEvent(_) => { + panic!("Cannot construct EntityBlockFormEvent from WASM") + } + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for FluidLevelChangeEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let target_world = state + .add_world(self.world.clone()) + .expect("failed to add world resource"); + Event::FluidLevelChangeEvent(FluidLevelChangeEventData { + block_pos: to_wasm_block_position(self.block_pos), + target_world, + new_state_id: self.new_state_id.as_u16(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::FluidLevelChangeEvent(data) = event { + self.new_state_id = BlockStateId::new_or_air(data.new_state_id); + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::FluidLevelChangeEvent(data) => Self { + block_pos: from_wasm_block_position(data.block_pos), + world: consume_world(state, &data.target_world), + new_state_id: BlockStateId::new_or_air(data.new_state_id), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for InventoryBlockStartEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let target_world = state + .add_world(self.world.clone()) + .expect("failed to add world resource"); + Event::InventoryBlockStartEvent(InventoryBlockStartEventData { + block_pos: to_wasm_block_position(self.block_pos), + target_world, + }) + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::InventoryBlockStartEvent(data) => Self { + block_pos: from_wasm_block_position(data.block_pos), + world: consume_world(state, &data.target_world), + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for LeavesDecayEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let target_world = state + .add_world(self.world.clone()) + .expect("failed to add world resource"); + Event::LeavesDecayEvent(LeavesDecayEventData { + block_pos: to_wasm_block_position(self.block_pos), + target_world, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::LeavesDecayEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::LeavesDecayEvent(data) => Self { + block_pos: from_wasm_block_position(data.block_pos), + world: consume_world(state, &data.target_world), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for MoistureChangeEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let target_world = state + .add_world(self.world.clone()) + .expect("failed to add world resource"); + Event::MoistureChangeEvent(MoistureChangeEventData { + block_pos: to_wasm_block_position(self.block_pos), + target_world, + new_moisture: self.new_moisture, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::MoistureChangeEvent(data) = event { + self.new_moisture = data.new_moisture; + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::MoistureChangeEvent(data) => Self { + block_pos: from_wasm_block_position(data.block_pos), + world: consume_world(state, &data.target_world), + new_moisture: data.new_moisture, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for SculkBloomEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let target_world = state + .add_world(self.world.clone()) + .expect("failed to add world resource"); + Event::SculkBloomEvent(SculkBloomEventData { + block_pos: to_wasm_block_position(self.block_pos), + target_world, + charge: self.charge, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::SculkBloomEvent(data) = event { + self.charge = data.charge; + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::SculkBloomEvent(data) => Self { + block_pos: from_wasm_block_position(data.block_pos), + world: consume_world(state, &data.target_world), + charge: data.charge, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for VaultDisplayItemEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let target_world = state + .add_world(self.world.clone()) + .expect("failed to add world resource"); + let item = state + .add_item_stack(Arc::new(Mutex::new(self.item.clone()))) + .expect("failed to add item stack resource"); + Event::VaultDisplayItemEvent(VaultDisplayItemEventData { + block_pos: to_wasm_block_position(self.block_pos), + target_world, + item, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::VaultDisplayItemEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::VaultDisplayItemEvent(_) => { + panic!("Cannot construct VaultDisplayItemEvent from WASM") + } + _ => panic!("unexpected event type"), + } + } +} diff --git a/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/entity.rs b/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/entity.rs index fdead9cf7..788232e74 100644 --- a/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/entity.rs +++ b/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/entity.rs @@ -1,27 +1,107 @@ +use std::sync::Arc; +use tokio::sync::Mutex; + use crate::plugin::{ entity::{ + area_effect_cloud_apply::AreaEffectCloudApplyEvent, + arrow_body_count_change::ArrowBodyCountChangeEvent, + bat_toggle_sleep::BatToggleSleepEvent, + creature_spawn::CreatureSpawnEvent, + creeper_power::CreeperPowerEvent, + ender_dragon_change_phase::EnderDragonChangePhaseEvent, + entity_break_door::EntityBreakDoorEvent, + entity_change_block::EntityChangeBlockEvent, entity_combust::EntityCombustEvent, + entity_combust_by_block::EntityCombustByBlockEvent, + entity_combust_by_entity::EntityCombustByEntityEvent, entity_damage::EntityDamageEvent, + entity_damage_by_block::EntityDamageByBlockEvent, + entity_damage_by_entity::EntityDamageByEntityEvent, entity_death::{EntityDeathEvent, PlayerDeathEvent}, + entity_drop_item::EntityDropItemEvent, + entity_enter_block::EntityEnterBlockEvent, + entity_exhaustion::EntityExhaustionEvent, + entity_interact::EntityInteractEvent, + entity_knockback::EntityKnockbackEvent, + entity_knockback_by_entity::EntityKnockbackByEntityEvent, + entity_place::EntityPlaceEvent, + entity_portal_enter::EntityPortalEnterEvent, + entity_portal_exit::EntityPortalExitEvent, + entity_pose_change::EntityPoseChangeEvent, + entity_potion_effect::EntityPotionEffectEvent, entity_regain_health::EntityRegainHealthEvent, + entity_remove::EntityRemoveEvent, entity_spawn::EntitySpawnEvent, + entity_spell_cast::EntitySpellCastEvent, + entity_target_block::EntityTargetBlockEvent, + entity_target_living_entity::EntityTargetLivingEntityEvent, + entity_toggle_swim::EntityToggleSwimEvent, + entity_unleash::EntityUnleashEvent, + exp_bottle::ExpBottleEvent, + explosion_prime::ExplosionPrimeEvent, + firework_explode::FireworkExplodeEvent, + food_level_change::FoodLevelChangeEvent, + horse_jump::HorseJumpEvent, + item_despawn::ItemDespawnEvent, + item_merge::ItemMergeEvent, + item_spawn::ItemSpawnEvent, + lingering_potion_splash::LingeringPotionSplashEvent, + pig_zap::PigZapEvent, + pig_zombie_anger::PigZombieAngerEvent, + piglin_barter::PiglinBarterEvent, + potion_splash::PotionSplashEvent, + projectile_hit::ProjectileHitEvent, + projectile_launch::ProjectileLaunchEvent, + sheep_dye_wool::SheepDyeWoolEvent, + sheep_regrow_wool::SheepRegrowWoolEvent, + slime_split::SlimeSplitEvent, + spawner_spawn::SpawnerSpawnEvent, + strider_temperature_change::StriderTemperatureChangeEvent, + trial_spawner_spawn::TrialSpawnerSpawnEvent, + villager_acquire_trade::VillagerAcquireTradeEvent, + villager_career_change::VillagerCareerChangeEvent, + villager_replenish_trade::VillagerReplenishTradeEvent, + villager_reputation_change::VillagerReputationChangeEvent, + warden_anger_change::WardenAngerChangeEvent, }, loader::wasm::wasm_host::{ state::PluginHostState, wit::v0_1::{ events::{ ToFromWasmEvent, consume_player, consume_text_component, consume_world, - from_wasm_block_position, to_wasm_block_position, to_wasm_position, + from_wasm_block_position, from_wasm_position, to_wasm_block_position, + to_wasm_position, }, pumpkin::plugin::event::{ - EntityAirChangeEventData, EntityBreedEventData, EntityCombustEventData, - EntityDamageEventData, EntityDeathEventData, EntityDismountEventData, - EntityDyeEventData, EntityEnterLoveModeEventData, EntityExplodeEventData, - EntityMountEventData, EntityPickupItemEventData, EntityPortalEventData, - EntityRegainHealthEventData, EntityResurrectEventData, EntityShootBowEventData, - EntitySpawnEventData, EntityTameEventData, EntityTargetEventData, - EntityTeleportEventData, EntityToggleGlideEventData, EntityTransformEventData, - Event, PlayerDeathEventData, + AreaEffectCloudApplyEventData, ArrowBodyCountChangeEventData, + BatToggleSleepEventData, CreatureSpawnEventData, CreeperPowerEventData, + EnderDragonChangePhaseEventData, EntityAirChangeEventData, + EntityBreakDoorEventData, EntityBreedEventData, EntityChangeBlockEventData, + EntityCombustByBlockEventData, EntityCombustByEntityEventData, + EntityCombustEventData, EntityDamageByBlockEventData, + EntityDamageByEntityEventData, EntityDamageEventData, EntityDeathEventData, + EntityDismountEventData, EntityDropItemEventData, EntityDyeEventData, + EntityEnterBlockEventData, EntityEnterLoveModeEventData, EntityExhaustionEventData, + EntityExplodeEventData, EntityInteractEventData, EntityKnockbackByEntityEventData, + EntityKnockbackEventData, EntityMountEventData, EntityPickupItemEventData, + EntityPlaceEventData, EntityPortalEnterEventData, EntityPortalEventData, + EntityPortalExitEventData, EntityPoseChangeEventData, EntityPotionEffectEventData, + EntityRegainHealthEventData, EntityRemoveEventData, EntityResurrectEventData, + EntityShootBowEventData, EntitySpawnEventData, EntitySpellCastEventData, + EntityTameEventData, EntityTargetBlockEventData, EntityTargetEventData, + EntityTargetLivingEntityEventData, EntityTeleportEventData, + EntityToggleGlideEventData, EntityToggleSwimEventData, EntityTransformEventData, + EntityUnleashEventData, Event, ExpBottleEventData, ExplosionPrimeEventData, + FireworkExplodeEventData, FoodLevelChangeEventData, HorseJumpEventData, + ItemDespawnEventData, ItemMergeEventData, ItemSpawnEventData, + LingeringPotionSplashEventData, PigZapEventData, PigZombieAngerEventData, + PiglinBarterEventData, PlayerDeathEventData, PotionSplashEventData, + ProjectileHitEventData, ProjectileLaunchEventData, SheepDyeWoolEventData, + SheepRegrowWoolEventData, SlimeSplitEventData, SpawnerSpawnEventData, + StriderTemperatureChangeEventData, TrialSpawnerSpawnEventData, + VillagerAcquireTradeEventData, VillagerCareerChangeEventData, + VillagerReplenishTradeEventData, VillagerReputationChangeEventData, + WardenAngerChangeEventData, }, }, }, @@ -559,3 +639,1606 @@ impl ToFromWasmEvent } } } + +impl ToFromWasmEvent for CreatureSpawnEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let target_world = state + .add_world(self.world.clone()) + .expect("failed to add world resource"); + Event::CreatureSpawnEvent(CreatureSpawnEventData { + entity_id: self.entity_id, + entity_type: self.entity_type.clone(), + position: to_wasm_position(self.position), + target_world, + spawn_reason: self.spawn_reason.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::CreatureSpawnEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::CreatureSpawnEvent(data) => Self { + entity_id: data.entity_id, + entity_type: data.entity_type, + position: from_wasm_position(data.position), + world: consume_world(state, &data.target_world), + spawn_reason: data.spawn_reason, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for EnderDragonChangePhaseEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::EnderDragonChangePhaseEvent(EnderDragonChangePhaseEventData { + entity_id: self.entity_id, + current_phase: self.current_phase.clone(), + new_phase: self.new_phase.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::EnderDragonChangePhaseEvent(data) = event { + self.cancelled = data.cancelled; + self.new_phase = data.new_phase; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::EnderDragonChangePhaseEvent(data) => Self { + entity_id: data.entity_id, + current_phase: data.current_phase, + new_phase: data.new_phase, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for EntityBreakDoorEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::EntityBreakDoorEvent(EntityBreakDoorEventData { + entity_id: self.entity_id, + block_pos: to_wasm_block_position(self.block_pos), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::EntityBreakDoorEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::EntityBreakDoorEvent(data) => Self { + entity_id: data.entity_id, + block_pos: from_wasm_block_position(data.block_pos), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for EntityChangeBlockEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::EntityChangeBlockEvent(EntityChangeBlockEventData { + entity_id: self.entity_id, + block_pos: to_wasm_block_position(self.block_pos), + new_block: self.new_block.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::EntityChangeBlockEvent(data) = event { + self.cancelled = data.cancelled; + self.new_block = data.new_block; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::EntityChangeBlockEvent(data) => Self { + entity_id: data.entity_id, + block_pos: from_wasm_block_position(data.block_pos), + new_block: data.new_block, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for EntityDamageByBlockEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::EntityDamageByBlockEvent(EntityDamageByBlockEventData { + entity_id: self.entity_id, + damager_pos: self.damager_pos.map(to_wasm_block_position), + damage: self.damage, + cause: self.cause.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::EntityDamageByBlockEvent(data) = event { + self.cancelled = data.cancelled; + self.damage = data.damage; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::EntityDamageByBlockEvent(data) => Self { + entity_id: data.entity_id, + damager_pos: data.damager_pos.map(from_wasm_block_position), + damage: data.damage, + cause: data.cause, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for EntityDamageByEntityEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::EntityDamageByEntityEvent(EntityDamageByEntityEventData { + entity_id: self.entity_id, + damager_id: self.damager_id, + damage: self.damage, + cause: self.cause.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::EntityDamageByEntityEvent(data) = event { + self.cancelled = data.cancelled; + self.damage = data.damage; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::EntityDamageByEntityEvent(data) => Self { + entity_id: data.entity_id, + damager_id: data.damager_id, + damage: data.damage, + cause: data.cause, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for EntityDropItemEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::EntityDropItemEvent(EntityDropItemEventData { + entity_id: self.entity_id, + item_name: self.item_name.clone(), + count: self.count, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::EntityDropItemEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::EntityDropItemEvent(data) => Self { + entity_id: data.entity_id, + item_name: data.item_name, + count: data.count, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for EntityEnterBlockEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::EntityEnterBlockEvent(EntityEnterBlockEventData { + entity_id: self.entity_id, + block_pos: to_wasm_block_position(self.block_pos), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::EntityEnterBlockEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::EntityEnterBlockEvent(data) => Self { + entity_id: data.entity_id, + block_pos: from_wasm_block_position(data.block_pos), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for EntityExhaustionEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::EntityExhaustionEvent(EntityExhaustionEventData { + entity_id: self.entity_id, + exhaustion: self.exhaustion, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::EntityExhaustionEvent(data) = event { + self.cancelled = data.cancelled; + self.exhaustion = data.exhaustion; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::EntityExhaustionEvent(data) => Self { + entity_id: data.entity_id, + exhaustion: data.exhaustion, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for EntityInteractEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::EntityInteractEvent(EntityInteractEventData { + entity_id: self.entity_id, + block_pos: to_wasm_block_position(self.block_pos), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::EntityInteractEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::EntityInteractEvent(data) => Self { + entity_id: data.entity_id, + block_pos: from_wasm_block_position(data.block_pos), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for EntityKnockbackEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::EntityKnockbackEvent(EntityKnockbackEventData { + entity_id: self.entity_id, + hit_by_id: self.hit_by_id, + knockback: to_wasm_position(self.knockback), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::EntityKnockbackEvent(data) = event { + self.cancelled = data.cancelled; + self.knockback = from_wasm_position(data.knockback); + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::EntityKnockbackEvent(data) => Self { + entity_id: data.entity_id, + hit_by_id: data.hit_by_id, + knockback: from_wasm_position(data.knockback), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for EntityPlaceEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::EntityPlaceEvent(EntityPlaceEventData { + entity_id: self.entity_id, + block_pos: to_wasm_block_position(self.block_pos), + block_name: self.block_name.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::EntityPlaceEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::EntityPlaceEvent(data) => Self { + entity_id: data.entity_id, + block_pos: from_wasm_block_position(data.block_pos), + block_name: data.block_name, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for EntityPoseChangeEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::EntityPoseChangeEvent(EntityPoseChangeEventData { + entity_id: self.entity_id, + pose: self.pose.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::EntityPoseChangeEvent(data) = event { + self.cancelled = data.cancelled; + self.pose = data.pose; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::EntityPoseChangeEvent(data) => Self { + entity_id: data.entity_id, + pose: data.pose, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for EntityPotionEffectEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::EntityPotionEffectEvent(EntityPotionEffectEventData { + entity_id: self.entity_id, + effect_name: self.effect_name.clone(), + duration: self.duration, + amplifier: self.amplifier, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::EntityPotionEffectEvent(data) = event { + self.cancelled = data.cancelled; + self.duration = data.duration; + self.amplifier = data.amplifier; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::EntityPotionEffectEvent(data) => Self { + entity_id: data.entity_id, + effect_name: data.effect_name, + duration: data.duration, + amplifier: data.amplifier, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for EntitySpellCastEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::EntitySpellCastEvent(EntitySpellCastEventData { + entity_id: self.entity_id, + spell: self.spell.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::EntitySpellCastEvent(data) = event { + self.cancelled = data.cancelled; + self.spell = data.spell; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::EntitySpellCastEvent(data) => Self { + entity_id: data.entity_id, + spell: data.spell, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for EntityTargetLivingEntityEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::EntityTargetLivingEntityEvent(EntityTargetLivingEntityEventData { + entity_id: self.entity_id, + target_id: self.target_id, + reason: self.reason.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::EntityTargetLivingEntityEvent(data) = event { + self.cancelled = data.cancelled; + self.target_id = data.target_id; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::EntityTargetLivingEntityEvent(data) => Self { + entity_id: data.entity_id, + target_id: data.target_id, + reason: data.reason, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for EntityToggleSwimEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::EntityToggleSwimEvent(EntityToggleSwimEventData { + entity_id: self.entity_id, + is_swimming: self.is_swimming, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::EntityToggleSwimEvent(data) = event { + self.cancelled = data.cancelled; + self.is_swimming = data.is_swimming; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::EntityToggleSwimEvent(data) => Self { + entity_id: data.entity_id, + is_swimming: data.is_swimming, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for ExplosionPrimeEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::ExplosionPrimeEvent(ExplosionPrimeEventData { + entity_id: self.entity_id, + radius: self.radius, + fire: self.fire, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::ExplosionPrimeEvent(data) = event { + self.cancelled = data.cancelled; + self.radius = data.radius; + self.fire = data.fire; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::ExplosionPrimeEvent(data) => Self { + entity_id: data.entity_id, + radius: data.radius, + fire: data.fire, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for FireworkExplodeEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::FireworkExplodeEvent(FireworkExplodeEventData { + entity_id: self.entity_id, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::FireworkExplodeEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::FireworkExplodeEvent(data) => Self { + entity_id: data.entity_id, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for FoodLevelChangeEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::FoodLevelChangeEvent(FoodLevelChangeEventData { + entity_id: self.entity_id, + food_level: self.food_level, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::FoodLevelChangeEvent(data) = event { + self.cancelled = data.cancelled; + self.food_level = data.food_level; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::FoodLevelChangeEvent(data) => Self { + entity_id: data.entity_id, + food_level: data.food_level, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for ItemDespawnEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::ItemDespawnEvent(ItemDespawnEventData { + entity_id: self.entity_id, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::ItemDespawnEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::ItemDespawnEvent(data) => Self { + entity_id: data.entity_id, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for ItemMergeEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::ItemMergeEvent(ItemMergeEventData { + entity_id: self.entity_id, + target_id: self.target_id, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::ItemMergeEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::ItemMergeEvent(data) => Self { + entity_id: data.entity_id, + target_id: data.target_id, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for ItemSpawnEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::ItemSpawnEvent(ItemSpawnEventData { + entity_id: self.entity_id, + position: to_wasm_position(self.position), + item_name: self.item_name.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::ItemSpawnEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::ItemSpawnEvent(data) => Self { + entity_id: data.entity_id, + position: from_wasm_position(data.position), + item_name: data.item_name, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PiglinBarterEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let input_item = state + .add_item_stack(Arc::new(Mutex::new(self.input_item.clone()))) + .expect("failed to add item stack resource"); + let outcome = self + .outcome + .iter() + .map(|i| { + state + .add_item_stack(Arc::new(Mutex::new(i.clone()))) + .expect("failed to add item stack resource") + }) + .collect(); + Event::PiglinBarterEvent(PiglinBarterEventData { + entity_id: self.entity_id, + input_item, + outcome, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PiglinBarterEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::PiglinBarterEvent(_) => panic!("Cannot construct PiglinBarterEvent from WASM"), + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for ProjectileHitEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::ProjectileHitEvent(ProjectileHitEventData { + entity_id: self.entity_id, + hit_position: to_wasm_position(self.hit_position), + hit_entity_id: self.hit_entity_id, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::ProjectileHitEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::ProjectileHitEvent(data) => Self { + entity_id: data.entity_id, + hit_position: from_wasm_position(data.hit_position), + hit_entity_id: data.hit_entity_id, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for ProjectileLaunchEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::ProjectileLaunchEvent(ProjectileLaunchEventData { + entity_id: self.entity_id, + shooter_id: self.shooter_id, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::ProjectileLaunchEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::ProjectileLaunchEvent(data) => Self { + entity_id: data.entity_id, + shooter_id: data.shooter_id, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for SheepDyeWoolEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::SheepDyeWoolEvent(SheepDyeWoolEventData { + entity_id: self.entity_id, + dye_color: self.dye_color, + player_id: self.player_id, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::SheepDyeWoolEvent(data) = event { + self.cancelled = data.cancelled; + self.dye_color = data.dye_color; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::SheepDyeWoolEvent(data) => Self { + entity_id: data.entity_id, + dye_color: data.dye_color, + player_id: data.player_id, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for SheepRegrowWoolEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::SheepRegrowWoolEvent(SheepRegrowWoolEventData { + entity_id: self.entity_id, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::SheepRegrowWoolEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::SheepRegrowWoolEvent(data) => Self { + entity_id: data.entity_id, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for SlimeSplitEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::SlimeSplitEvent(SlimeSplitEventData { + entity_id: self.entity_id, + count: self.count, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::SlimeSplitEvent(data) = event { + self.cancelled = data.cancelled; + self.count = data.count; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::SlimeSplitEvent(data) => Self { + entity_id: data.entity_id, + count: data.count, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for StriderTemperatureChangeEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::StriderTemperatureChangeEvent(StriderTemperatureChangeEventData { + entity_id: self.entity_id, + is_shivering: self.is_shivering, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::StriderTemperatureChangeEvent(data) = event { + self.cancelled = data.cancelled; + self.is_shivering = data.is_shivering; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::StriderTemperatureChangeEvent(data) => Self { + entity_id: data.entity_id, + is_shivering: data.is_shivering, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for VillagerAcquireTradeEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::VillagerAcquireTradeEvent(VillagerAcquireTradeEventData { + entity_id: self.entity_id, + recipe_index: self.recipe_index, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::VillagerAcquireTradeEvent(data) = event { + self.cancelled = data.cancelled; + self.recipe_index = data.recipe_index; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::VillagerAcquireTradeEvent(data) => Self { + entity_id: data.entity_id, + recipe_index: data.recipe_index, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for VillagerCareerChangeEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::VillagerCareerChangeEvent(VillagerCareerChangeEventData { + entity_id: self.entity_id, + profession: self.profession.clone(), + reason: self.reason.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::VillagerCareerChangeEvent(data) = event { + self.cancelled = data.cancelled; + self.profession = data.profession; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::VillagerCareerChangeEvent(data) => Self { + entity_id: data.entity_id, + profession: data.profession, + reason: data.reason, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for VillagerReplenishTradeEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::VillagerReplenishTradeEvent(VillagerReplenishTradeEventData { + entity_id: self.entity_id, + restock_quantity: self.restock_quantity, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::VillagerReplenishTradeEvent(data) = event { + self.cancelled = data.cancelled; + self.restock_quantity = data.restock_quantity; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::VillagerReplenishTradeEvent(data) => Self { + entity_id: data.entity_id, + restock_quantity: data.restock_quantity, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for WardenAngerChangeEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::WardenAngerChangeEvent(WardenAngerChangeEventData { + entity_id: self.entity_id, + target_id: self.target_id, + old_anger: self.old_anger, + new_anger: self.new_anger, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::WardenAngerChangeEvent(data) = event { + self.cancelled = data.cancelled; + self.new_anger = data.new_anger; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::WardenAngerChangeEvent(data) => Self { + entity_id: data.entity_id, + target_id: data.target_id, + old_anger: data.old_anger, + new_anger: data.new_anger, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for AreaEffectCloudApplyEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::AreaEffectCloudApplyEvent(AreaEffectCloudApplyEventData { + entity_id: self.entity_id, + affected_entities: self.affected_entities.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::AreaEffectCloudApplyEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::AreaEffectCloudApplyEvent(data) => Self { + entity_id: data.entity_id, + affected_entities: data.affected_entities, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for ArrowBodyCountChangeEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::ArrowBodyCountChangeEvent(ArrowBodyCountChangeEventData { + entity_id: self.entity_id, + old_amount: self.old_amount, + new_amount: self.new_amount, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::ArrowBodyCountChangeEvent(data) = event { + self.cancelled = data.cancelled; + self.new_amount = data.new_amount; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::ArrowBodyCountChangeEvent(data) => Self { + entity_id: data.entity_id, + old_amount: data.old_amount, + new_amount: data.new_amount, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for BatToggleSleepEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::BatToggleSleepEvent(BatToggleSleepEventData { + entity_id: self.entity_id, + is_awake: self.is_awake, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::BatToggleSleepEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::BatToggleSleepEvent(data) => Self { + entity_id: data.entity_id, + is_awake: data.is_awake, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for CreeperPowerEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::CreeperPowerEvent(CreeperPowerEventData { + entity_id: self.entity_id, + lightning_id: self.lightning_id, + cause: self.cause.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::CreeperPowerEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::CreeperPowerEvent(data) => Self { + entity_id: data.entity_id, + lightning_id: data.lightning_id, + cause: data.cause, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for EntityCombustByBlockEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::EntityCombustByBlockEvent(EntityCombustByBlockEventData { + entity_id: self.entity_id, + combuster: to_wasm_block_position(self.combuster), + duration: self.duration, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::EntityCombustByBlockEvent(data) = event { + self.cancelled = data.cancelled; + self.duration = data.duration; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::EntityCombustByBlockEvent(data) => Self { + entity_id: data.entity_id, + combuster: from_wasm_block_position(data.combuster), + duration: data.duration, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for EntityCombustByEntityEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::EntityCombustByEntityEvent(EntityCombustByEntityEventData { + entity_id: self.entity_id, + combuster_id: self.combuster_id, + duration: self.duration, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::EntityCombustByEntityEvent(data) = event { + self.cancelled = data.cancelled; + self.duration = data.duration; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::EntityCombustByEntityEvent(data) => Self { + entity_id: data.entity_id, + combuster_id: data.combuster_id, + duration: data.duration, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for EntityKnockbackByEntityEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::EntityKnockbackByEntityEvent(EntityKnockbackByEntityEventData { + entity_id: self.entity_id, + hit_by_id: self.hit_by_id, + force: self.force, + x: self.x, + z: self.z, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::EntityKnockbackByEntityEvent(data) = event { + self.cancelled = data.cancelled; + self.force = data.force; + self.x = data.x; + self.z = data.z; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::EntityKnockbackByEntityEvent(data) => Self { + entity_id: data.entity_id, + hit_by_id: data.hit_by_id, + force: data.force, + x: data.x, + z: data.z, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for EntityPortalEnterEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::EntityPortalEnterEvent(EntityPortalEnterEventData { + entity_id: self.entity_id, + location: to_wasm_block_position(self.location), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::EntityPortalEnterEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::EntityPortalEnterEvent(data) => Self { + entity_id: data.entity_id, + location: from_wasm_block_position(data.location), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for EntityPortalExitEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::EntityPortalExitEvent(EntityPortalExitEventData { + entity_id: self.entity_id, + from_pos: to_wasm_block_position(self.from_pos), + to_pos: self.to_pos.map(to_wasm_block_position), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::EntityPortalExitEvent(data) = event { + self.cancelled = data.cancelled; + self.to_pos = data.to_pos.map(from_wasm_block_position); + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::EntityPortalExitEvent(data) => Self { + entity_id: data.entity_id, + from_pos: from_wasm_block_position(data.from_pos), + to_pos: data.to_pos.map(from_wasm_block_position), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for EntityRemoveEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::EntityRemoveEvent(EntityRemoveEventData { + entity_id: self.entity_id, + cause: self.cause.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::EntityRemoveEvent(data) = event { + self.cancelled = data.cancelled; + self.cause = data.cause; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::EntityRemoveEvent(data) => Self { + entity_id: data.entity_id, + cause: data.cause, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for EntityTargetBlockEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::EntityTargetBlockEvent(EntityTargetBlockEventData { + entity_id: self.entity_id, + block_pos: to_wasm_block_position(self.block_pos), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::EntityTargetBlockEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::EntityTargetBlockEvent(data) => Self { + entity_id: data.entity_id, + block_pos: from_wasm_block_position(data.block_pos), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for EntityUnleashEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::EntityUnleashEvent(EntityUnleashEventData { + entity_id: self.entity_id, + reason: self.reason.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::EntityUnleashEvent(data) = event { + self.cancelled = data.cancelled; + self.reason = data.reason; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::EntityUnleashEvent(data) => Self { + entity_id: data.entity_id, + reason: data.reason, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for ExpBottleEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::ExpBottleEvent(ExpBottleEventData { + entity_id: self.entity_id, + experience: self.experience, + location: to_wasm_block_position(self.location), + show_effect: self.show_effect, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::ExpBottleEvent(data) = event { + self.cancelled = data.cancelled; + self.experience = data.experience; + self.show_effect = data.show_effect; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::ExpBottleEvent(data) => Self { + entity_id: data.entity_id, + experience: data.experience, + location: from_wasm_block_position(data.location), + show_effect: data.show_effect, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for HorseJumpEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::HorseJumpEvent(HorseJumpEventData { + entity_id: self.entity_id, + power: self.power, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::HorseJumpEvent(data) = event { + self.cancelled = data.cancelled; + self.power = data.power; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::HorseJumpEvent(data) => Self { + entity_id: data.entity_id, + power: data.power, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for LingeringPotionSplashEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::LingeringPotionSplashEvent(LingeringPotionSplashEventData { + entity_id: self.entity_id, + location: to_wasm_block_position(self.location), + potion_item: self.potion_item.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::LingeringPotionSplashEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::LingeringPotionSplashEvent(data) => Self { + entity_id: data.entity_id, + location: from_wasm_block_position(data.location), + potion_item: data.potion_item, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PigZapEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::PigZapEvent(PigZapEventData { + entity_id: self.entity_id, + lightning_id: self.lightning_id, + pig_zombie_id: self.pig_zombie_id, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PigZapEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::PigZapEvent(data) => Self { + entity_id: data.entity_id, + lightning_id: data.lightning_id, + pig_zombie_id: data.pig_zombie_id, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PigZombieAngerEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::PigZombieAngerEvent(PigZombieAngerEventData { + entity_id: self.entity_id, + target_id: self.target_id, + new_anger: self.new_anger, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PigZombieAngerEvent(data) = event { + self.cancelled = data.cancelled; + self.new_anger = data.new_anger; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::PigZombieAngerEvent(data) => Self { + entity_id: data.entity_id, + target_id: data.target_id, + new_anger: data.new_anger, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PotionSplashEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::PotionSplashEvent(PotionSplashEventData { + entity_id: self.entity_id, + location: to_wasm_block_position(self.location), + potion_item: self.potion_item.clone(), + affected_entities: self.affected_entities.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PotionSplashEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::PotionSplashEvent(data) => Self { + entity_id: data.entity_id, + location: from_wasm_block_position(data.location), + potion_item: data.potion_item, + affected_entities: data.affected_entities, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for SpawnerSpawnEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::SpawnerSpawnEvent(SpawnerSpawnEventData { + entity_id: self.entity_id, + spawner_pos: to_wasm_block_position(self.spawner_pos), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::SpawnerSpawnEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::SpawnerSpawnEvent(data) => Self { + entity_id: data.entity_id, + spawner_pos: from_wasm_block_position(data.spawner_pos), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for TrialSpawnerSpawnEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::TrialSpawnerSpawnEvent(TrialSpawnerSpawnEventData { + entity_id: self.entity_id, + spawner_pos: to_wasm_block_position(self.spawner_pos), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::TrialSpawnerSpawnEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::TrialSpawnerSpawnEvent(data) => Self { + entity_id: data.entity_id, + spawner_pos: from_wasm_block_position(data.spawner_pos), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for VillagerReputationChangeEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::VillagerReputationChangeEvent(VillagerReputationChangeEventData { + entity_id: self.entity_id, + target_id: self.target_id, + reputation_change: self.reputation_change, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::VillagerReputationChangeEvent(data) = event { + self.cancelled = data.cancelled; + self.reputation_change = data.reputation_change; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::VillagerReputationChangeEvent(data) => Self { + entity_id: data.entity_id, + target_id: data.target_id, + reputation_change: data.reputation_change, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} diff --git a/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/hanging.rs b/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/hanging.rs new file mode 100644 index 000000000..ca3c1ee07 --- /dev/null +++ b/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/hanging.rs @@ -0,0 +1,98 @@ +use crate::plugin::{ + hanging::{ + hanging_break::HangingBreakEvent, hanging_break_by_entity::HangingBreakByEntityEvent, + hanging_place::HangingPlaceEvent, + }, + loader::wasm::wasm_host::{ + state::PluginHostState, + wit::v0_1::{ + events::{ToFromWasmEvent, to_wasm_block_position}, + pumpkin::plugin::event::{ + Event, HangingBreakByEntityEventData, HangingBreakEventData, HangingPlaceEventData, + }, + }, + }, +}; + +impl ToFromWasmEvent for HangingBreakEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::HangingBreakEvent(HangingBreakEventData { + entity_id: self.entity.get_entity().entity_id, + remover_entity_id: self.remover.as_ref().map(|r| r.get_entity().entity_id), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::HangingBreakEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::HangingBreakEvent(_) => { + panic!("Cannot construct HangingBreakEvent from WASM event data alone"); + } + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for HangingBreakByEntityEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::HangingBreakByEntityEvent(HangingBreakByEntityEventData { + entity_id: self.entity.get_entity().entity_id, + remover_entity_id: self.remover.get_entity().entity_id, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::HangingBreakByEntityEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::HangingBreakByEntityEvent(_) => { + panic!("Cannot construct HangingBreakByEntityEvent from WASM event data alone"); + } + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for HangingPlaceEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = self.player.as_ref().map(|p| { + state + .add_player(p.clone()) + .expect("failed to add player resource") + }); + + Event::HangingPlaceEvent(HangingPlaceEventData { + entity_id: self.entity.get_entity().entity_id, + player, + block_pos: to_wasm_block_position(self.block_pos), + block_face: format!("{:?}", self.block_face), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::HangingPlaceEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::HangingPlaceEvent(_) => { + panic!("Cannot construct HangingPlaceEvent from WASM event data alone"); + } + _ => panic!("unexpected event type"), + } + } +} diff --git a/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/inventory.rs b/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/inventory.rs index 8216133e5..66d7267b5 100644 --- a/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/inventory.rs +++ b/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/inventory.rs @@ -1,7 +1,16 @@ use crate::plugin::{ inventory::{ - craft_item::CraftItemEvent, furnace_smelt::FurnaceSmeltEvent, - inventory_drag::InventoryDragEvent, inventory_open::InventoryOpenEvent, + brew::BrewEvent, brewing_stand_fuel::BrewingStandFuelEvent, craft_item::CraftItemEvent, + furnace_burn::FurnaceBurnEvent, furnace_extract::FurnaceExtractEvent, + furnace_smelt::FurnaceSmeltEvent, furnace_start_smelt::FurnaceStartSmeltEvent, + hopper_inventory_search::HopperInventorySearchEvent, + inventory_creative::InventoryCreativeEvent, inventory_drag::InventoryDragEvent, + inventory_interact::InventoryInteractEvent, inventory_move_item::InventoryMoveItemEvent, + inventory_open::InventoryOpenEvent, inventory_pickup_item::InventoryPickupItemEvent, + prepare_anvil::PrepareAnvilEvent, prepare_grindstone::PrepareGrindstoneEvent, + prepare_inventory_result::PrepareInventoryResultEvent, + prepare_item_craft::PrepareItemCraftEvent, prepare_smithing::PrepareSmithingEvent, + smith_item::SmithItemEvent, trade_select::TradeSelectEvent, }, loader::wasm::wasm_host::{ state::PluginHostState, @@ -10,8 +19,14 @@ use crate::plugin::{ ToFromWasmEvent, consume_player, from_wasm_block_position, to_wasm_block_position, }, pumpkin::plugin::event::{ - CraftItemEventData, Event, FurnaceSmeltEventData, InventoryDragEventData, - InventoryOpenEventData, + BrewEventData, BrewingStandFuelEventData, CraftItemEventData, Event, + FurnaceBurnEventData, FurnaceExtractEventData, FurnaceSmeltEventData, + FurnaceStartSmeltEventData, HopperInventorySearchEventData, + InventoryCreativeEventData, InventoryDragEventData, InventoryInteractEventData, + InventoryMoveItemEventData, InventoryOpenEventData, InventoryPickupItemEventData, + PrepareAnvilEventData, PrepareGrindstoneEventData, PrepareInventoryResultEventData, + PrepareItemCraftEventData, PrepareSmithingEventData, SmithItemEventData, + TradeSelectEventData, }, }, }, @@ -110,3 +125,410 @@ impl ToFromWasmEvent for FurnaceSmeltEvent { } } } + +impl ToFromWasmEvent for BrewEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::BrewEvent(BrewEventData { + block_pos: to_wasm_block_position(self.block_pos), + fuel_level: self.fuel_level, + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::BrewEvent(data) => Self { + block_pos: from_wasm_block_position(data.block_pos), + fuel_level: data.fuel_level, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for BrewingStandFuelEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::BrewingStandFuelEvent(BrewingStandFuelEventData { + block_pos: to_wasm_block_position(self.block_pos), + fuel_power: self.fuel_power, + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::BrewingStandFuelEvent(data) => Self { + block_pos: from_wasm_block_position(data.block_pos), + fuel_power: data.fuel_power, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for FurnaceBurnEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::FurnaceBurnEvent(FurnaceBurnEventData { + block_pos: to_wasm_block_position(self.block_pos), + fuel_item: self.fuel_item.clone(), + burn_time: self.burn_time, + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::FurnaceBurnEvent(data) => Self { + block_pos: from_wasm_block_position(data.block_pos), + fuel_item: data.fuel_item, + burn_time: data.burn_time, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for FurnaceExtractEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + + Event::FurnaceExtractEvent(FurnaceExtractEventData { + player, + block_pos: to_wasm_block_position(self.block_pos), + item_id: self.item_id.clone(), + item_amount: self.item_amount, + exp_gained: self.exp_gained, + }) + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::FurnaceExtractEvent(data) => Self { + player: consume_player(state, &data.player), + block_pos: from_wasm_block_position(data.block_pos), + item_id: data.item_id, + item_amount: data.item_amount, + exp_gained: data.exp_gained, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for FurnaceStartSmeltEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::FurnaceStartSmeltEvent(FurnaceStartSmeltEventData { + block_pos: to_wasm_block_position(self.block_pos), + source_item: self.source_item.clone(), + cooking_time: self.cooking_time, + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::FurnaceStartSmeltEvent(data) => Self { + block_pos: from_wasm_block_position(data.block_pos), + source_item: data.source_item, + cooking_time: data.cooking_time, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for HopperInventorySearchEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::HopperInventorySearchEvent(HopperInventorySearchEventData { + block_pos: to_wasm_block_position(self.block_pos), + search_pos: to_wasm_block_position(self.search_pos), + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::HopperInventorySearchEvent(data) => Self { + block_pos: from_wasm_block_position(data.block_pos), + search_pos: from_wasm_block_position(data.search_pos), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for InventoryCreativeEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + + Event::InventoryCreativeEvent(InventoryCreativeEventData { + player, + slot: self.slot, + item_id: self.item_id.clone(), + item_count: self.item_count, + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::InventoryCreativeEvent(data) => Self { + player: consume_player(state, &data.player), + slot: data.slot, + item_id: data.item_id, + item_count: data.item_count, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for InventoryInteractEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + + Event::InventoryInteractEvent(InventoryInteractEventData { + player, + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::InventoryInteractEvent(data) => Self { + player: consume_player(state, &data.player), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for InventoryMoveItemEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::InventoryMoveItemEvent(InventoryMoveItemEventData { + source_pos: to_wasm_block_position(self.source_pos), + target_pos: to_wasm_block_position(self.target_pos), + item_id: self.item_id.clone(), + item_amount: self.item_amount, + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::InventoryMoveItemEvent(data) => Self { + source_pos: from_wasm_block_position(data.source_pos), + target_pos: from_wasm_block_position(data.target_pos), + item_id: data.item_id, + item_amount: data.item_amount, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for InventoryPickupItemEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::InventoryPickupItemEvent(InventoryPickupItemEventData { + block_pos: to_wasm_block_position(self.block_pos), + item_entity_id: self.item_entity_id, + item_id: self.item_id.clone(), + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::InventoryPickupItemEvent(data) => Self { + block_pos: from_wasm_block_position(data.block_pos), + item_entity_id: data.item_entity_id, + item_id: data.item_id, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PrepareAnvilEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + + Event::PrepareAnvilEvent(PrepareAnvilEventData { + player, + rename_text: self.rename_text.clone(), + repair_cost: self.repair_cost, + }) + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PrepareAnvilEvent(data) => Self { + player: consume_player(state, &data.player), + rename_text: data.rename_text, + repair_cost: data.repair_cost, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PrepareGrindstoneEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + + Event::PrepareGrindstoneEvent(PrepareGrindstoneEventData { + player, + result_item: self.result_item.clone(), + }) + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PrepareGrindstoneEvent(data) => Self { + player: consume_player(state, &data.player), + result_item: data.result_item, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PrepareInventoryResultEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + + Event::PrepareInventoryResultEvent(PrepareInventoryResultEventData { + player, + result_item: self.result_item.clone(), + }) + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PrepareInventoryResultEvent(data) => Self { + player: consume_player(state, &data.player), + result_item: data.result_item, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PrepareItemCraftEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + + Event::PrepareItemCraftEvent(PrepareItemCraftEventData { + player, + recipe_id: self.recipe_id.clone(), + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PrepareItemCraftEvent(data) => Self { + player: consume_player(state, &data.player), + recipe_id: data.recipe_id, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PrepareSmithingEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + + Event::PrepareSmithingEvent(PrepareSmithingEventData { + player, + result_item: self.result_item.clone(), + }) + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PrepareSmithingEvent(data) => Self { + player: consume_player(state, &data.player), + result_item: data.result_item, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for SmithItemEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + + Event::SmithItemEvent(SmithItemEventData { + player, + recipe_id: self.recipe_id.clone(), + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::SmithItemEvent(data) => Self { + player: consume_player(state, &data.player), + recipe_id: data.recipe_id, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for TradeSelectEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + + Event::TradeSelectEvent(TradeSelectEventData { + player, + slot_index: self.slot_index, + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::TradeSelectEvent(data) => Self { + player: consume_player(state, &data.player), + slot_index: data.slot_index, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} diff --git a/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/mod.rs b/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/mod.rs index 40e009e0b..ead7f7d7a 100644 --- a/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/mod.rs +++ b/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/mod.rs @@ -26,9 +26,12 @@ use crate::{ pub mod block; pub mod enchantment; pub mod entity; +pub mod hanging; pub mod inventory; pub mod player; +pub mod raid; pub mod server; +pub mod vehicle; pub mod world; impl pumpkin::plugin::event::Host for PluginHostState {} diff --git a/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/player.rs b/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/player.rs index c060f5214..fa111f757 100644 --- a/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/player.rs +++ b/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/player.rs @@ -1,3 +1,6 @@ +use std::sync::Arc; +use tokio::sync::Mutex; + use crate::plugin::api::events::player::custom_click_action::CustomClickActionEvent; use crate::plugin::{ loader::wasm::wasm_host::{ @@ -12,27 +15,46 @@ use crate::plugin::{ to_wasm_hand, to_wasm_position, }, pumpkin::plugin::event::{ + AsyncPlayerChatEventData, AsyncPlayerPreLoginEventData, BedrockFormResponseEventData, CustomClickActionEventData, Event, InteractAction as WasmInteractAction, InventoryClickEventData, - InventoryCloseEventData, PlayerBedEnterEventData, PlayerBedLeaveEventData, - PlayerBucketEmptyEventData, PlayerBucketFillEventData, PlayerChangeWorldEventData, - PlayerChangedMainHandEventData, PlayerChatEventData, PlayerCommandSendEventData, - PlayerCustomPayloadEventData, PlayerDropItemEventData, PlayerEggThrowEventData, - PlayerExpChangeEventData, PlayerFishEventData, + InventoryCloseEventData, PlayerAdvancementDoneEventData, PlayerAnimationEventData, + PlayerArmorStandManipulateEventData, PlayerBedEnterEventData, + PlayerBedLeaveEventData, PlayerBucketEmptyEventData, PlayerBucketEntityEventData, + PlayerBucketFillEventData, PlayerChangeWorldEventData, + PlayerChangedMainHandEventData, PlayerChangedWorldEventData, + PlayerChannelEventData, PlayerChatEventData, PlayerCommandPreprocessEventData, + PlayerCommandSendEventData, PlayerCustomPayloadEventData, PlayerDropItemEventData, + PlayerEditBookEventData, PlayerEggThrowEventData, PlayerElytraBoostEventData, + PlayerExpChangeEventData, PlayerExpCooldownChangeEventData, PlayerFishEventData, PlayerFishState as WasmPlayerFishState, PlayerGamemodeChangeEventData, - PlayerInteractEntityEventData, PlayerInteractEventData, - PlayerInteractUnknownEntityEventData, PlayerItemConsumeEventData, - PlayerItemDamageEventData, PlayerItemHeldEventData, PlayerJoinEventData, - PlayerLeaveEventData, PlayerLoginEventData, PlayerMoveEventData, - PlayerPermissionCheckEventData, PlayerRespawnEventData, PlayerTeleportEventData, + PlayerHarvestBlockEventData, PlayerHideEntityEventData, PlayerInputEventData, + PlayerInteractAtEntityEventData, PlayerInteractEntityEventData, + PlayerInteractEventData, PlayerInteractUnknownEntityEventData, + PlayerItemBreakEventData, PlayerItemConsumeEventData, PlayerItemDamageEventData, + PlayerItemHeldEventData, PlayerItemMendEventData, PlayerJoinEventData, + PlayerKickEventData, PlayerLeashEntityEventData, PlayerLeaveEventData, + PlayerLevelChangeEventData, PlayerLinksSendEventData, PlayerLocaleChangeEventData, + PlayerLoginEventData, PlayerMoveEventData, PlayerNameEntityEventData, + PlayerOpenSignEventData, PlayerPermissionCheckEventData, + PlayerPickupArrowEventData, PlayerPortalEventData, PlayerPreLoginEventData, + PlayerRecipeBookClickEventData, PlayerRecipeBookSettingsChangeEventData, + PlayerRecipeDiscoverEventData, PlayerRegisterChannelEventData, + PlayerResourcePackStatusEventData, PlayerRespawnEventData, PlayerRiptideEventData, + PlayerShearEntityEventData, PlayerShowEntityEventData, PlayerSpawnChangeEventData, + PlayerSpawnLocationEventData, PlayerStatisticIncrementEventData, + PlayerSwapHandsEventData, PlayerTakeLecternBookEventData, PlayerTeleportEventData, PlayerToggleFlightEventData, PlayerToggleSneakEventData, - PlayerToggleSprintEventData, + PlayerToggleSprintEventData, PlayerUnleashEntityEventData, + PlayerUnregisterChannelEventData, PlayerVelocityEventData, }, pumpkin::plugin::uuid::Uuid as WitUuid, uuid::UuidExt, }, }, player::{ + async_player_chat::AsyncPlayerChatEvent, + async_player_pre_login::AsyncPlayerPreLoginEvent, bedrock_form_response::BedrockFormResponseEvent, changed_main_hand::PlayerChangedMainHandEvent, egg_throw::PlayerEggThrowEvent, @@ -41,24 +63,66 @@ use crate::plugin::{ inventory_close::InventoryCloseEvent, inventory_interact::InventoryClickEvent, item_held::PlayerItemHeldEvent, + player_advancement_done::PlayerAdvancementDoneEvent, + player_animation::{PlayerAnimationEvent, PlayerAnimationType}, + player_armor_stand_manipulate::PlayerArmorStandManipulateEvent, + player_bucket_entity::PlayerBucketEntityEvent, player_change_world::PlayerChangeWorldEvent, + player_changed_world::PlayerChangedWorldEvent, + player_channel::PlayerChannelEvent, player_chat::PlayerChatEvent, + player_command_preprocess::PlayerCommandPreprocessEvent, player_command_send::PlayerCommandSendEvent, player_custom_payload::PlayerCustomPayloadEvent, + player_edit_book::PlayerEditBookEvent, + player_elytra_boost::PlayerElytraBoostEvent, + player_exp_cooldown_change::PlayerExpCooldownChangeEvent, player_gamemode_change::PlayerGamemodeChangeEvent, + player_harvest_block::PlayerHarvestBlockEvent, + player_hide_entity::PlayerHideEntityEvent, + player_input::PlayerInputEvent, + player_interact_at_entity::PlayerInteractAtEntityEvent, player_interact_entity_event::PlayerInteractEntityEvent, player_interact_event::{InteractAction, PlayerInteractEvent}, player_interact_unknown_entity_event::PlayerInteractUnknownEntityEvent, + player_item_break::PlayerItemBreakEvent, + player_item_mend::PlayerItemMendEvent, player_join::PlayerJoinEvent, + player_kick::PlayerKickEvent, + player_leash_entity::PlayerLeashEntityEvent, player_leave::PlayerLeaveEvent, + player_level_change::PlayerLevelChangeEvent, + player_links_send::PlayerLinksSendEvent, + player_locale_change::PlayerLocaleChangeEvent, player_login::PlayerLoginEvent, player_move::PlayerMoveEvent, + player_name_entity::PlayerNameEntityEvent, + player_open_sign::PlayerOpenSignEvent, player_permission_check::PlayerPermissionCheckEvent, + player_pickup_arrow::PlayerPickupArrowEvent, + player_portal::PlayerPortalEvent, + player_pre_login::PlayerPreLoginEvent, + player_recipe_book_click::PlayerRecipeBookClickEvent, + player_recipe_book_settings_change::PlayerRecipeBookSettingsChangeEvent, + player_recipe_discover::PlayerRecipeDiscoverEvent, + player_register_channel::PlayerRegisterChannelEvent, + player_resource_pack_status::PlayerResourcePackStatusEvent, player_respawn::PlayerRespawnEvent, + player_riptide::PlayerRiptideEvent, + player_shear_entity::PlayerShearEntityEvent, + player_show_entity::PlayerShowEntityEvent, + player_spawn_change::PlayerSpawnChangeEvent, + player_spawn_location::PlayerSpawnLocationEvent, + player_statistic_increment::PlayerStatisticIncrementEvent, + player_swap_hands::PlayerSwapHandItemsEvent, + player_take_lectern_book::PlayerTakeLecternBookEvent, player_teleport::PlayerTeleportEvent, player_toggle_flight_event::PlayerToggleFlightEvent, player_toggle_sneak_event::PlayerToggleSneakEvent, player_toggle_sprint_event::PlayerToggleSprintEvent, + player_unleash_entity::PlayerUnleashEntityEvent, + player_unregister_channel::PlayerUnregisterChannelEvent, + player_velocity::PlayerVelocityEvent, }, }; use bytes::Bytes; @@ -110,9 +174,6 @@ impl ToFromWasmEvent for InventoryCloseEvent { } } -use std::sync::Arc; -use tokio::sync::Mutex; - impl ToFromWasmEvent for InventoryClickEvent { fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { let player = state @@ -1074,3 +1135,1428 @@ impl ToFromWasmEvent for crate::plugin::api::events::player::player_bucket::Play } } } + +impl ToFromWasmEvent for AsyncPlayerChatEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + let format = state + .add_text_component(self.format.clone()) + .expect("failed to add text-component resource"); + Event::AsyncPlayerChatEvent(AsyncPlayerChatEventData { + player, + message: self.message.clone(), + format, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, state: &mut PluginHostState) { + if let Event::AsyncPlayerChatEvent(data) = event { + self.cancelled = data.cancelled; + self.message = data.message; + self.format = consume_text_component(state, &data.format); + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::AsyncPlayerChatEvent(data) => Self { + player: consume_player(state, &data.player), + message: data.message, + format: consume_text_component(state, &data.format), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for AsyncPlayerPreLoginEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let kick_message = state + .add_text_component(self.kick_message.clone()) + .expect("failed to add text-component resource"); + Event::AsyncPlayerPreLoginEvent(AsyncPlayerPreLoginEventData { + player_name: self.player_name.clone(), + player_uuid: self.player_uuid.to_string(), + ip_address: self.ip_address.to_string(), + kick_message, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, state: &mut PluginHostState) { + if let Event::AsyncPlayerPreLoginEvent(data) = event { + self.cancelled = data.cancelled; + self.kick_message = consume_text_component(state, &data.kick_message); + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::AsyncPlayerPreLoginEvent(data) => Self { + player_name: data.player_name, + player_uuid: data.player_uuid.parse().unwrap_or_default(), + ip_address: data + .ip_address + .parse() + .unwrap_or_else(|_| "127.0.0.1:0".parse().unwrap()), + kick_message: consume_text_component(state, &data.kick_message), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerAdvancementDoneEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerAdvancementDoneEvent(PlayerAdvancementDoneEventData { + player, + advancement_id: self.advancement_id.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerAdvancementDoneEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerAdvancementDoneEvent(data) => Self { + player: consume_player(state, &data.player), + advancement_id: data.advancement_id, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerAnimationEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + let animation_type = match self.animation_type { + PlayerAnimationType::ArmSwingOff => "ArmSwingOff".to_string(), + PlayerAnimationType::LeaveBed => "LeaveBed".to_string(), + PlayerAnimationType::ArmSwingMain => "ArmSwingMain".to_string(), + }; + Event::PlayerAnimationEvent(PlayerAnimationEventData { + player, + animation_type, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerAnimationEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerAnimationEvent(data) => Self { + player: consume_player(state, &data.player), + animation_type: match data.animation_type.as_str() { + "ArmSwingOff" => PlayerAnimationType::ArmSwingOff, + "LeaveBed" => PlayerAnimationType::LeaveBed, + _ => PlayerAnimationType::ArmSwingMain, + }, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerArmorStandManipulateEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerArmorStandManipulateEvent(PlayerArmorStandManipulateEventData { + player, + armor_stand_id: self.armor_stand_id, + slot: self.slot, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerArmorStandManipulateEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerArmorStandManipulateEvent(data) => Self { + player: consume_player(state, &data.player), + armor_stand_id: data.armor_stand_id, + slot: data.slot, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerBucketEntityEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerBucketEntityEvent(PlayerBucketEntityEventData { + player, + entity_id: self.entity_id, + bucket_item: self.bucket_item.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerBucketEntityEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerBucketEntityEvent(data) => Self { + player: consume_player(state, &data.player), + entity_id: data.entity_id, + bucket_item: data.bucket_item, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerChangedWorldEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + let from_world = state + .add_world(self.from_world.clone()) + .expect("failed to add world resource"); + let to_world = state + .add_world(self.to_world.clone()) + .expect("failed to add world resource"); + Event::PlayerChangedWorldEvent(PlayerChangedWorldEventData { + player, + from_world, + to_world, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerChangedWorldEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerChangedWorldEvent(data) => Self { + player: consume_player(state, &data.player), + from_world: consume_world(state, &data.from_world), + to_world: consume_world(state, &data.to_world), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerChannelEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerChannelEvent(PlayerChannelEventData { + player, + channel: self.channel.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerChannelEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerChannelEvent(data) => Self { + player: consume_player(state, &data.player), + channel: data.channel, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerCommandPreprocessEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerCommandPreprocessEvent(PlayerCommandPreprocessEventData { + player, + command: self.command.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerCommandPreprocessEvent(data) = event { + self.cancelled = data.cancelled; + self.command = data.command; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerCommandPreprocessEvent(data) => Self { + player: consume_player(state, &data.player), + command: data.command, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerEditBookEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerEditBookEvent(PlayerEditBookEventData { + player, + slot: self.slot, + pages: self.pages.clone(), + title: self.title.clone(), + signing: self.signing, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerEditBookEvent(data) = event { + self.cancelled = data.cancelled; + self.pages = data.pages; + self.title = data.title; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerEditBookEvent(data) => Self { + player: consume_player(state, &data.player), + slot: data.slot, + pages: data.pages, + title: data.title, + signing: data.signing, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerElytraBoostEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerElytraBoostEvent(PlayerElytraBoostEventData { + player, + firework_id: self.firework_id, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerElytraBoostEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerElytraBoostEvent(data) => Self { + player: consume_player(state, &data.player), + firework_id: data.firework_id, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerExpCooldownChangeEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerExpCooldownChangeEvent(PlayerExpCooldownChangeEventData { + player, + new_cooldown: self.new_cooldown, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerExpCooldownChangeEvent(data) = event { + self.cancelled = data.cancelled; + self.new_cooldown = data.new_cooldown; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerExpCooldownChangeEvent(data) => Self { + player: consume_player(state, &data.player), + new_cooldown: data.new_cooldown, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerHarvestBlockEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + let harvested_items = self + .harvested_items + .iter() + .map(|i| { + state + .add_item_stack(Arc::new(Mutex::new(i.clone()))) + .expect("failed to add item stack resource") + }) + .collect(); + Event::PlayerHarvestBlockEvent(PlayerHarvestBlockEventData { + player, + block_pos: to_wasm_block_position(self.block_pos), + harvested_items, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerHarvestBlockEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::PlayerHarvestBlockEvent(_) => { + panic!("Cannot construct PlayerHarvestBlockEvent from WASM") + } + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerHideEntityEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerHideEntityEvent(PlayerHideEntityEventData { + player, + entity_id: self.entity_id, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerHideEntityEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerHideEntityEvent(data) => Self { + player: consume_player(state, &data.player), + entity_id: data.entity_id, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerItemBreakEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerItemBreakEvent(PlayerItemBreakEventData { + player, + item_name: self.item_name.clone(), + }) + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerItemBreakEvent(data) => Self { + player: consume_player(state, &data.player), + item_name: data.item_name, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerItemMendEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerItemMendEvent(PlayerItemMendEventData { + player, + item_name: self.item_name.clone(), + repair_amount: self.repair_amount, + exp_consumed: self.exp_consumed, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerItemMendEvent(data) = event { + self.cancelled = data.cancelled; + self.repair_amount = data.repair_amount; + self.exp_consumed = data.exp_consumed; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerItemMendEvent(data) => Self { + player: consume_player(state, &data.player), + item_name: data.item_name, + repair_amount: data.repair_amount, + exp_consumed: data.exp_consumed, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerKickEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerKickEvent(PlayerKickEventData { + player, + reason: self.reason.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerKickEvent(data) = event { + self.cancelled = data.cancelled; + self.reason = data.reason; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerKickEvent(data) => Self { + player: consume_player(state, &data.player), + reason: data.reason, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerLeashEntityEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerLeashEntityEvent(PlayerLeashEntityEventData { + player, + entity_id: self.entity_id, + holder_id: self.holder_id, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerLeashEntityEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerLeashEntityEvent(data) => Self { + player: consume_player(state, &data.player), + entity_id: data.entity_id, + holder_id: data.holder_id, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerLevelChangeEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerLevelChangeEvent(PlayerLevelChangeEventData { + player, + old_level: self.old_level, + new_level: self.new_level, + }) + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerLevelChangeEvent(data) => Self { + player: consume_player(state, &data.player), + old_level: data.old_level, + new_level: data.new_level, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerLocaleChangeEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerLocaleChangeEvent(PlayerLocaleChangeEventData { + player, + new_locale: self.new_locale.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerLocaleChangeEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerLocaleChangeEvent(data) => Self { + player: consume_player(state, &data.player), + new_locale: data.new_locale, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerNameEntityEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + let name = state + .add_text_component(self.name.clone()) + .expect("failed to add text-component resource"); + Event::PlayerNameEntityEvent(PlayerNameEntityEventData { + player, + entity_id: self.entity_id, + name, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, state: &mut PluginHostState) { + if let Event::PlayerNameEntityEvent(data) = event { + self.cancelled = data.cancelled; + self.name = consume_text_component(state, &data.name); + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerNameEntityEvent(data) => Self { + player: consume_player(state, &data.player), + entity_id: data.entity_id, + name: consume_text_component(state, &data.name), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerOpenSignEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerOpenSignEvent(PlayerOpenSignEventData { + player, + block_pos: to_wasm_block_position(self.block_pos), + is_front: self.is_front, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerOpenSignEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerOpenSignEvent(data) => Self { + player: consume_player(state, &data.player), + block_pos: from_wasm_block_position(data.block_pos), + is_front: data.is_front, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerPortalEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerPortalEvent(PlayerPortalEventData { + player, + from_pos: to_wasm_block_position(self.from_pos), + to_pos: self.to_pos.map(to_wasm_block_position), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerPortalEvent(data) = event { + self.cancelled = data.cancelled; + self.to_pos = data.to_pos.map(from_wasm_block_position); + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerPortalEvent(data) => Self { + player: consume_player(state, &data.player), + from_pos: from_wasm_block_position(data.from_pos), + to_pos: data.to_pos.map(from_wasm_block_position), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerPreLoginEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let kick_message = state + .add_text_component(self.kick_message.clone()) + .expect("failed to add text-component resource"); + Event::PlayerPreLoginEvent(PlayerPreLoginEventData { + player_name: self.player_name.clone(), + player_uuid: self.player_uuid.to_string(), + ip_address: self.ip_address.to_string(), + kick_message, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, state: &mut PluginHostState) { + if let Event::PlayerPreLoginEvent(data) = event { + self.cancelled = data.cancelled; + self.kick_message = consume_text_component(state, &data.kick_message); + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerPreLoginEvent(data) => Self { + player_name: data.player_name, + player_uuid: data.player_uuid.parse().unwrap_or_default(), + ip_address: data + .ip_address + .parse() + .unwrap_or_else(|_| "127.0.0.1:0".parse().unwrap()), + kick_message: consume_text_component(state, &data.kick_message), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerRiptideEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerRiptideEvent(PlayerRiptideEventData { + player, + item_name: self.item_name.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerRiptideEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerRiptideEvent(data) => Self { + player: consume_player(state, &data.player), + item_name: data.item_name, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerShearEntityEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerShearEntityEvent(PlayerShearEntityEventData { + player, + entity_id: self.entity_id, + hand: self.hand, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerShearEntityEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerShearEntityEvent(data) => Self { + player: consume_player(state, &data.player), + entity_id: data.entity_id, + hand: data.hand, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerShowEntityEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerShowEntityEvent(PlayerShowEntityEventData { + player, + entity_id: self.entity_id, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerShowEntityEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerShowEntityEvent(data) => Self { + player: consume_player(state, &data.player), + entity_id: data.entity_id, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerSpawnChangeEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerSpawnChangeEvent(PlayerSpawnChangeEventData { + player, + new_spawn: self.new_spawn.map(to_wasm_block_position), + forced: self.forced, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerSpawnChangeEvent(data) = event { + self.cancelled = data.cancelled; + self.new_spawn = data.new_spawn.map(from_wasm_block_position); + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerSpawnChangeEvent(data) => Self { + player: consume_player(state, &data.player), + new_spawn: data.new_spawn.map(from_wasm_block_position), + forced: data.forced, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerStatisticIncrementEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerStatisticIncrementEvent(PlayerStatisticIncrementEventData { + player, + statistic_id: self.statistic_id.clone(), + amount: self.amount, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerStatisticIncrementEvent(data) = event { + self.cancelled = data.cancelled; + self.amount = data.amount; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerStatisticIncrementEvent(data) => Self { + player: consume_player(state, &data.player), + statistic_id: data.statistic_id, + amount: data.amount, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerSwapHandItemsEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerSwapHandsEvent(PlayerSwapHandsEventData { + player, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerSwapHandsEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerSwapHandsEvent(data) => Self { + player: consume_player(state, &data.player), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerTakeLecternBookEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + let book = state + .add_item_stack(Arc::new(Mutex::new(self.book.clone()))) + .expect("failed to add item stack resource"); + Event::PlayerTakeLecternBookEvent(PlayerTakeLecternBookEventData { + player, + block_pos: to_wasm_block_position(self.block_pos), + book, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerTakeLecternBookEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::PlayerTakeLecternBookEvent(_) => { + panic!("Cannot construct PlayerTakeLecternBookEvent from WASM") + } + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerUnleashEntityEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerUnleashEntityEvent(PlayerUnleashEntityEventData { + player, + entity_id: self.entity_id, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerUnleashEntityEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerUnleashEntityEvent(data) => Self { + player: consume_player(state, &data.player), + entity_id: data.entity_id, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerVelocityEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerVelocityEvent(PlayerVelocityEventData { + player, + velocity: to_wasm_position(self.velocity), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerVelocityEvent(data) = event { + self.cancelled = data.cancelled; + self.velocity = from_wasm_position(data.velocity); + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerVelocityEvent(data) => Self { + player: consume_player(state, &data.player), + velocity: from_wasm_position(data.velocity), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerInputEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerInputEvent(PlayerInputEventData { + player, + input: self.input.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerInputEvent(data) = event { + self.cancelled = data.cancelled; + self.input = data.input; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerInputEvent(data) => Self { + player: consume_player(state, &data.player), + input: data.input, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerInteractAtEntityEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerInteractAtEntityEvent(PlayerInteractAtEntityEventData { + player, + entity_id: self.entity_id, + clicked_x: self.clicked_x, + clicked_y: self.clicked_y, + clicked_z: self.clicked_z, + hand: self.hand, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerInteractAtEntityEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerInteractAtEntityEvent(data) => Self { + player: consume_player(state, &data.player), + entity_id: data.entity_id, + clicked_x: data.clicked_x, + clicked_y: data.clicked_y, + clicked_z: data.clicked_z, + hand: data.hand, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerLinksSendEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerLinksSendEvent(PlayerLinksSendEventData { + player, + links: self.links.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerLinksSendEvent(data) = event { + self.cancelled = data.cancelled; + self.links = data.links; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerLinksSendEvent(data) => Self { + player: consume_player(state, &data.player), + links: data.links, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerPickupArrowEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerPickupArrowEvent(PlayerPickupArrowEventData { + player, + arrow_id: self.arrow_id, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerPickupArrowEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerPickupArrowEvent(data) => Self { + player: consume_player(state, &data.player), + arrow_id: data.arrow_id, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerRecipeBookClickEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerRecipeBookClickEvent(PlayerRecipeBookClickEventData { + player, + recipe_id: self.recipe_id.clone(), + make_all: self.make_all, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerRecipeBookClickEvent(data) = event { + self.cancelled = data.cancelled; + self.recipe_id = data.recipe_id; + self.make_all = data.make_all; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerRecipeBookClickEvent(data) => Self { + player: consume_player(state, &data.player), + recipe_id: data.recipe_id, + make_all: data.make_all, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerRecipeBookSettingsChangeEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerRecipeBookSettingsChangeEvent(PlayerRecipeBookSettingsChangeEventData { + player, + book_type: self.book_type.clone(), + is_open: self.is_open, + is_filtering: self.is_filtering, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerRecipeBookSettingsChangeEvent(data) = event { + self.cancelled = data.cancelled; + self.book_type = data.book_type; + self.is_open = data.is_open; + self.is_filtering = data.is_filtering; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerRecipeBookSettingsChangeEvent(data) => Self { + player: consume_player(state, &data.player), + book_type: data.book_type, + is_open: data.is_open, + is_filtering: data.is_filtering, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerRecipeDiscoverEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerRecipeDiscoverEvent(PlayerRecipeDiscoverEventData { + player, + recipe_id: self.recipe_id.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerRecipeDiscoverEvent(data) = event { + self.cancelled = data.cancelled; + self.recipe_id = data.recipe_id; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerRecipeDiscoverEvent(data) => Self { + player: consume_player(state, &data.player), + recipe_id: data.recipe_id, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerRegisterChannelEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerRegisterChannelEvent(PlayerRegisterChannelEventData { + player, + channel: self.channel.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerRegisterChannelEvent(data) = event { + self.cancelled = data.cancelled; + self.channel = data.channel; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerRegisterChannelEvent(data) => Self { + player: consume_player(state, &data.player), + channel: data.channel, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerResourcePackStatusEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerResourcePackStatusEvent(PlayerResourcePackStatusEventData { + player, + pack_id: self.pack_id.clone(), + status: self.status.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerResourcePackStatusEvent(data) = event { + self.cancelled = data.cancelled; + self.status = data.status; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerResourcePackStatusEvent(data) => Self { + player: consume_player(state, &data.player), + pack_id: data.pack_id, + status: data.status, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerSpawnLocationEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerSpawnLocationEvent(PlayerSpawnLocationEventData { + player, + spawn_pos: to_wasm_position(self.spawn_pos), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerSpawnLocationEvent(data) = event { + self.cancelled = data.cancelled; + self.spawn_pos = from_wasm_position(data.spawn_pos); + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerSpawnLocationEvent(data) => Self { + player: consume_player(state, &data.player), + spawn_pos: from_wasm_position(data.spawn_pos), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for PlayerUnregisterChannelEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let player = state + .add_player(self.player.clone()) + .expect("failed to add player resource"); + Event::PlayerUnregisterChannelEvent(PlayerUnregisterChannelEventData { + player, + channel: self.channel.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PlayerUnregisterChannelEvent(data) = event { + self.cancelled = data.cancelled; + self.channel = data.channel; + } + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::PlayerUnregisterChannelEvent(data) => Self { + player: consume_player(state, &data.player), + channel: data.channel, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} diff --git a/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/raid.rs b/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/raid.rs new file mode 100644 index 000000000..b48d0a47d --- /dev/null +++ b/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/raid.rs @@ -0,0 +1,119 @@ +use crate::plugin::{ + loader::wasm::wasm_host::{ + state::PluginHostState, + wit::v0_1::{ + events::{ToFromWasmEvent, from_wasm_block_position, to_wasm_block_position}, + pumpkin::plugin::event::{ + Event, RaidFinishEventData, RaidSpawnWaveEventData, RaidStopEventData, + RaidTriggerEventData, + }, + }, + }, + raid::{ + raid_finish::RaidFinishEvent, raid_spawn_wave::RaidSpawnWaveEvent, + raid_stop::RaidStopEvent, raid_trigger::RaidTriggerEvent, + }, +}; + +impl ToFromWasmEvent for RaidFinishEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::RaidFinishEvent(RaidFinishEventData { + victory: self.victory, + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::RaidFinishEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::RaidFinishEvent(data) => Self { + victory: data.victory, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for RaidSpawnWaveEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::RaidSpawnWaveEvent(RaidSpawnWaveEventData { + wave: self.wave, + pos: to_wasm_block_position(self.pos), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::RaidSpawnWaveEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::RaidSpawnWaveEvent(data) => Self { + wave: data.wave, + pos: from_wasm_block_position(data.pos), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for RaidStopEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::RaidStopEvent(RaidStopEventData { + reason: self.reason.clone(), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::RaidStopEvent(data) = event { + self.cancelled = data.cancelled; + self.reason = data.reason; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::RaidStopEvent(data) => Self { + reason: data.reason, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for RaidTriggerEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::RaidTriggerEvent(RaidTriggerEventData { + pos: to_wasm_block_position(self.pos), + cancelled: self.cancelled, + }) + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::RaidTriggerEvent(data) = event { + self.cancelled = data.cancelled; + } + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::RaidTriggerEvent(data) => Self { + pos: from_wasm_block_position(data.pos), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } +} diff --git a/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/server.rs b/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/server.rs index 20a90a78b..21f2ec4f1 100644 --- a/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/server.rs +++ b/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/server.rs @@ -6,15 +6,17 @@ use crate::plugin::{ events::{ToFromWasmEvent, consume_text_component}, generated_packets, pumpkin::plugin::event::{ - ClientboundPacket, Event, PacketReceivedEventData, PacketSentEventData, - ServerBroadcastEventData, ServerCommandEventData, ServerListPingAddress, - ServerListPingEventData, ServerLoadEventData, ServerLoadType, - ServerTickEndEventData, ServerTickStartEventData, ServerboundPacket, + ClientboundPacket, Event, MapInitializeEventData, PacketReceivedEventData, + PacketSentEventData, ServerBroadcastEventData, ServerCommandEventData, + ServerListPingAddress, ServerListPingEventData, ServerLoadEventData, + ServerLoadType, ServerTickEndEventData, ServerTickStartEventData, + ServerboundPacket, }, }, }, server::{ list_ping::ServerListPingEvent, + map_initialize::MapInitializeEvent, packet::{PacketReceivedEvent, PacketSentEvent}, server_broadcast::ServerBroadcastEvent, server_command::ServerCommandEvent, @@ -267,3 +269,20 @@ impl ToFromWasmEvent for ServerTickStartEvent { } } } + +impl ToFromWasmEvent for MapInitializeEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::MapInitializeEvent(MapInitializeEventData { + map_id: self.map_id, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::MapInitializeEvent(data) => Self { + map_id: data.map_id, + }, + _ => panic!("unexpected event type"), + } + } +} diff --git a/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/vehicle.rs b/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/vehicle.rs new file mode 100644 index 000000000..fdb99e972 --- /dev/null +++ b/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/vehicle.rs @@ -0,0 +1,305 @@ +use crate::plugin::{ + loader::wasm::wasm_host::{ + state::PluginHostState, + wit::v0_1::{ + events::{ToFromWasmEvent, from_wasm_block_position, to_wasm_block_position}, + pumpkin::plugin::event::{ + Event, VehicleBlockCollisionEventData, VehicleCollisionEventData, + VehicleCreateEventData, VehicleDamageEventData, VehicleDestroyEventData, + VehicleEnterEventData, VehicleEntityCollisionEventData, VehicleExitEventData, + VehicleMoveEventData, VehicleUpdateEventData, + }, + }, + }, + vehicle::{ + vehicle_block_collision::VehicleBlockCollisionEvent, + vehicle_collision::VehicleCollisionEvent, vehicle_create::VehicleCreateEvent, + vehicle_damage::VehicleDamageEvent, vehicle_destroy::VehicleDestroyEvent, + vehicle_enter::VehicleEnterEvent, vehicle_entity_collision::VehicleEntityCollisionEvent, + vehicle_exit::VehicleExitEvent, vehicle_move::VehicleMoveEvent, + vehicle_update::VehicleUpdateEvent, + }, +}; +use pumpkin_util::math::vector3::Vector3; + +impl ToFromWasmEvent for VehicleBlockCollisionEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::VehicleBlockCollisionEvent(VehicleBlockCollisionEventData { + vehicle_id: self.vehicle_id, + block_pos: to_wasm_block_position(self.block_pos), + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::VehicleBlockCollisionEvent(data) => Self { + vehicle_id: data.vehicle_id, + block_pos: from_wasm_block_position(data.block_pos), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::VehicleBlockCollisionEvent(data) = event { + self.block_pos = from_wasm_block_position(data.block_pos); + self.cancelled = data.cancelled; + } + } +} + +impl ToFromWasmEvent for VehicleCollisionEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::VehicleCollisionEvent(VehicleCollisionEventData { + vehicle_id: self.vehicle_id, + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::VehicleCollisionEvent(data) => Self { + vehicle_id: data.vehicle_id, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::VehicleCollisionEvent(data) = event { + self.cancelled = data.cancelled; + } + } +} + +impl ToFromWasmEvent for VehicleCreateEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::VehicleCreateEvent(VehicleCreateEventData { + vehicle_id: self.vehicle_id, + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::VehicleCreateEvent(data) => Self { + vehicle_id: data.vehicle_id, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::VehicleCreateEvent(data) = event { + self.cancelled = data.cancelled; + } + } +} + +impl ToFromWasmEvent for VehicleDamageEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::VehicleDamageEvent(VehicleDamageEventData { + vehicle_id: self.vehicle_id, + damage: self.damage, + attacker_id: self.attacker_id, + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::VehicleDamageEvent(data) => Self { + vehicle_id: data.vehicle_id, + damage: data.damage, + attacker_id: data.attacker_id, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::VehicleDamageEvent(data) = event { + self.damage = data.damage; + self.attacker_id = data.attacker_id; + self.cancelled = data.cancelled; + } + } +} + +impl ToFromWasmEvent for VehicleDestroyEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::VehicleDestroyEvent(VehicleDestroyEventData { + vehicle_id: self.vehicle_id, + attacker_id: self.attacker_id, + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::VehicleDestroyEvent(data) => Self { + vehicle_id: data.vehicle_id, + attacker_id: data.attacker_id, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::VehicleDestroyEvent(data) = event { + self.attacker_id = data.attacker_id; + self.cancelled = data.cancelled; + } + } +} + +impl ToFromWasmEvent for VehicleEnterEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::VehicleEnterEvent(VehicleEnterEventData { + vehicle_id: self.vehicle_id, + entered_id: self.entered_id, + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::VehicleEnterEvent(data) => Self { + vehicle_id: data.vehicle_id, + entered_id: data.entered_id, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::VehicleEnterEvent(data) = event { + self.cancelled = data.cancelled; + } + } +} + +impl ToFromWasmEvent for VehicleEntityCollisionEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::VehicleEntityCollisionEvent(VehicleEntityCollisionEventData { + vehicle_id: self.vehicle_id, + collided_entity_id: self.collided_entity_id, + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::VehicleEntityCollisionEvent(data) => Self { + vehicle_id: data.vehicle_id, + collided_entity_id: data.collided_entity_id, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::VehicleEntityCollisionEvent(data) = event { + self.cancelled = data.cancelled; + } + } +} + +impl ToFromWasmEvent for VehicleExitEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::VehicleExitEvent(VehicleExitEventData { + vehicle_id: self.vehicle_id, + exited_id: self.exited_id, + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::VehicleExitEvent(data) => Self { + vehicle_id: data.vehicle_id, + exited_id: data.exited_id, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::VehicleExitEvent(data) = event { + self.cancelled = data.cancelled; + } + } +} + +impl ToFromWasmEvent for VehicleMoveEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::VehicleMoveEvent(VehicleMoveEventData { + vehicle_id: self.vehicle_id, + from_position: (self.from.x, self.from.y, self.from.z), + to_position: (self.to.x, self.to.y, self.to.z), + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::VehicleMoveEvent(data) => Self { + vehicle_id: data.vehicle_id, + from: Vector3::new( + data.from_position.0, + data.from_position.1, + data.from_position.2, + ), + to: Vector3::new(data.to_position.0, data.to_position.1, data.to_position.2), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::VehicleMoveEvent(data) = event { + self.from = Vector3::new( + data.from_position.0, + data.from_position.1, + data.from_position.2, + ); + self.to = Vector3::new(data.to_position.0, data.to_position.1, data.to_position.2); + self.cancelled = data.cancelled; + } + } +} + +impl ToFromWasmEvent for VehicleUpdateEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::VehicleUpdateEvent(VehicleUpdateEventData { + vehicle_id: self.vehicle_id, + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::VehicleUpdateEvent(data) => Self { + vehicle_id: data.vehicle_id, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::VehicleUpdateEvent(data) = event { + self.cancelled = data.cancelled; + } + } +} diff --git a/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/world.rs b/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/world.rs index 321a63821..0d72a9f62 100644 --- a/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/world.rs +++ b/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/events/world.rs @@ -290,3 +290,411 @@ impl ToFromWasmEvent for crate::plugin::api::events::world::world_load::WorldUnl } } } + +impl ToFromWasmEvent + for crate::plugin::api::events::world::async_structure_generate::AsyncStructureGenerateEvent +{ + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::AsyncStructureGenerateEvent(crate::plugin::loader::wasm::wasm_host::wit::v0_1::pumpkin::plugin::event::AsyncStructureGenerateEventData { + world_name: self.world_name.clone(), + structure_name: self.structure_name.clone(), + pos: to_wasm_block_position(self.pos), + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::AsyncStructureGenerateEvent(data) => Self { + world_name: data.world_name, + structure_name: data.structure_name, + pos: from_wasm_block_position(data.pos), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::AsyncStructureGenerateEvent(data) = event { + self.cancelled = data.cancelled; + } + } +} + +impl ToFromWasmEvent + for crate::plugin::api::events::world::async_structure_spawn::AsyncStructureSpawnEvent +{ + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::AsyncStructureSpawnEvent(crate::plugin::loader::wasm::wasm_host::wit::v0_1::pumpkin::plugin::event::AsyncStructureSpawnEventData { + world_name: self.world_name.clone(), + structure_name: self.structure_name.clone(), + pos: to_wasm_block_position(self.pos), + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::AsyncStructureSpawnEvent(data) => Self { + world_name: data.world_name, + structure_name: data.structure_name, + pos: from_wasm_block_position(data.pos), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::AsyncStructureSpawnEvent(data) = event { + self.cancelled = data.cancelled; + } + } +} + +impl ToFromWasmEvent for crate::plugin::api::events::world::chunk_populate::ChunkPopulateEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::ChunkPopulateEvent(crate::plugin::loader::wasm::wasm_host::wit::v0_1::pumpkin::plugin::event::ChunkPopulateEventData { + chunk_x: self.chunk_pos.x, + chunk_z: self.chunk_pos.y, + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::ChunkPopulateEvent(data) => Self { + chunk_pos: pumpkin_util::math::vector2::Vector2::new(data.chunk_x, data.chunk_z), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::ChunkPopulateEvent(data) = event { + self.cancelled = data.cancelled; + } + } +} + +impl ToFromWasmEvent for crate::plugin::api::events::world::chunk_unload::ChunkUnloadEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::ChunkUnloadEvent(crate::plugin::loader::wasm::wasm_host::wit::v0_1::pumpkin::plugin::event::ChunkUnloadEventData { + chunk_x: self.chunk_pos.x, + chunk_z: self.chunk_pos.y, + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::ChunkUnloadEvent(data) => Self { + chunk_pos: pumpkin_util::math::vector2::Vector2::new(data.chunk_x, data.chunk_z), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::ChunkUnloadEvent(data) = event { + self.cancelled = data.cancelled; + } + } +} + +impl ToFromWasmEvent for crate::plugin::api::events::world::entities_load::EntitiesLoadEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::EntitiesLoadEvent(crate::plugin::loader::wasm::wasm_host::wit::v0_1::pumpkin::plugin::event::EntitiesLoadEventData { + chunk_x: self.chunk_pos.x, + chunk_z: self.chunk_pos.y, + entity_count: self.entity_count as u32, + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::EntitiesLoadEvent(data) => Self { + chunk_pos: pumpkin_util::math::vector2::Vector2::new(data.chunk_x, data.chunk_z), + entity_count: data.entity_count as usize, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::EntitiesLoadEvent(data) = event { + self.cancelled = data.cancelled; + } + } +} + +impl ToFromWasmEvent for crate::plugin::api::events::world::entities_unload::EntitiesUnloadEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::EntitiesUnloadEvent(crate::plugin::loader::wasm::wasm_host::wit::v0_1::pumpkin::plugin::event::EntitiesUnloadEventData { + chunk_x: self.chunk_pos.x, + chunk_z: self.chunk_pos.y, + entity_count: self.entity_count as u32, + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::EntitiesUnloadEvent(data) => Self { + chunk_pos: pumpkin_util::math::vector2::Vector2::new(data.chunk_x, data.chunk_z), + entity_count: data.entity_count as usize, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::EntitiesUnloadEvent(data) = event { + self.cancelled = data.cancelled; + } + } +} + +impl ToFromWasmEvent for crate::plugin::api::events::world::generic_game::GenericGameEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::GenericGameEvent(crate::plugin::loader::wasm::wasm_host::wit::v0_1::pumpkin::plugin::event::GenericGameEventData { + event_id: self.event_key.clone(), + pos: (self.position.x, self.position.y, self.position.z), + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::GenericGameEvent(data) => Self { + event_key: data.event_id, + position: pumpkin_util::math::vector3::Vector3::new( + data.pos.0, data.pos.1, data.pos.2, + ), + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::GenericGameEvent(data) = event { + self.cancelled = data.cancelled; + } + } +} + +impl ToFromWasmEvent for crate::plugin::api::events::world::loot_generate::LootGenerateEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::LootGenerateEvent(crate::plugin::loader::wasm::wasm_host::wit::v0_1::pumpkin::plugin::event::LootGenerateEventData { + loot_table: self.loot_table.clone(), + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::LootGenerateEvent(data) => Self { + loot_table: data.loot_table, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::LootGenerateEvent(data) = event { + self.cancelled = data.cancelled; + } + } +} + +impl ToFromWasmEvent for crate::plugin::api::events::world::portal_create::PortalCreateEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::PortalCreateEvent(crate::plugin::loader::wasm::wasm_host::wit::v0_1::pumpkin::plugin::event::PortalCreateEventData { + pos: to_wasm_block_position(self.block_pos), + portal_type: format!("{:?}", self.portal_type), + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::PortalCreateEvent(data) => Self { + block_pos: from_wasm_block_position(data.pos), + portal_type: match data.portal_type.as_str() { + "Nether" => { + crate::plugin::api::events::world::portal_create::PortalType::Nether + } + "End" => crate::plugin::api::events::world::portal_create::PortalType::End, + _ => crate::plugin::api::events::world::portal_create::PortalType::Custom, + }, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::PortalCreateEvent(data) = event { + self.cancelled = data.cancelled; + } + } +} + +impl ToFromWasmEvent for crate::plugin::api::events::world::structure_grow::StructureGrowEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::StructureGrowEvent(crate::plugin::loader::wasm::wasm_host::wit::v0_1::pumpkin::plugin::event::StructureGrowEventData { + pos: to_wasm_block_position(self.block_pos), + species: format!("{:?}", self.species), + bone_meal: self.bone_meal, + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::StructureGrowEvent(data) => Self { + block_pos: from_wasm_block_position(data.pos), + species: match data.species.as_str() { + "Oak" => crate::plugin::api::events::world::structure_grow::TreeType::Oak, + "Spruce" => crate::plugin::api::events::world::structure_grow::TreeType::Spruce, + "Birch" => crate::plugin::api::events::world::structure_grow::TreeType::Birch, + "Jungle" => crate::plugin::api::events::world::structure_grow::TreeType::Jungle, + "Acacia" => crate::plugin::api::events::world::structure_grow::TreeType::Acacia, + "DarkOak" => { + crate::plugin::api::events::world::structure_grow::TreeType::DarkOak + } + "Mangrove" => { + crate::plugin::api::events::world::structure_grow::TreeType::Mangrove + } + "Cherry" => crate::plugin::api::events::world::structure_grow::TreeType::Cherry, + "Azalea" => crate::plugin::api::events::world::structure_grow::TreeType::Azalea, + "BrownMushroom" => { + crate::plugin::api::events::world::structure_grow::TreeType::BrownMushroom + } + "RedMushroom" => { + crate::plugin::api::events::world::structure_grow::TreeType::RedMushroom + } + _ => crate::plugin::api::events::world::structure_grow::TreeType::Custom, + }, + bone_meal: data.bone_meal, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::StructureGrowEvent(data) = event { + self.cancelled = data.cancelled; + } + } +} + +impl ToFromWasmEvent for crate::plugin::api::events::world::time_skip::TimeSkipEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::TimeSkipEvent(crate::plugin::loader::wasm::wasm_host::wit::v0_1::pumpkin::plugin::event::TimeSkipEventData { + skip_amount: self.skip_amount, + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::TimeSkipEvent(data) => Self { + skip_amount: data.skip_amount, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::TimeSkipEvent(data) = event { + self.cancelled = data.cancelled; + } + } +} + +impl ToFromWasmEvent for crate::plugin::api::events::world::world_init::WorldInitEvent { + fn to_wasm_event(&self, state: &mut PluginHostState) -> Event { + let target_world = state + .add_world(self.world.clone()) + .expect("failed to add world resource"); + + Event::WorldInitEvent(crate::plugin::loader::wasm::wasm_host::wit::v0_1::pumpkin::plugin::event::WorldInitEventData { + target_world, + }) + } + + fn from_wasm_event(event: Event, state: &mut PluginHostState) -> Self { + match event { + Event::WorldInitEvent(data) => Self { + world: consume_world(state, &data.target_world), + }, + _ => panic!("unexpected event type"), + } + } +} + +impl ToFromWasmEvent for crate::plugin::api::events::world::world_save::WorldSaveEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::WorldSaveEvent(crate::plugin::loader::wasm::wasm_host::wit::v0_1::pumpkin::plugin::event::WorldSaveEventData { + world_name: self.world_name.clone(), + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::WorldSaveEvent(data) => Self { + world_name: data.world_name, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::WorldSaveEvent(data) = event { + self.cancelled = data.cancelled; + } + } +} + +impl ToFromWasmEvent for crate::plugin::api::events::world::lightning_strike::LightningStrikeEvent { + fn to_wasm_event(&self, _state: &mut PluginHostState) -> Event { + Event::LightningStrikeEvent(crate::plugin::loader::wasm::wasm_host::wit::v0_1::pumpkin::plugin::event::LightningStrikeEventData { + position: crate::plugin::loader::wasm::wasm_host::wit::v0_1::events::to_wasm_position(self.position), + is_effect: self.is_effect, + cancelled: self.cancelled, + }) + } + + fn from_wasm_event(event: Event, _state: &mut PluginHostState) -> Self { + match event { + Event::LightningStrikeEvent(data) => Self { + position: + crate::plugin::loader::wasm::wasm_host::wit::v0_1::events::from_wasm_position( + data.position, + ), + is_effect: data.is_effect, + cancelled: data.cancelled, + }, + _ => panic!("unexpected event type"), + } + } + + fn apply_wasm_event(&mut self, event: Event, _state: &mut PluginHostState) { + if let Event::LightningStrikeEvent(data) = event { + self.cancelled = data.cancelled; + } + } +} diff --git a/crates/pumpkin/src/world/mod.rs b/crates/pumpkin/src/world/mod.rs index 7de96dd32..3ad8c0124 100644 --- a/crates/pumpkin/src/world/mod.rs +++ b/crates/pumpkin/src/world/mod.rs @@ -3691,6 +3691,18 @@ impl World { ) }; + let mut spawn_loc_event = crate::plugin::api::events::player::player_spawn_location::PlayerSpawnLocationEvent::new( + player.clone(), + position, + ); + if let Some(server) = self.server.upgrade() { + server + .plugin_manager + .fire(&server, &mut spawn_loc_event) + .await; + } + let position = spawn_loc_event.spawn_pos; + // Candidate destination world for a cross-dimension respawn. let candidate_world = if respawn_dimension == self.dimension { None @@ -6122,6 +6134,39 @@ impl World { server.plugin_manager.fire(&server, &mut raid_event).await; } } + + pub async fn async_structure_generate( + &self, + world_name: String, + structure_name: String, + pos: BlockPos, + ) { + let mut event = crate::plugin::api::events::world::async_structure_generate::AsyncStructureGenerateEvent::new( + world_name, + structure_name, + pos, + ); + if let Some(server) = self.server.upgrade() { + server.plugin_manager.fire(&server, &mut event).await; + } + } + + pub async fn async_structure_spawn( + &self, + world_name: String, + structure_name: String, + pos: BlockPos, + ) { + let mut event = + crate::plugin::api::events::world::async_structure_spawn::AsyncStructureSpawnEvent::new( + world_name, + structure_name, + pos, + ); + if let Some(server) = self.server.upgrade() { + server.plugin_manager.fire(&server, &mut event).await; + } + } } impl BlockAccessor for World {