705 lines
24 KiB
Rust
705 lines
24 KiB
Rust
use std::sync::{
|
|
Arc, Weak,
|
|
atomic::{AtomicBool, AtomicI32, Ordering},
|
|
};
|
|
|
|
use pumpkin_data::Block;
|
|
use pumpkin_data::data_component_impl::EquipmentSlot;
|
|
use pumpkin_data::dimension::Dimension;
|
|
use pumpkin_data::entity::EntityType;
|
|
use pumpkin_data::item::Item;
|
|
use pumpkin_data::item_stack::ItemStack;
|
|
use pumpkin_data::sound::{Sound, SoundCategory};
|
|
use pumpkin_data::tracked_data;
|
|
use pumpkin_nbt::compound::NbtCompound;
|
|
use pumpkin_nbt::tag::NbtTag;
|
|
use pumpkin_protocol::java::client::play::Metadata;
|
|
use pumpkin_util::math::boundingbox::EntityDimensions;
|
|
use pumpkin_util::math::position::BlockPos;
|
|
use tokio::sync::Mutex;
|
|
|
|
use crate::entity::living::LivingEntity;
|
|
use crate::entity::player::Player;
|
|
use crate::entity::{
|
|
Entity, EntityBase, EntityBaseFuture, NbtFuture,
|
|
ai::goal::{
|
|
active_target::ActiveTargetGoal, look_around::RandomLookAroundGoal,
|
|
look_at_entity::LookAtEntityGoal, melee_attack::MeleeAttackGoal, open_door::OpenDoorGoal,
|
|
ranged_crossbow_attack::RangedCrossbowAttackGoal, revenge::RevengeGoal, swim::SwimGoal,
|
|
wander_around::WanderAroundGoal,
|
|
},
|
|
mob::{
|
|
Mob, MobEntity, crossbow_attack_mob::CrossbowAttackMob, equipment::RegionalDifficulty,
|
|
piglin_ai::PiglinAi,
|
|
},
|
|
};
|
|
use crate::world::World;
|
|
|
|
pub struct PiglinEntity {
|
|
pub mob_entity: MobEntity,
|
|
pub immune_to_zombification: AtomicBool,
|
|
pub time_in_overworld: AtomicI32,
|
|
pub is_baby: AtomicBool,
|
|
pub cannot_hunt: AtomicBool,
|
|
pub is_charging_crossbow: AtomicBool,
|
|
pub is_dancing: AtomicBool,
|
|
pub inventory: Mutex<Vec<ItemStack>>,
|
|
pub admire_timer: AtomicI32,
|
|
pub admiring_disabled_timer: AtomicI32,
|
|
pub eat_cooldown_timer: AtomicI32,
|
|
pub celebration_timer: AtomicI32,
|
|
pub hunt_cooldown_timer: AtomicI32,
|
|
pub admiring_item: Mutex<Option<ItemStack>>,
|
|
}
|
|
|
|
impl PiglinEntity {
|
|
pub const CONVERSION_TIME: i32 = 300;
|
|
pub const INVENTORY_SIZE: usize = 8;
|
|
pub const XP_REWARD: u32 = 5;
|
|
|
|
pub const ADULT_DIMENSIONS: EntityDimensions = EntityDimensions {
|
|
width: 0.6,
|
|
height: 1.95,
|
|
eye_height: 1.79,
|
|
};
|
|
pub const BABY_DIMENSIONS: EntityDimensions = EntityDimensions {
|
|
width: 0.49,
|
|
height: 0.98,
|
|
eye_height: 0.78,
|
|
};
|
|
|
|
pub fn new(entity: Entity) -> Arc<Self> {
|
|
let mob_entity = MobEntity::new(entity);
|
|
let piglin = Self {
|
|
mob_entity,
|
|
immune_to_zombification: AtomicBool::new(false),
|
|
time_in_overworld: AtomicI32::new(0),
|
|
is_baby: AtomicBool::new(false),
|
|
cannot_hunt: AtomicBool::new(false),
|
|
is_charging_crossbow: AtomicBool::new(false),
|
|
is_dancing: AtomicBool::new(false),
|
|
inventory: Mutex::new(Vec::new()),
|
|
admire_timer: AtomicI32::new(0),
|
|
admiring_disabled_timer: AtomicI32::new(0),
|
|
eat_cooldown_timer: AtomicI32::new(0),
|
|
celebration_timer: AtomicI32::new(0),
|
|
hunt_cooldown_timer: AtomicI32::new(0),
|
|
admiring_item: Mutex::new(None),
|
|
};
|
|
let mob_arc = Arc::new(piglin);
|
|
let mob_weak: Weak<dyn Mob> = {
|
|
let mob_arc: Arc<dyn Mob> = mob_arc.clone();
|
|
Arc::downgrade(&mob_arc)
|
|
};
|
|
|
|
{
|
|
let mut goal_selector = mob_arc
|
|
.mob_entity
|
|
.goals_selector
|
|
.lock()
|
|
.unwrap_or_else(std::sync::PoisonError::into_inner);
|
|
|
|
goal_selector.add_goal(0, Box::new(SwimGoal::default()));
|
|
goal_selector.add_goal(1, Box::new(OpenDoorGoal::new(true)));
|
|
goal_selector.add_goal(2, Box::new(MeleeAttackGoal::new(1.0, true)));
|
|
goal_selector.add_goal(3, Box::new(RangedCrossbowAttackGoal::new(1.0, 8.0)));
|
|
goal_selector.add_goal(5, Box::new(WanderAroundGoal::new(1.0)));
|
|
goal_selector.add_goal(
|
|
6,
|
|
LookAtEntityGoal::with_default(mob_weak.clone(), &EntityType::PLAYER, 8.0),
|
|
);
|
|
goal_selector.add_goal(7, Box::new(RandomLookAroundGoal::default()));
|
|
|
|
let mut target_selector = mob_arc
|
|
.mob_entity
|
|
.target_selector
|
|
.lock()
|
|
.unwrap_or_else(std::sync::PoisonError::into_inner);
|
|
|
|
// Retaliate when attacked
|
|
target_selector.add_goal(1, Box::new(RevengeGoal::new(true)));
|
|
|
|
// Hostile to players unless wearing safe gold armor
|
|
target_selector.add_goal(
|
|
2,
|
|
Box::new(ActiveTargetGoal::new(
|
|
&mob_arc.mob_entity,
|
|
&EntityType::PLAYER,
|
|
10,
|
|
true,
|
|
false,
|
|
Some(|target: Arc<LivingEntity>, _world: Arc<World>| {
|
|
Box::pin(async move { !PiglinAi::is_wearing_safe_armor(&target).await })
|
|
}),
|
|
)),
|
|
);
|
|
|
|
// Hostile to wither skeletons and withers
|
|
target_selector.add_goal(
|
|
3,
|
|
ActiveTargetGoal::with_default(
|
|
&mob_arc.mob_entity,
|
|
&EntityType::WITHER_SKELETON,
|
|
true,
|
|
),
|
|
);
|
|
target_selector.add_goal(
|
|
3,
|
|
ActiveTargetGoal::with_default(&mob_arc.mob_entity, &EntityType::WITHER, true),
|
|
);
|
|
|
|
// Adults that can hunt are hostile to hoglins
|
|
let piglin_clone = mob_arc.clone();
|
|
target_selector.add_goal(
|
|
4,
|
|
Box::new(ActiveTargetGoal::new(
|
|
&mob_arc.mob_entity,
|
|
&EntityType::HOGLIN,
|
|
10,
|
|
true,
|
|
false,
|
|
Some(move |_target: Arc<LivingEntity>, _world: Arc<World>| {
|
|
let piglin = piglin_clone.clone();
|
|
Box::pin(async move { piglin.is_adult() && piglin.can_hunt() })
|
|
}),
|
|
)),
|
|
);
|
|
};
|
|
|
|
mob_arc
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn is_immune_to_zombification(&self) -> bool {
|
|
self.immune_to_zombification.load(Ordering::Relaxed)
|
|
}
|
|
|
|
pub fn set_immune_to_zombification(&self, immune: bool) {
|
|
self.immune_to_zombification
|
|
.store(immune, Ordering::Relaxed);
|
|
self.mob_entity.living_entity.entity.send_meta_data(
|
|
&[Metadata::new(
|
|
tracked_data::piglin::DATA_IMMUNE_TO_ZOMBIFICATION,
|
|
immune,
|
|
)],
|
|
None,
|
|
);
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn is_converting(&self, world: &World) -> bool {
|
|
!self.is_immune_to_zombification()
|
|
&& !self.mob_entity.is_no_ai()
|
|
&& world.dimension.minecraft_name != Dimension::THE_NETHER.minecraft_name
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn is_baby(&self) -> bool {
|
|
self.is_baby.load(Ordering::Relaxed)
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn is_adult(&self) -> bool {
|
|
!self.is_baby()
|
|
}
|
|
|
|
pub fn set_baby(&self, baby: bool) {
|
|
self.is_baby.store(baby, Ordering::Relaxed);
|
|
let entity = &self.mob_entity.living_entity.entity;
|
|
entity.send_meta_data(
|
|
&[Metadata::new(tracked_data::piglin::DATA_BABY_ID, baby)],
|
|
None,
|
|
);
|
|
if baby {
|
|
entity.entity_dimension.store(Self::BABY_DIMENSIONS);
|
|
} else {
|
|
entity.entity_dimension.store(Self::ADULT_DIMENSIONS);
|
|
}
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn is_charging_crossbow(&self) -> bool {
|
|
self.is_charging_crossbow.load(Ordering::Relaxed)
|
|
}
|
|
|
|
pub fn set_charging_crossbow(&self, is_charging: bool) {
|
|
self.is_charging_crossbow
|
|
.store(is_charging, Ordering::Relaxed);
|
|
self.mob_entity.living_entity.entity.send_meta_data(
|
|
&[Metadata::new(
|
|
tracked_data::piglin::DATA_IS_CHARGING_CROSSBOW,
|
|
is_charging,
|
|
)],
|
|
None,
|
|
);
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn is_dancing(&self) -> bool {
|
|
self.is_dancing.load(Ordering::Relaxed)
|
|
}
|
|
|
|
pub fn set_dancing(&self, is_dancing: bool) {
|
|
self.is_dancing.store(is_dancing, Ordering::Relaxed);
|
|
self.mob_entity.living_entity.entity.send_meta_data(
|
|
&[Metadata::new(
|
|
tracked_data::piglin::DATA_IS_DANCING,
|
|
is_dancing,
|
|
)],
|
|
None,
|
|
);
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn can_hunt(&self) -> bool {
|
|
!self.cannot_hunt.load(Ordering::Relaxed)
|
|
&& self.hunt_cooldown_timer.load(Ordering::Relaxed) <= 0
|
|
}
|
|
|
|
pub fn set_cannot_hunt(&self, cannot_hunt: bool) {
|
|
self.cannot_hunt.store(cannot_hunt, Ordering::Relaxed);
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn is_admiring(&self) -> bool {
|
|
self.admire_timer.load(Ordering::Relaxed) > 0
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn is_admiring_disabled(&self) -> bool {
|
|
self.admiring_disabled_timer.load(Ordering::Relaxed) > 0
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn has_eaten_recently(&self) -> bool {
|
|
self.eat_cooldown_timer.load(Ordering::Relaxed) > 0
|
|
}
|
|
|
|
pub async fn start_admiring(&self, item: ItemStack) {
|
|
self.admire_timer
|
|
.store(PiglinAi::ADMIRE_DURATION, Ordering::Relaxed);
|
|
*self.admiring_item.lock().await = Some(item.clone());
|
|
|
|
let mut equip = self.mob_entity.living_entity.entity_equipment.lock().await;
|
|
equip.put(&EquipmentSlot::OFF_HAND, item);
|
|
|
|
let entity = &self.mob_entity.living_entity.entity;
|
|
let pos = entity.pos.load();
|
|
entity.world.load().play_sound(
|
|
Sound::EntityPiglinAdmiringItem,
|
|
SoundCategory::Hostile,
|
|
&pos,
|
|
);
|
|
}
|
|
|
|
pub async fn stop_holding_off_hand_item(&self, bartering_enabled: bool) {
|
|
let admired_item = {
|
|
let mut guard = self.admiring_item.lock().await;
|
|
guard.take()
|
|
};
|
|
|
|
let _ = {
|
|
let mut equip = self.mob_entity.living_entity.entity_equipment.lock().await;
|
|
equip.put(&EquipmentSlot::OFF_HAND, ItemStack::EMPTY.clone())
|
|
};
|
|
|
|
let Some(item) = admired_item else {
|
|
return;
|
|
};
|
|
|
|
if self.is_adult() {
|
|
let is_barter = PiglinAi::is_barter_currency(&item);
|
|
if bartering_enabled && is_barter {
|
|
let outcomes = PiglinAi::get_barter_response_items();
|
|
let entity = &self.mob_entity.living_entity.entity;
|
|
|
|
let mut event =
|
|
crate::plugin::api::events::entity::piglin_barter::PiglinBarterEvent::new(
|
|
entity.entity_id,
|
|
item,
|
|
outcomes,
|
|
);
|
|
if let Some(server) = entity.world.load().server.upgrade() {
|
|
server.plugin_manager.fire(&server, &mut event).await;
|
|
}
|
|
|
|
if !event.cancelled {
|
|
PiglinAi::throw_items(self, event.outcome, None).await;
|
|
}
|
|
} else if !is_barter {
|
|
let remainder = self.add_to_inventory(item).await;
|
|
if let Some(rem) = remainder {
|
|
PiglinAi::throw_items(self, vec![rem], None).await;
|
|
}
|
|
}
|
|
} else {
|
|
let remainder = self.add_to_inventory(item).await;
|
|
if let Some(rem) = remainder {
|
|
PiglinAi::throw_items(self, vec![rem], None).await;
|
|
}
|
|
}
|
|
}
|
|
|
|
pub async fn cancel_admiring(&self) {
|
|
if self.is_admiring() {
|
|
self.admire_timer.store(0, Ordering::Relaxed);
|
|
let item = {
|
|
let mut guard = self.admiring_item.lock().await;
|
|
guard.take()
|
|
};
|
|
if let Some(item) = item {
|
|
let _ = {
|
|
let mut equip = self.mob_entity.living_entity.entity_equipment.lock().await;
|
|
equip.put(&EquipmentSlot::OFF_HAND, ItemStack::EMPTY.clone())
|
|
};
|
|
PiglinAi::throw_items(self, vec![item], None).await;
|
|
}
|
|
}
|
|
}
|
|
|
|
pub async fn was_hurt_by(&self, attacker: Option<&dyn EntityBase>) {
|
|
self.cancel_admiring().await;
|
|
self.set_dancing(false);
|
|
self.celebration_timer.store(0, Ordering::Relaxed);
|
|
|
|
if let Some(attacker_entity) = attacker
|
|
&& attacker_entity.get_entity().entity_type.id == EntityType::PLAYER.id
|
|
{
|
|
self.admiring_disabled_timer
|
|
.store(PiglinAi::ADMIRING_DISABLED_DURATION, Ordering::Relaxed);
|
|
}
|
|
}
|
|
|
|
pub async fn add_to_inventory(&self, item: ItemStack) -> Option<ItemStack> {
|
|
let mut inv = self.inventory.lock().await;
|
|
if inv.len() < Self::INVENTORY_SIZE {
|
|
inv.push(item);
|
|
None
|
|
} else {
|
|
Some(item)
|
|
}
|
|
}
|
|
|
|
pub async fn drop_inventory(&self) {
|
|
let items = {
|
|
let mut inv = self.inventory.lock().await;
|
|
std::mem::take(&mut *inv)
|
|
};
|
|
let entity = &self.mob_entity.living_entity.entity;
|
|
let world = entity.world.load();
|
|
let pos = entity.pos.load();
|
|
for item in items {
|
|
if !item.is_empty() {
|
|
let item_entity = crate::entity::item::ItemEntity::new(
|
|
Entity::new(world.clone(), pos, &EntityType::ITEM),
|
|
item,
|
|
);
|
|
world.spawn_entity(Arc::new(item_entity)).await;
|
|
}
|
|
}
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn check_piglin_spawn_rules(world: &World, pos: &BlockPos) -> bool {
|
|
let below = BlockPos::new(pos.0.x, pos.0.y - 1, pos.0.z);
|
|
let state = world.get_block_state(&below);
|
|
state.id != Block::NETHER_WART_BLOCK.default_state.id
|
|
}
|
|
|
|
async fn convert_to_zombified(&self) {
|
|
let entity = &self.mob_entity.living_entity.entity;
|
|
let world = entity.world.load();
|
|
let pos = entity.pos.load();
|
|
|
|
if world.level_info.load().difficulty != pumpkin_util::Difficulty::Peaceful {
|
|
world.play_sound(
|
|
Sound::EntityPiglinConvertedToZombified,
|
|
SoundCategory::Hostile,
|
|
&pos,
|
|
);
|
|
}
|
|
|
|
self.drop_inventory().await;
|
|
|
|
let zombified = crate::entity::r#type::from_type(
|
|
&EntityType::ZOMBIFIED_PIGLIN,
|
|
pos,
|
|
&world,
|
|
uuid::Uuid::new_v4(),
|
|
);
|
|
|
|
let zombified_base = zombified.get_entity();
|
|
zombified_base.set_rotation(entity.yaw.load(), entity.pitch.load());
|
|
zombified_base.head_yaw.store(entity.head_yaw.load());
|
|
zombified_base.velocity.store(entity.velocity.load());
|
|
|
|
if let Some(living) = zombified.get_living_entity() {
|
|
living.set_health(self.mob_entity.living_entity.health.load());
|
|
}
|
|
|
|
if let Some(custom_name) = &**entity.custom_name.load() {
|
|
zombified_base.set_custom_name(custom_name.clone());
|
|
}
|
|
|
|
{
|
|
let src_equip = self.mob_entity.living_entity.entity_equipment.lock().await;
|
|
if let Some(living) = zombified.get_living_entity() {
|
|
let mut dst_equip = living.entity_equipment.lock().await;
|
|
for (slot, item) in &src_equip.equipment {
|
|
dst_equip.put(slot, item.clone());
|
|
}
|
|
}
|
|
}
|
|
|
|
world.spawn_entity(zombified).await;
|
|
entity.remove().await;
|
|
}
|
|
}
|
|
|
|
impl Mob for PiglinEntity {
|
|
fn get_mob_entity(&self) -> &MobEntity {
|
|
&self.mob_entity
|
|
}
|
|
|
|
fn populate_default_equipment_slots<'a>(
|
|
&'a self,
|
|
_world: &'a Arc<World>,
|
|
_difficulty: &'a RegionalDifficulty,
|
|
) -> EntityBaseFuture<'a, ()> {
|
|
Box::pin(async move {
|
|
if !self.is_baby.load(Ordering::Relaxed) {
|
|
let living = &self.mob_entity.living_entity;
|
|
let mut equipment = living.entity_equipment.lock().await;
|
|
|
|
// Spawn weapon: 50% crossbow, 5% golden spear (10% of remaining 50%), 45% golden sword
|
|
let weapon = if rand::random::<f32>() < 0.5 {
|
|
&Item::CROSSBOW
|
|
} else if rand::random_range(0..10) == 0 {
|
|
&Item::GOLDEN_SPEAR
|
|
} else {
|
|
&Item::GOLDEN_SWORD
|
|
};
|
|
equipment.put(&EquipmentSlot::MAIN_HAND, ItemStack::new(1, weapon));
|
|
|
|
// Armor: 10% chance per piece for golden armor
|
|
if rand::random::<f32>() < 0.1 {
|
|
equipment.put(
|
|
&EquipmentSlot::HEAD,
|
|
ItemStack::new(1, &Item::GOLDEN_HELMET),
|
|
);
|
|
}
|
|
if rand::random::<f32>() < 0.1 {
|
|
equipment.put(
|
|
&EquipmentSlot::CHEST,
|
|
ItemStack::new(1, &Item::GOLDEN_CHESTPLATE),
|
|
);
|
|
}
|
|
if rand::random::<f32>() < 0.1 {
|
|
equipment.put(
|
|
&EquipmentSlot::LEGS,
|
|
ItemStack::new(1, &Item::GOLDEN_LEGGINGS),
|
|
);
|
|
}
|
|
if rand::random::<f32>() < 0.1 {
|
|
equipment.put(&EquipmentSlot::FEET, ItemStack::new(1, &Item::GOLDEN_BOOTS));
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
fn mob_init_data_tracker(&self) -> EntityBaseFuture<'_, ()> {
|
|
Box::pin(async move {
|
|
let entity = self.get_entity();
|
|
let mut meta = Vec::new();
|
|
if self.is_immune_to_zombification() {
|
|
meta.push(Metadata::new(
|
|
tracked_data::piglin::DATA_IMMUNE_TO_ZOMBIFICATION,
|
|
true,
|
|
));
|
|
}
|
|
if self.is_baby() {
|
|
meta.push(Metadata::new(tracked_data::piglin::DATA_BABY_ID, true));
|
|
}
|
|
if self.is_charging_crossbow() {
|
|
meta.push(Metadata::new(
|
|
tracked_data::piglin::DATA_IS_CHARGING_CROSSBOW,
|
|
true,
|
|
));
|
|
}
|
|
if self.is_dancing() {
|
|
meta.push(Metadata::new(tracked_data::piglin::DATA_IS_DANCING, true));
|
|
}
|
|
if !meta.is_empty() {
|
|
entity.send_meta_data(&meta, None);
|
|
}
|
|
})
|
|
}
|
|
|
|
fn mob_write_nbt<'a>(&'a self, nbt: &'a mut NbtCompound) -> NbtFuture<'a, ()> {
|
|
Box::pin(async move {
|
|
if self.is_immune_to_zombification() {
|
|
nbt.put_bool("IsImmuneToZombification", true);
|
|
}
|
|
let time_in_overworld = self.time_in_overworld.load(Ordering::Relaxed);
|
|
if time_in_overworld > 0 {
|
|
nbt.put_int("TimeInOverworld", time_in_overworld);
|
|
}
|
|
nbt.put_bool("CanPickUpLoot", true);
|
|
if self.is_baby() {
|
|
nbt.put_bool("IsBaby", true);
|
|
}
|
|
if !self.can_hunt() {
|
|
nbt.put_bool("CannotHunt", true);
|
|
}
|
|
if self.is_charging_crossbow() {
|
|
nbt.put_bool("IsChargingCrossbow", true);
|
|
}
|
|
if self.is_dancing() {
|
|
nbt.put_bool("IsDancing", true);
|
|
}
|
|
|
|
let inv = self.inventory.lock().await;
|
|
if !inv.is_empty() {
|
|
let mut items_tag = Vec::new();
|
|
for item in inv.iter() {
|
|
if !item.is_empty() {
|
|
let mut item_nbt = NbtCompound::new();
|
|
item.write_item_stack(&mut item_nbt);
|
|
items_tag.push(NbtTag::Compound(item_nbt));
|
|
}
|
|
}
|
|
if !items_tag.is_empty() {
|
|
nbt.put_list("Inventory", items_tag);
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
fn mob_read_nbt<'a>(&'a self, nbt: &'a NbtCompound) -> NbtFuture<'a, ()> {
|
|
Box::pin(async move {
|
|
if let Some(immune) = nbt.get_bool("IsImmuneToZombification") {
|
|
self.set_immune_to_zombification(immune);
|
|
}
|
|
if let Some(time) = nbt.get_int("TimeInOverworld") {
|
|
self.time_in_overworld.store(time, Ordering::Relaxed);
|
|
}
|
|
if let Some(baby) = nbt.get_bool("IsBaby") {
|
|
self.set_baby(baby);
|
|
}
|
|
if let Some(cannot_hunt) = nbt.get_bool("CannotHunt") {
|
|
self.set_cannot_hunt(cannot_hunt);
|
|
}
|
|
if let Some(charging) = nbt.get_bool("IsChargingCrossbow") {
|
|
self.set_charging_crossbow(charging);
|
|
}
|
|
if let Some(dancing) = nbt.get_bool("IsDancing") {
|
|
self.set_dancing(dancing);
|
|
}
|
|
if let Some(inv_list) = nbt.get_list("Inventory") {
|
|
let mut inv = self.inventory.lock().await;
|
|
inv.clear();
|
|
for tag in inv_list {
|
|
if let Some(compound) = tag.extract_compound()
|
|
&& let Some(stack) = ItemStack::read_item_stack(compound)
|
|
{
|
|
inv.push(stack);
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
fn mob_interact<'a>(
|
|
&'a self,
|
|
player: &'a Arc<Player>,
|
|
item_stack: &'a mut ItemStack,
|
|
) -> EntityBaseFuture<'a, bool> {
|
|
Box::pin(async move {
|
|
if PiglinAi::can_admire(self, item_stack) {
|
|
let mut given = item_stack.clone();
|
|
given.item_count = 1;
|
|
if player.gamemode.load() != pumpkin_util::GameMode::Creative {
|
|
item_stack.item_count -= 1;
|
|
}
|
|
self.start_admiring(given).await;
|
|
return true;
|
|
}
|
|
self.mob_entity.mob_interact(player, item_stack).await
|
|
})
|
|
}
|
|
|
|
fn mob_tick<'a>(&'a self, _caller: &'a Arc<dyn EntityBase>) -> EntityBaseFuture<'a, ()> {
|
|
Box::pin(async move {
|
|
let entity = &self.mob_entity.living_entity.entity;
|
|
if !entity.is_alive() {
|
|
return;
|
|
}
|
|
|
|
let world = entity.world.load();
|
|
if self.is_converting(&world) {
|
|
let time = self.time_in_overworld.fetch_add(1, Ordering::Relaxed) + 1;
|
|
if time > Self::CONVERSION_TIME {
|
|
self.convert_to_zombified().await;
|
|
}
|
|
} else {
|
|
self.time_in_overworld.store(0, Ordering::Relaxed);
|
|
}
|
|
|
|
if self.admiring_disabled_timer.load(Ordering::Relaxed) > 0 {
|
|
self.admiring_disabled_timer.fetch_sub(1, Ordering::Relaxed);
|
|
}
|
|
if self.eat_cooldown_timer.load(Ordering::Relaxed) > 0 {
|
|
self.eat_cooldown_timer.fetch_sub(1, Ordering::Relaxed);
|
|
}
|
|
if self.hunt_cooldown_timer.load(Ordering::Relaxed) > 0 {
|
|
self.hunt_cooldown_timer.fetch_sub(1, Ordering::Relaxed);
|
|
}
|
|
if self.celebration_timer.load(Ordering::Relaxed) > 0 {
|
|
let remaining = self.celebration_timer.fetch_sub(1, Ordering::Relaxed) - 1;
|
|
if remaining <= 0 {
|
|
self.set_dancing(false);
|
|
}
|
|
}
|
|
|
|
if self.admire_timer.load(Ordering::Relaxed) > 0 {
|
|
let remaining = self.admire_timer.fetch_sub(1, Ordering::Relaxed) - 1;
|
|
if remaining <= 0 {
|
|
self.stop_holding_off_hand_item(true).await;
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
fn on_damage<'a>(
|
|
&'a self,
|
|
_damage_type: pumpkin_data::damage::DamageType,
|
|
source: Option<&'a dyn EntityBase>,
|
|
) -> EntityBaseFuture<'a, ()> {
|
|
Box::pin(async move {
|
|
if self.mob_entity.living_entity.dead.load(Ordering::Relaxed) {
|
|
self.drop_inventory().await;
|
|
} else {
|
|
self.was_hurt_by(source).await;
|
|
}
|
|
})
|
|
}
|
|
|
|
fn as_crossbow_attack_mob(&self) -> Option<&dyn CrossbowAttackMob> {
|
|
Some(self)
|
|
}
|
|
|
|
fn get_base_experience_reward(&self) -> u32 {
|
|
Self::XP_REWARD
|
|
}
|
|
}
|
|
|
|
impl CrossbowAttackMob for PiglinEntity {
|
|
fn set_charging_crossbow(&self, is_charging: bool) {
|
|
self.set_charging_crossbow(is_charging);
|
|
}
|
|
|
|
fn is_charging_crossbow(&self) -> bool {
|
|
self.is_charging_crossbow()
|
|
}
|
|
}
|