mirror of
https://github.com/4jcraft/4jcraft.git
synced 2026-04-30 10:33:38 +00:00
349 lines
12 KiB
C++
349 lines
12 KiB
C++
#include "../../Platform/stdafx.h"
|
|
#include "../../Headers/net.minecraft.world.level.h"
|
|
#include "../../Headers/net.minecraft.world.level.tile.h"
|
|
#include "../../Headers/net.minecraft.world.h"
|
|
#include "../../Headers/net.minecraft.world.item.h"
|
|
#include "../../Headers/net.minecraft.world.effect.h"
|
|
#include "../../Headers/net.minecraft.world.entity.ai.goal.h"
|
|
#include "../../Headers/net.minecraft.world.entity.ai.goal.target.h"
|
|
#include "../../Headers/net.minecraft.world.entity.ai.navigation.h"
|
|
#include "../../Headers/net.minecraft.world.entity.npc.h"
|
|
#include "../../Headers/net.minecraft.world.entity.player.h"
|
|
#include "Zombie.h"
|
|
#include "../../Stats/GenericStats.h"
|
|
#include "../../../Minecraft.Client/Textures/Textures.h"
|
|
#include "../../Headers/net.minecraft.world.entity.h"
|
|
#include "../../Util/SoundTypes.h"
|
|
|
|
Zombie::Zombie(Level* level) : Monster(level) {
|
|
// 4J Stu - This function call had to be moved here from the Entity ctor to
|
|
// ensure that the derived version of the function is called
|
|
this->defineSynchedData();
|
|
|
|
// 4J Stu - This function call had to be moved here from the Entity ctor to
|
|
// ensure that the derived version of the function is called
|
|
health = getMaxHealth();
|
|
|
|
this->textureIdx = TN_MOB_ZOMBIE; // 4J was L"/mob/zombie.png";
|
|
runSpeed = 0.23f;
|
|
attackDamage = 4;
|
|
|
|
villagerConversionTime = 0;
|
|
|
|
registeredBBWidth = -1;
|
|
registeredBBHeight = 0;
|
|
|
|
setSize(bbWidth, bbHeight);
|
|
|
|
getNavigation()->setCanOpenDoors(true);
|
|
goalSelector.addGoal(0, new FloatGoal(this));
|
|
goalSelector.addGoal(1, new BreakDoorGoal(this));
|
|
goalSelector.addGoal(
|
|
2, new MeleeAttackGoal(this, eTYPE_PLAYER, runSpeed, false));
|
|
goalSelector.addGoal(
|
|
3, new MeleeAttackGoal(this, eTYPE_VILLAGER, runSpeed, true));
|
|
goalSelector.addGoal(4, new MoveTowardsRestrictionGoal(this, runSpeed));
|
|
goalSelector.addGoal(5, new MoveThroughVillageGoal(this, runSpeed, false));
|
|
goalSelector.addGoal(6, new RandomStrollGoal(this, runSpeed));
|
|
goalSelector.addGoal(7, new LookAtPlayerGoal(this, typeid(Player), 8));
|
|
goalSelector.addGoal(7, new RandomLookAroundGoal(this));
|
|
|
|
targetSelector.addGoal(1, new HurtByTargetGoal(this, false));
|
|
targetSelector.addGoal(
|
|
2, new NearestAttackableTargetGoal(this, typeid(Player), 16, 0, true));
|
|
targetSelector.addGoal(2, new NearestAttackableTargetGoal(
|
|
this, typeid(Villager), 16, 0, false));
|
|
}
|
|
|
|
void Zombie::defineSynchedData() {
|
|
Monster::defineSynchedData();
|
|
|
|
getEntityData()->define(DATA_BABY_ID, (uint8_t)0);
|
|
getEntityData()->define(DATA_VILLAGER_ID, (uint8_t)0);
|
|
getEntityData()->define(DATA_CONVERTING_ID, (uint8_t)0);
|
|
}
|
|
|
|
float Zombie::getWalkingSpeedModifier() {
|
|
return Monster::getWalkingSpeedModifier() * (isBaby() ? 1.5f : 1.0f);
|
|
}
|
|
|
|
int Zombie::getTexture() {
|
|
return isVillager() ? TN_MOB_ZOMBIE_VILLAGER : TN_MOB_ZOMBIE;
|
|
}
|
|
|
|
int Zombie::getMaxHealth() { return 20; }
|
|
|
|
int Zombie::getArmorValue() { return 2; }
|
|
|
|
bool Zombie::useNewAi() { return true; }
|
|
|
|
bool Zombie::isBaby() {
|
|
return getEntityData()->getByte(DATA_BABY_ID) == (uint8_t)1;
|
|
}
|
|
|
|
void Zombie::setBaby(bool baby) {
|
|
getEntityData()->set(DATA_BABY_ID, (uint8_t)1);
|
|
updateSize(isBaby());
|
|
}
|
|
|
|
bool Zombie::isVillager() {
|
|
return getEntityData()->getByte(DATA_VILLAGER_ID) == (uint8_t)1;
|
|
}
|
|
|
|
void Zombie::setVillager(bool villager) {
|
|
getEntityData()->set(DATA_VILLAGER_ID, (uint8_t)(villager ? 1 : 0));
|
|
}
|
|
|
|
void Zombie::aiStep() {
|
|
if (level->isClientSide) {
|
|
updateSize(isBaby());
|
|
} else if (level->isDay() && !level->isClientSide && !isBaby()) {
|
|
float br = getBrightness(1);
|
|
if (br > 0.5f && random->nextFloat() * 30 < (br - 0.4f) * 2 &&
|
|
level->canSeeSky(Mth::floor(x), Mth::floor(y), Mth::floor(z))) {
|
|
setOnFire(8);
|
|
}
|
|
}
|
|
Monster::aiStep();
|
|
}
|
|
|
|
void Zombie::tick() {
|
|
if (!level->isClientSide && isConverting()) {
|
|
int amount = getConversionProgress();
|
|
|
|
villagerConversionTime -= amount;
|
|
|
|
if (villagerConversionTime <= 0) {
|
|
finishConversion();
|
|
}
|
|
}
|
|
|
|
Monster::tick();
|
|
}
|
|
|
|
int Zombie::getAmbientSound() { return eSoundType_MOB_ZOMBIE_AMBIENT; }
|
|
|
|
int Zombie::getHurtSound() { return eSoundType_MOB_ZOMBIE_HURT; }
|
|
|
|
int Zombie::getDeathSound() { return eSoundType_MOB_ZOMBIE_DEATH; }
|
|
|
|
int Zombie::getDeathLoot() { return Item::rotten_flesh_Id; }
|
|
|
|
MobType Zombie::getMobType() { return UNDEAD; }
|
|
|
|
void Zombie::dropRareDeathLoot(int rareLootLevel) {
|
|
switch (random->nextInt(3)) {
|
|
/* case 0:
|
|
spawnAtLocation(Item::sword_iron_Id, 1);
|
|
break;
|
|
case 1:
|
|
spawnAtLocation(Item::helmet_iron_Id, 1);
|
|
break;
|
|
case 2:
|
|
spawnAtLocation(Item::ironIngot_Id, 1);
|
|
break;
|
|
case 3:
|
|
spawnAtLocation(Item::shovel_iron_Id, 1);
|
|
break;*/
|
|
case 0:
|
|
spawnAtLocation(Item::ironIngot_Id, 1);
|
|
break;
|
|
case 1:
|
|
spawnAtLocation(Item::carrots_Id, 1);
|
|
break;
|
|
case 2:
|
|
spawnAtLocation(Item::potato_Id, 1);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void Zombie::addAdditonalSaveData(CompoundTag* tag) {
|
|
Monster::addAdditonalSaveData(tag);
|
|
|
|
if (isBaby()) tag->putBoolean(L"IsBaby", true);
|
|
if (isVillager()) tag->putBoolean(L"IsVillager", true);
|
|
tag->putInt(L"ConversionTime",
|
|
isConverting() ? villagerConversionTime : -1);
|
|
}
|
|
|
|
void Zombie::readAdditionalSaveData(CompoundTag* tag) {
|
|
Monster::readAdditionalSaveData(tag);
|
|
|
|
if (tag->getBoolean(L"IsBaby")) setBaby(true);
|
|
if (tag->getBoolean(L"IsVillager")) setVillager(true);
|
|
if (tag->contains(L"ConversionTime") && tag->getInt(L"ConversionTime") > -1)
|
|
startConverting(tag->getInt(L"ConversionTime"));
|
|
}
|
|
|
|
void Zombie::killed(std::shared_ptr<Mob> mob) {
|
|
Monster::killed(mob);
|
|
|
|
if (level->difficulty >= Difficulty::NORMAL &&
|
|
((mob->GetType() & eTYPE_VILLAGER) == eTYPE_VILLAGER)) {
|
|
if (!level->canCreateMore(GetType(), Level::eSpawnType_Egg)) return;
|
|
if (level->difficulty == Difficulty::NORMAL && random->nextBoolean())
|
|
return;
|
|
|
|
std::shared_ptr<Zombie> zombie =
|
|
std::shared_ptr<Zombie>(new Zombie(level));
|
|
zombie->copyPosition(mob);
|
|
level->removeEntity(mob);
|
|
zombie->finalizeMobSpawn();
|
|
zombie->setVillager(true);
|
|
if (mob->isBaby()) zombie->setBaby(true);
|
|
level->addEntity(zombie);
|
|
|
|
level->levelEvent(nullptr, LevelEvent::SOUND_ZOMBIE_INFECTED, (int)x,
|
|
(int)y, (int)z, 0);
|
|
}
|
|
}
|
|
|
|
void Zombie::finalizeMobSpawn() {
|
|
// 4J Stu - TODO TU15
|
|
#if 0
|
|
canPickUpLoot = random->nextFloat() < CAN_PICK_UP_LOOT_CHANCES[level->difficulty];
|
|
#endif
|
|
|
|
if (level->random->nextFloat() < 0.05f) {
|
|
setVillager(true);
|
|
}
|
|
|
|
// 4J Stu - TODO TU15
|
|
#if 0
|
|
populateDefaultEquipmentSlots();
|
|
populateDefaultEquipmentEnchantments();
|
|
|
|
if (getCarried(SLOT_HELM) == null)
|
|
{
|
|
Calendar cal = level.getCalendar();
|
|
|
|
if (cal.get(Calendar.MONTH) + 1 == 10 && cal.get(Calendar.DAY_OF_MONTH) == 31 && random.nextFloat() < 0.25f) {
|
|
// Halloween! OooOOo! 25% of all skeletons/zombies can wear
|
|
// pumpkins on their heads.
|
|
setEquippedSlot(SLOT_HELM, new ItemInstance(random.nextFloat() < 0.1f ? Tile.litPumpkin : Tile.pumpkin));
|
|
dropChances[SLOT_HELM] = 0;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
bool Zombie::interact(std::shared_ptr<Player> player) {
|
|
std::shared_ptr<ItemInstance> item = player->getSelectedItem();
|
|
|
|
if (item != NULL && item->getItem() == Item::apple_gold &&
|
|
item->getAuxValue() == 0 && isVillager() &&
|
|
hasEffect(MobEffect::weakness)) {
|
|
if (!player->abilities.instabuild) item->count--;
|
|
if (item->count <= 0) {
|
|
player->inventory->setItem(player->inventory->selected, nullptr);
|
|
}
|
|
|
|
if (!level->isClientSide) {
|
|
startConverting(random->nextInt(VILLAGER_CONVERSION_WAIT_MAX -
|
|
VILLAGER_CONVERSION_WAIT_MIN + 1) +
|
|
VILLAGER_CONVERSION_WAIT_MIN);
|
|
|
|
// 4J-JEV, award achievement here, as it is impractical to award
|
|
// when the zombie is actually cured.
|
|
player->awardStat(GenericStats::zombieDoctor(),
|
|
GenericStats::param_zombieDoctor());
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void Zombie::startConverting(int time) {
|
|
villagerConversionTime = time;
|
|
getEntityData()->set(DATA_CONVERTING_ID, (uint8_t)1);
|
|
|
|
removeEffect(MobEffect::weakness->id);
|
|
addEffect(new MobEffectInstance(MobEffect::damageBoost->id, time,
|
|
std::min(level->difficulty - 1, 0)));
|
|
|
|
level->broadcastEntityEvent(shared_from_this(),
|
|
EntityEvent::ZOMBIE_CONVERTING);
|
|
}
|
|
|
|
void Zombie::handleEntityEvent(uint8_t id) {
|
|
if (id == EntityEvent::ZOMBIE_CONVERTING) {
|
|
level->playLocalSound(x + 0.5f, y + 0.5f, z + 0.5f,
|
|
eSoundType_MOB_ZOMBIE_REMEDY,
|
|
1 + random->nextFloat(),
|
|
random->nextFloat() * 0.7f + 0.3f); //, false);
|
|
} else {
|
|
Monster::handleEntityEvent(id);
|
|
}
|
|
}
|
|
|
|
bool Zombie::isConverting() {
|
|
return getEntityData()->getByte(DATA_CONVERTING_ID) == (uint8_t)1;
|
|
}
|
|
|
|
void Zombie::finishConversion() {
|
|
std::shared_ptr<Villager> villager =
|
|
std::shared_ptr<Villager>(new Villager(level));
|
|
villager->copyPosition(shared_from_this());
|
|
villager->finalizeMobSpawn();
|
|
villager->setRewardPlayersInVillage();
|
|
if (isBaby()) villager->setAge(-20 * 60 * 20);
|
|
level->removeEntity(shared_from_this());
|
|
level->addEntity(villager);
|
|
|
|
villager->addEffect(new MobEffectInstance(
|
|
MobEffect::confusion->id, SharedConstants::TICKS_PER_SECOND * 10, 0));
|
|
level->levelEvent(nullptr, LevelEvent::SOUND_ZOMBIE_CONVERTED, (int)x,
|
|
(int)y, (int)z, 0);
|
|
}
|
|
|
|
int Zombie::getConversionProgress() {
|
|
int amount = 1;
|
|
|
|
if (random->nextFloat() < 0.01f) {
|
|
int specialBlocksCount = 0;
|
|
|
|
for (int xx = (int)x - SPECIAL_BLOCK_RADIUS;
|
|
xx < (int)x + SPECIAL_BLOCK_RADIUS &&
|
|
specialBlocksCount < MAX_SPECIAL_BLOCKS_COUNT;
|
|
xx++) {
|
|
for (int yy = (int)y - SPECIAL_BLOCK_RADIUS;
|
|
yy < (int)y + SPECIAL_BLOCK_RADIUS &&
|
|
specialBlocksCount < MAX_SPECIAL_BLOCKS_COUNT;
|
|
yy++) {
|
|
for (int zz = (int)z - SPECIAL_BLOCK_RADIUS;
|
|
zz < (int)z + SPECIAL_BLOCK_RADIUS &&
|
|
specialBlocksCount < MAX_SPECIAL_BLOCKS_COUNT;
|
|
zz++) {
|
|
int tile = level->getTile(xx, yy, zz);
|
|
|
|
if (tile == Tile::ironFence_Id || tile == Tile::bed_Id) {
|
|
if (random->nextFloat() < 0.3f) amount++;
|
|
specialBlocksCount++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return amount;
|
|
}
|
|
|
|
void Zombie::updateSize(bool isBaby) { internalSetSize(isBaby ? .5f : 1.0f); }
|
|
|
|
void Zombie::setSize(float w, float h) {
|
|
bool inited = registeredBBWidth > 0;
|
|
|
|
registeredBBWidth = w;
|
|
registeredBBHeight = h;
|
|
|
|
if (!inited) {
|
|
internalSetSize(1.0f);
|
|
}
|
|
}
|
|
|
|
void Zombie::internalSetSize(float scale) {
|
|
PathfinderMob::setSize(registeredBBWidth * scale,
|
|
registeredBBHeight * scale);
|
|
}
|