Merge branch 'main' into pr/win64-world-saves

# Conflicts:
#	Minecraft.Client/MinecraftServer.cpp
#	README.md

1 files changed, 584 insertions, 0 deletions

diff --git a/Minecraft.World/WitherBoss.cpp b/Minecraft.World/WitherBoss.cpp
new file mode 100644
index 00000000..676f07d9
--- /dev/null
+++ b/Minecraft.World/WitherBoss.cpp
@@ -0,0 +1,584 @@
+#include "stdafx.h"
+#include "net.minecraft.world.h"
+#include "net.minecraft.world.damagesource.h"
+#include "net.minecraft.world.entity.ai.attributes.h"
+#include "net.minecraft.world.entity.ai.goal.h"
+#include "net.minecraft.world.entity.ai.goal.target.h"
+#include "net.minecraft.world.entity.ai.navigation.h"
+#include "net.minecraft.world.entity.monster.h"
+#include "net.minecraft.world.entity.projectile.h"
+#include "net.minecraft.world.entity.h"
+#include "net.minecraft.world.item.h"
+#include "net.minecraft.world.level.h"
+#include "net.minecraft.world.level.tile.h"
+#include "net.minecraft.world.phys.h"
+#include "Mth.h"
+
+#include "SoundTypes.h"
+
+#include "WitherBoss.h"
+
+bool LivingEntitySelector::matches(shared_ptr<Entity> entity) const
+{
+	if ( entity->instanceof(eTYPE_LIVINGENTITY) )
+	{
+		return dynamic_pointer_cast<LivingEntity>(entity)->getMobType() != UNDEAD;
+	}
+	else
+	{
+		return false;
+	}
+}
+
+EntitySelector *WitherBoss::livingEntitySelector = new LivingEntitySelector(); 
+
+WitherBoss::WitherBoss(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();
+	registerAttributes();
+	setHealth(getMaxHealth());
+
+	for(unsigned int i = 0; i < 2; ++i)
+	{	
+		xRotHeads[i] = 0.0f;
+		yRotHeads[i] = 0.0f;
+		xRotOHeads[i] = 0.0f;
+		yRotOHeads[i] = 0.0f;
+		nextHeadUpdate[i] = 0;
+		idleHeadUpdates[i] = 0;
+	}
+	destroyBlocksTick = 0;
+
+	setSize(.9f, 4);
+
+	//        noPhysics = true;
+	fireImmune = true;
+
+	//        noCulling = true;
+
+	getNavigation()->setCanFloat(true);
+
+	goalSelector.addGoal(0, new FloatGoal(this));
+	goalSelector.addGoal(2, new RangedAttackGoal(this, this, 1.0, SharedConstants::TICKS_PER_SECOND * 2, 20));
+
+	goalSelector.addGoal(5, new RandomStrollGoal(this, 1.0));
+	goalSelector.addGoal(6, 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(Mob), 0, false, false, livingEntitySelector));
+
+	xpReward = Enemy::XP_REWARD_BOSS;
+}
+
+void WitherBoss::defineSynchedData()
+{
+	Monster::defineSynchedData();
+
+	entityData->define(DATA_TARGET_A, (int)0);
+	entityData->define(DATA_TARGET_B, (int)0);
+	entityData->define(DATA_TARGET_C, (int)0);
+	entityData->define(DATA_ID_INV, (int)0);
+}
+
+void WitherBoss::addAdditonalSaveData(CompoundTag *entityTag)
+{
+	Monster::addAdditonalSaveData(entityTag);
+
+	entityTag->putInt(L"Invul", getInvulnerableTicks());
+}
+
+void WitherBoss::readAdditionalSaveData(CompoundTag *tag)
+{
+	Monster::readAdditionalSaveData(tag);
+
+	setInvulnerableTicks(tag->getInt(L"Invul"));
+}
+
+float WitherBoss::getShadowHeightOffs()
+{
+	return bbHeight / 8;
+}
+
+int WitherBoss::getAmbientSound()
+{
+	return eSoundType_MOB_WITHER_IDLE; //"mob.wither.idle";
+}
+
+int WitherBoss::getHurtSound()
+{
+	return eSoundType_MOB_WITHER_HURT; //"mob.wither.hurt";
+}
+
+int WitherBoss::getDeathSound()
+{
+	return eSoundType_MOB_WITHER_DEATH; //"mob.wither.death";
+}
+
+void WitherBoss::aiStep()
+{
+	yd *= 0.6f;
+
+	if (!level->isClientSide && getAlternativeTarget(0) > 0)
+	{
+		shared_ptr<Entity> e = level->getEntity(getAlternativeTarget(0));
+		if (e != NULL)
+		{
+			if ((y < e->y) || (!isPowered() && y < (e->y + 5)))
+			{
+				if (yd < 0)
+				{
+					yd = 0;
+				}
+				yd += (.5f - yd) * .6f;
+			}
+
+			double xdist = e->x - x;
+			double zdist = e->z - z;
+			double distSqr = xdist * xdist + zdist * zdist;
+			if (distSqr > 9)
+			{
+				double sd = Mth::sqrt(distSqr);
+				xd += ((xdist / sd) * .5f - xd) * .6f;
+				zd += ((zdist / sd) * .5f - zd) * .6f;
+			}
+		}
+	}
+	if ((xd * xd + zd * zd) > .05f)
+	{
+		yRot = (float) atan2(zd, xd) * Mth::RADDEG - 90;
+	}
+	Monster::aiStep();
+
+
+	for (int i = 0; i < 2; i++)
+	{
+		yRotOHeads[i] = yRotHeads[i];
+		xRotOHeads[i] = xRotHeads[i];
+	}
+
+	for (int i = 0; i < 2; i++)
+	{
+		int entityId = getAlternativeTarget(i + 1);
+		shared_ptr<Entity> e = nullptr;
+		if (entityId > 0)
+		{
+			e = level->getEntity(entityId);
+		}
+		if (e != NULL)
+		{
+			double hx = getHeadX(i + 1);
+			double hy = getHeadY(i + 1);
+			double hz = getHeadZ(i + 1);
+
+			double xd = e->x - hx;
+			double yd = e->y + e->getHeadHeight() - hy;
+			double zd = e->z - hz;
+			double sd = Mth::sqrt(xd * xd + zd * zd);
+
+			float yRotD = (float) (atan2(zd, xd) * 180 / PI) - 90;
+			float xRotD = (float) -(atan2(yd, sd) * 180 / PI);
+			xRotHeads[i] = rotlerp(xRotHeads[i], xRotD, 40);
+			yRotHeads[i] = rotlerp(yRotHeads[i], yRotD, 10);
+
+
+		}
+		else
+		{
+			yRotHeads[i] = rotlerp(yRotHeads[i], yBodyRot, 10);
+		}
+	}
+	bool _isPowered = isPowered();
+	for (int i = 0; i < 3; i++)
+	{
+		double hx = getHeadX(i);
+		double hy = getHeadY(i);
+		double hz = getHeadZ(i);
+
+		level->addParticle(eParticleType_smoke, hx + random->nextGaussian() * .3f, hy + random->nextGaussian() * .3f, hz + random->nextGaussian() * .3f, 0, 0, 0);
+		if (_isPowered && level->random->nextInt(4) == 0)
+		{
+			level->addParticle(eParticleType_mobSpell, hx + random->nextGaussian() * .3f, hy + random->nextGaussian() * .3f, hz + random->nextGaussian() * .3f, .7f, .7f, .5f);
+		}
+	}
+	if (getInvulnerableTicks() > 0)
+	{
+		for (int i = 0; i < 3; i++)
+		{
+			level->addParticle(eParticleType_mobSpell, x + random->nextGaussian() * 1.0f, y + random->nextFloat() * 3.3f, z + random->nextGaussian() * 1.0f, .7f, .7f, .9f);
+		}
+	}
+}
+
+void WitherBoss::newServerAiStep()
+{
+	if (getInvulnerableTicks() > 0)
+	{
+		int newCount = getInvulnerableTicks() - 1;
+
+		if (newCount <= 0)
+		{
+			level->explode(shared_from_this(), x, y + getHeadHeight(), z, 7, false, level->getGameRules()->getBoolean(GameRules::RULE_MOBGRIEFING));
+			level->globalLevelEvent(LevelEvent::SOUND_WITHER_BOSS_SPAWN, (int) x, (int) y, (int) z, 0);
+		}
+
+		setInvulnerableTicks(newCount);
+		if (tickCount % 10 == 0)
+		{
+			heal(10);
+		}
+
+		return;
+	}
+
+	Monster::newServerAiStep();
+
+	for (int i = 1; i < 3; i++)
+	{
+		if (tickCount >= nextHeadUpdate[i - 1])
+		{
+			nextHeadUpdate[i - 1] = tickCount + SharedConstants::TICKS_PER_SECOND / 2 + random->nextInt(SharedConstants::TICKS_PER_SECOND / 2);
+
+			if (level->difficulty >= Difficulty::NORMAL && idleHeadUpdates[i - 1]++ > 15)
+			{
+				float hrange = 10;
+				float vrange = 5;
+				double xt = Mth::nextDouble(random, x - hrange, x + hrange);
+				double yt = Mth::nextDouble(random, y - vrange, y + vrange);
+				double zt = Mth::nextDouble(random, z - hrange, z + hrange);
+				performRangedAttack(i + 1, xt, yt, zt, true);
+				idleHeadUpdates[i - 1] = 0;
+			}
+
+			int headTarget = getAlternativeTarget(i);
+			if (headTarget > 0)
+			{
+				shared_ptr<Entity> current = level->getEntity(headTarget);
+
+				// 4J: Added check for instance of living entity, had a problem with IDs being recycled to other entities
+				if (current == NULL || !current->instanceof(eTYPE_LIVINGENTITY) || !current->isAlive() || distanceToSqr(current) > 30 * 30 || !canSee(current))
+				{
+					setAlternativeTarget(i, 0);
+				}
+				else
+				{
+					performRangedAttack(i + 1, dynamic_pointer_cast<LivingEntity>(current) );
+					nextHeadUpdate[i - 1] = tickCount + SharedConstants::TICKS_PER_SECOND * 2 + random->nextInt(SharedConstants::TICKS_PER_SECOND);
+					idleHeadUpdates[i - 1] = 0;
+				}
+			}
+			else
+			{
+				vector<shared_ptr<Entity> > *entities = level->getEntitiesOfClass(typeid(LivingEntity), bb->grow(20, 8, 20), livingEntitySelector);
+				// randomly try to find a target 10 times
+				for (int attempt = 0; attempt < 10 && !entities->empty(); attempt++)
+				{
+					int randomIndex = random->nextInt(entities->size());
+					shared_ptr<LivingEntity> selected = dynamic_pointer_cast<LivingEntity>( entities->at(randomIndex) );
+
+					if (selected != shared_from_this() && selected->isAlive() && canSee(selected))
+					{
+						if ( selected->instanceof(eTYPE_PLAYER) )
+						{
+							if (!dynamic_pointer_cast<Player>(selected)->abilities.invulnerable)
+							{
+								assert(selected->instanceof(eTYPE_LIVINGENTITY));
+								setAlternativeTarget(i, selected->entityId);
+							}
+							break;
+						}
+						else
+						{
+							assert(selected->instanceof(eTYPE_LIVINGENTITY));
+							setAlternativeTarget(i, selected->entityId);
+							break;
+						}
+					}
+					// don't pick this again
+					entities->erase(entities->begin() + randomIndex);
+				}
+				delete entities;
+			}
+		}
+	}
+	if (getTarget() != NULL)
+	{
+		assert(getTarget()->instanceof(eTYPE_LIVINGENTITY));
+		setAlternativeTarget(0, getTarget()->entityId);
+	}
+	else
+	{
+		setAlternativeTarget(0, 0);
+	}
+
+	if (destroyBlocksTick > 0)
+	{
+		destroyBlocksTick--;
+
+		if (destroyBlocksTick == 0 && level->getGameRules()->getBoolean(GameRules::RULE_MOBGRIEFING))
+		{
+			// destroy all blocks that are within 1 range, counting from
+			// feet and 3 blocks up
+
+			int feet = Mth::floor(y);
+			int ox = Mth::floor(x);
+			int oz = Mth::floor(z);
+			bool destroyed = false;
+
+			for (int xStep = -1; xStep <= 1; xStep++)
+			{
+				for (int zStep = -1; zStep <= 1; zStep++)
+				{
+					for (int yStep = 0; yStep <= 3; yStep++)
+					{
+						int tx = ox + xStep;
+						int ty = feet + yStep;
+						int tz = oz + zStep;
+						int tile = level->getTile(tx, ty, tz);
+						if (tile > 0 && tile != Tile::unbreakable_Id && tile != Tile::endPortalTile_Id && tile != Tile::endPortalFrameTile_Id)
+						{
+							destroyed = level->destroyTile(tx, ty, tz, true) || destroyed;
+						}
+					}
+				}
+			}
+			if (destroyed)
+			{
+				level->levelEvent(nullptr, LevelEvent::SOUND_ZOMBIE_DOOR_CRASH, (int) x, (int) y, (int) z, 0);
+			}
+		}
+	}
+
+	if ((tickCount % (SharedConstants::TICKS_PER_SECOND)) == 0)
+	{
+		heal(1);
+	}
+}
+
+void WitherBoss::makeInvulnerable()
+{
+	setInvulnerableTicks(SharedConstants::TICKS_PER_SECOND * 11);
+	setHealth(getMaxHealth() / 3);
+}
+
+void WitherBoss::makeStuckInWeb()
+{
+}
+
+int WitherBoss::getArmorValue()
+{
+	return 4;
+}
+
+double WitherBoss::getHeadX(int index)
+{
+	if (index <= 0)
+	{
+		return x;
+	}
+	float headAngle = (yBodyRot + 180 * (index - 1)) / 180.0f * PI;
+	float cos = Mth::cos(headAngle);
+	return x + cos * 1.3;
+}
+
+double WitherBoss::getHeadY(int index)
+{
+	if (index <= 0)
+	{
+		return y + 3;
+	}
+	else
+	{
+		return y + 2.2;
+	}
+}
+
+double WitherBoss::getHeadZ(int index)
+{
+	if (index <= 0)
+	{
+		return z;
+	}
+	float headAngle = (yBodyRot + 180 * (index - 1)) / 180.0f * PI;
+	float sin = Mth::sin(headAngle);
+	return z + sin * 1.3;
+}
+
+float WitherBoss::rotlerp(float a, float b, float max)
+{
+	float diff = Mth::wrapDegrees(b - a);
+	if (diff > max)
+	{
+		diff = max;
+	}
+	if (diff < -max)
+	{
+		diff = -max;
+	}
+	return a + diff;
+}
+
+void WitherBoss::performRangedAttack(int head, shared_ptr<LivingEntity> target)
+{
+	performRangedAttack(head, target->x, target->y + target->getHeadHeight() * .5, target->z, head == 0 && random->nextFloat() < 0.001f);
+}
+
+void WitherBoss::performRangedAttack(int head, double tx, double ty, double tz, bool dangerous)
+{
+	level->levelEvent(nullptr, LevelEvent::SOUND_WITHER_BOSS_SHOOT, (int) x, (int) y, (int) z, 0);
+
+	double hx = getHeadX(head);
+	double hy = getHeadY(head);
+	double hz = getHeadZ(head);
+
+	double xd = tx - hx;
+	double yd = ty - hy;
+	double zd = tz - hz;
+
+	shared_ptr<WitherSkull> ie = shared_ptr<WitherSkull>( new WitherSkull(level, dynamic_pointer_cast<LivingEntity>(shared_from_this()), xd, yd, zd) );
+	if (dangerous) ie->setDangerous(true);
+	ie->y = hy;
+	ie->x = hx;
+	ie->z = hz;
+	level->addEntity(ie);
+}
+
+void WitherBoss::performRangedAttack(shared_ptr<LivingEntity> target, float power)
+{
+	performRangedAttack(0, target);
+}
+
+bool WitherBoss::hurt(DamageSource *source, float dmg)
+{
+	if (isInvulnerable()) return false;
+	if (source == DamageSource::drown) return false;
+	if (getInvulnerableTicks() > 0)
+	{
+		return false;
+	}
+
+	if (isPowered())
+	{
+		shared_ptr<Entity> directEntity = source->getDirectEntity();
+		if (directEntity != NULL && directEntity->GetType() == eTYPE_ARROW)
+		{
+			return false;
+		}
+	}
+
+	shared_ptr<Entity> sourceEntity = source->getEntity();
+	if (sourceEntity != NULL)
+	{
+		if ( sourceEntity->instanceof(eTYPE_PLAYER) )
+		{
+		}
+		else if ( sourceEntity->instanceof(eTYPE_LIVINGENTITY) && dynamic_pointer_cast<LivingEntity>(sourceEntity)->getMobType() == getMobType())
+		{
+			// can't be harmed by other undead
+			return false;
+		}
+	}
+	if (destroyBlocksTick <= 0)
+	{
+		destroyBlocksTick = SharedConstants::TICKS_PER_SECOND;
+	}
+
+	for (int i = 0; i < IDLE_HEAD_UPDATES_SIZE; i++)
+	{
+		idleHeadUpdates[i] += 3;
+	}
+
+	return Monster::hurt(source, dmg);
+}
+
+void WitherBoss::dropDeathLoot(bool wasKilledByPlayer, int playerBonusLevel)
+{
+	spawnAtLocation(Item::netherStar_Id, 1);
+}
+
+void WitherBoss::checkDespawn()
+{
+	noActionTime = 0;
+}
+
+int WitherBoss::getLightColor(float a)
+{
+	return SharedConstants::FULLBRIGHT_LIGHTVALUE;
+}
+
+bool WitherBoss::isPickable()
+{
+	return !removed;
+}
+
+void WitherBoss::causeFallDamage(float distance)
+{
+}
+
+void WitherBoss::addEffect(MobEffectInstance *newEffect)
+{
+	// do nothing
+}
+
+bool WitherBoss::useNewAi()
+{
+	return true;
+}
+
+void WitherBoss::registerAttributes()
+{
+	Monster::registerAttributes();
+
+	getAttribute(SharedMonsterAttributes::MAX_HEALTH)->setBaseValue(300);
+	getAttribute(SharedMonsterAttributes::MOVEMENT_SPEED)->setBaseValue(0.6f);
+
+	// 4J Stu - Don't make it so far!
+	//getAttribute(SharedMonsterAttributes::FOLLOW_RANGE)->setBaseValue(40);
+}
+
+float WitherBoss::getHeadYRot(int i)
+{
+	return yRotHeads[i];
+}
+
+float WitherBoss::getHeadXRot(int i)
+{
+	return xRotHeads[i];
+}
+
+int WitherBoss::getInvulnerableTicks()
+{
+	return entityData->getInteger(DATA_ID_INV);
+}
+
+void WitherBoss::setInvulnerableTicks(int invulnerableTicks)
+{
+	entityData->set(DATA_ID_INV, invulnerableTicks);
+}
+
+int WitherBoss::getAlternativeTarget(int headIndex)
+{
+	return entityData->getInteger(DATA_TARGET_A + headIndex);
+}
+
+void WitherBoss::setAlternativeTarget(int headIndex, int entityId)
+{
+	entityData->set(DATA_TARGET_A + headIndex, entityId);
+}
+
+bool WitherBoss::isPowered()
+{
+	return getHealth() <= getMaxHealth() / 2;
+}
+
+MobType WitherBoss::getMobType()
+{
+	return UNDEAD;
+}
+
+void WitherBoss::ride(shared_ptr<Entity> e)
+{
+	riding = nullptr;
+}
\ No newline at end of file