backups/4jcraft
1
0
Fork 0
mirror of https://github.com/4jcraft/4jcraft.git synced 2026-04-24 07:13:36 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
4jcraft/Minecraft.World/Entities/Entity.cpp

1760 lines
54 KiB
C++
Raw Blame History

#include "../Platform/stdafx.h"
#include "../Headers/com.mojang.nbt.h"
#include "../Headers/net.minecraft.world.item.h"
#include "../Headers/net.minecraft.world.item.enchantment.h"
#include "../Headers/net.minecraft.world.level.h"
#include "../Headers/net.minecraft.world.level.tile.h"
#include "../Headers/net.minecraft.world.phys.h"
#include "../Headers/net.minecraft.world.entity.item.h"
#include "../Headers/net.minecraft.world.level.material.h"
#include "../Headers/net.minecraft.world.damagesource.h"
#include "SyncedEntityData.h"
#include "../Level/Storage/EntityIO.h"
#include "../Util/SharedConstants.h"
#include "../Util/ParticleTypes.h"
#include "EntityPos.h"
#include "Entity.h"
#include "../Util/SoundTypes.h"
#include "../../Minecraft.Client/Rendering/Models/HumanoidModel.h"
#include "../../Minecraft.Client/MinecraftServer.h"
#include "../../Minecraft.Client/Level/MultiPlayerLevel.h"
#include "../../Minecraft.Client/Player/MultiPlayerLocalPlayer.h"
#include <cstdint>
namespace {
#if defined(_WIN32)
inline void* EntityTlsGetValue(Entity::TlsKey key) { return TlsGetValue(key); }
inline void EntityTlsSetValue(Entity::TlsKey key, void* value) {
TlsSetValue(key, value);
}
#else
pthread_key_t CreateEntityTlsKey() {
pthread_key_t key;
const int result = pthread_key_create(&key, nullptr);
assert(result == 0);
return key;
}
inline void* EntityTlsGetValue(pthread_key_t key) {
return pthread_getspecific(key);
}
inline void EntityTlsSetValue(pthread_key_t key, void* value) {
pthread_setspecific(key, value);
}
#endif
} // namespace
int Entity::entityCounter =
2048; // 4J - changed initialiser to 2048, as we are using range 0 - 2047
// as special unique smaller ids for things that need network tracked
#if defined(_WIN32)
Entity::TlsKey Entity::tlsIdx = TlsAlloc();
#else
Entity::TlsKey Entity::tlsIdx = CreateEntityTlsKey();
#endif
// 4J - added getSmallId & freeSmallId methods
unsigned int Entity::entityIdUsedFlags[2048 / 32] = {0};
unsigned int Entity::entityIdWanderFlags[2048 / 32] = {0};
unsigned int Entity::entityIdRemovingFlags[2048 / 32] = {0};
int Entity::extraWanderIds[EXTRA_WANDER_MAX] = {0};
int Entity::extraWanderTicks = 0;
int Entity::extraWanderCount = 0;
int Entity::getSmallId() {
unsigned int* puiUsedFlags = entityIdUsedFlags;
unsigned int* puiRemovedFlags = NULL;
// If we are the server (we should be, if we are allocating small Ids), then
// check with the server if there are any small Ids which are still in the
// ServerPlayer's vectors of entities to be removed - these are used to
// gather up a set of entities into one network packet for final
// notification to the client that the entities are removed. We can't go
// re-using these small Ids yet, as otherwise we will potentially end up
// telling the client that the entity has been removed After we have already
// re-used its Id and created a new entity. This ends up with newly created
// client-side entities being removed by accident, causing invisible mobs.
if (reinterpret_cast<std::intptr_t>(EntityTlsGetValue(tlsIdx)) != 0) {
MinecraftServer* server = MinecraftServer::getInstance();
if (server) {
// In some attempt to optimise this, flagEntitiesToBeRemoved most of
// the time shouldn't do anything at all, and in this case it
// doesn't even memset the entityIdRemovingFlags array, so we
// shouldn't use it if the return value is false.
bool removedFound =
server->flagEntitiesToBeRemoved(entityIdRemovingFlags);
if (removedFound) {
// Has set up the entityIdRemovingFlags vector in this case, so
// we should check against this when allocating new ids
// app.DebugPrintf("getSmallId:
//Removed entities found\n");
puiRemovedFlags = entityIdRemovingFlags;
}
}
}
for (int i = 0; i < (2048 / 32); i++) {
unsigned int uiFlags = *puiUsedFlags;
if (uiFlags != 0xffffffff) {
unsigned int uiMask = 0x80000000;
for (int j = 0; j < 32; j++) {
// See comments above - now checking (if required) that these
// aren't newly removed entities that the clients still haven't
// been told about, so we don't reuse those ids before we
// should.
if (puiRemovedFlags) {
if (puiRemovedFlags[i] & uiMask) {
// app.DebugPrintf("Avoiding
//using ID %d (0x%x)\n", i * 32 + j,puiRemovedFlags[i]);
uiMask >>= 1;
continue;
}
}
if ((uiFlags & uiMask) == 0) {
uiFlags |= uiMask;
*puiUsedFlags = uiFlags;
return i * 32 + j;
}
uiMask >>= 1;
}
}
puiUsedFlags++;
}
app.DebugPrintf("Out of small entity Ids... possible leak?\n");
__debugbreak();
return -1;
}
void Entity::countFlagsForPIX() {
int freecount = 0;
unsigned int* puiUsedFlags = entityIdUsedFlags;
for (int i = 0; i < (2048 / 32); i++) {
unsigned int uiFlags = *puiUsedFlags;
if (uiFlags != 0xffffffff) {
unsigned int uiMask = 0x80000000;
for (int j = 0; j < 32; j++) {
if ((uiFlags & uiMask) == 0) {
freecount++;
}
uiMask >>= 1;
}
}
puiUsedFlags++;
}
PIXAddNamedCounter(freecount, "Small Ids free");
PIXAddNamedCounter(2048 - freecount, "Small Ids used");
}
void Entity::resetSmallId() {
freeSmallId(entityId);
if (reinterpret_cast<std::intptr_t>(EntityTlsGetValue(tlsIdx)) != 0) {
entityId = getSmallId();
}
}
void Entity::freeSmallId(int index) {
if (reinterpret_cast<std::intptr_t>(EntityTlsGetValue(tlsIdx)) == 0)
return; // Don't do anything with small ids if this isn't the server
// thread
if (index >= 2048) return; // Don't do anything if this isn't a short id
unsigned int i = index / 32;
unsigned int j = index % 32;
unsigned int uiMask = ~(0x80000000 >> j);
entityIdUsedFlags[i] &= uiMask;
entityIdWanderFlags[i] &= uiMask;
}
void Entity::useSmallIds() {
EntityTlsSetValue(tlsIdx,
reinterpret_cast<void*>(static_cast<std::intptr_t>(1)));
}
// Things also added here to be able to manage the concept of a number of extra
// "wandering" entities - normally path finding entities aren't allowed to
// randomly wander about once they are a certain distance away from any player,
// but we want to be able to (in a controlled fashion) allow some to be able to
// move so that we can determine whether they have been enclosed in some kind of
// farm, and so be able to better determine what shouldn't or shouldn't be
// despawned.
// Let the management system here know whether or not to consider this
// particular entity for some extra wandering
void Entity::considerForExtraWandering(bool enable) {
if (reinterpret_cast<std::intptr_t>(EntityTlsGetValue(tlsIdx)) == 0)
return; // Don't do anything with small ids if this isn't the server
// thread
if (entityId >= 2048) return; // Don't do anything if this isn't a short id
unsigned int i = entityId / 32;
unsigned int j = entityId % 32;
if (enable) {
unsigned int uiMask = 0x80000000 >> j;
entityIdWanderFlags[i] |= uiMask;
} else {
unsigned int uiMask = ~(0x80000000 >> j);
entityIdWanderFlags[i] &= uiMask;
}
}
// Should this entity do wandering in addition to what the java code would have
// done?
bool Entity::isExtraWanderingEnabled() {
if (reinterpret_cast<std::intptr_t>(EntityTlsGetValue(tlsIdx)) == 0)
return false; // Don't do anything with small ids if this isn't the
// server thread
if (entityId >= 2048)
return false; // Don't do anything if this isn't a short id
for (int i = 0; i < extraWanderCount; i++) {
if (extraWanderIds[i] == entityId) return true;
}
return false;
}
// Returns a quadrant of direction that a given entity should be moved in - this
// is to stop the randomness of the wandering/strolling from just making the
// entity double back on itself and thus making the determination of whether the
// entity has been enclosed take longer than it needs to. This function returns
// a quadrant from 0 to 3 that should be consistent within one period of an
// entity being considered for extra wandering, but should potentially vary
// between tries and between different entities.
int Entity::getWanderingQuadrant() {
return (entityId + (extraWanderTicks / EXTRA_WANDER_TICKS)) & 3;
}
// Every EXTRA_WANDER_TICKS ticks, attempt to find EXTRA_WANDER_MAX entity Ids
// from those that have been flagged as ones that should be considered for extra
// wandering
void Entity::tickExtraWandering() {
extraWanderTicks++;
// Time to move onto some new entities?
if ((extraWanderTicks % EXTRA_WANDER_TICKS == 0)) {
// printf("Updating extras: ");
// Start from the next Id after the one that we last found, or zero if
// we didn't find anything last time
int entityId = 0;
if (extraWanderCount) {
entityId = (extraWanderIds[extraWanderCount - 1] + 1) % 2048;
}
extraWanderCount = 0;
for (int k = 0; (k < 2048) && (extraWanderCount < EXTRA_WANDER_MAX);
k++) {
unsigned int i = entityId / 32;
unsigned int j = entityId % 32;
unsigned int uiMask = 0x80000000 >> j;
if (entityIdWanderFlags[i] & uiMask) {
extraWanderIds[extraWanderCount++] = entityId;
// printf("%d, ", entityId);
}
entityId = (entityId + 1) % 2048;
}
// printf("\n");
}
}
// 4J - added for common ctor code
// Do all the default initialisations done in the java class
void Entity::_init(bool useSmallId) {
// 4J - changed to assign two different types of ids. A range from 0-2047 is
// used for things that we'll be wanting to identify over the network, so we
// should only need 11 bits rather than 32 to uniquely identify them. The
// rest of the range is used for anything we don't need to track like this,
// currently particles. We only ever want to allocate this type of id from
// the server thread, so using thread local storage to isolate this.
if (useSmallId &&
reinterpret_cast<std::intptr_t>(EntityTlsGetValue(tlsIdx)) != 0) {
entityId = getSmallId();
} else {
entityId = Entity::entityCounter++;
if (entityCounter == 0x7ffffff) entityCounter = 2048;
}
viewScale = 1.0;
blocksBuilding = false;
rider = std::weak_ptr<Entity>();
riding = nullptr;
// level = NULL; // Level is assigned to in the original c_tor code
xo = yo = zo = 0.0;
x = y = z = 0.0;
xd = yd = zd = 0.0;
yRot = xRot = 0.0f;
yRotO = xRotO = 0.0f;
bb = AABB::newPermanent(0, 0, 0, 0, 0, 0); // 4J Was final
onGround = false;
horizontalCollision = verticalCollision = false;
collision = false;
hurtMarked = false;
isStuckInWeb = false;
slide = true;
removed = false;
heightOffset = 0 / 16.0f;
bbWidth = 0.6f;
bbHeight = 1.8f;
walkDistO = 0;
walkDist = 0;
fallDistance = 0;
nextStep = 1;
xOld = yOld = zOld = 0.0;
ySlideOffset = 0;
footSize = 0.0f;
noPhysics = false;
pushthrough = 0.0f;
random = new Random();
tickCount = 0;
flameTime = 1;
onFire = 0;
wasInWater = false;
invulnerableTime = 0;
firstTick = true;
customTextureUrl = L"";
customTextureUrl2 = L"";
fireImmune = false;
// values that need to be sent to clients in SMP
entityData = std::shared_ptr<SynchedEntityData>(new SynchedEntityData());
xRideRotA = yRideRotA = 0.0;
inChunk = false;
xChunk = yChunk = zChunk = 0;
xp = yp = zp = 0;
xRotp = yRotp = 0;
noCulling = false;
hasImpulse = false;
// 4J Added
m_ignoreVerticalCollisions = false;
m_uiAnimOverrideBitmask = 0L;
}
Entity::Entity(Level* level,
bool useSmallId) // 4J - added useSmallId parameter
{
MemSect(16);
_init(useSmallId);
MemSect(0);
this->level = level;
// resetPos();
setPos(0, 0, 0);
entityData->define(DATA_SHARED_FLAGS_ID, (uint8_t)0);
entityData->define(
DATA_AIR_SUPPLY_ID,
TOTAL_AIR_SUPPLY); // 4J Stu - Brought forward from 1.2.3 to fix 38654
// - Gameplay: Player will take damage when air
// bubbles are present if resuming game from
// load/autosave underwater.
// 4J Stu - We cannot call virtual functions in ctors, as at this point the
// object is of type Entity and not a derived class
// this->defineSynchedData();
}
Entity::~Entity() {
freeSmallId(entityId);
delete random;
delete bb;
}
std::shared_ptr<SynchedEntityData> Entity::getEntityData() {
return entityData;
}
/*
public bool equals(Object obj) {
if (obj instanceof Entity) {
return ((Entity) obj).entityId == entityId;
}
return false;
}
public int hashCode() {
return entityId;
}
*/
void Entity::resetPos() {
if (level == NULL) return;
std::shared_ptr<Entity> sharedThis = shared_from_this();
while (true && y > 0) {
setPos(x, y, z);
if (level->getCubes(sharedThis, bb)->empty()) break;
y += 1;
}
xd = yd = zd = 0;
xRot = 0;
}
void Entity::remove() { removed = true; }
void Entity::setSize(float w, float h) {
if (w != bbWidth || h != bbHeight) {
float oldW = bbWidth;
bbWidth = w;
bbHeight = h;
bb->x1 = bb->x0 + bbWidth;
bb->z1 = bb->z0 + bbWidth;
bb->y1 = bb->y0 + bbHeight;
if (bbWidth > oldW && !firstTick && !level->isClientSide) {
move(oldW - bbWidth, 0, oldW - bbWidth);
}
}
}
void Entity::setPos(EntityPos* pos) {
if (pos->move)
setPos(pos->x, pos->y, pos->z);
else
setPos(x, y, z);
if (pos->rot)
setRot(pos->yRot, pos->xRot);
else
setRot(yRot, xRot);
}
void Entity::setRot(float yRot, float xRot) {
/* JAVA:
this->yRot = yRot % 360.0f;
this->xRot = xRot % 360.0f;
C++ Cannot do mod of non-integral type
*/
while (yRot >= 360.0f) yRot -= 360.0f;
while (yRot < 0) yRot += 360.0f;
while (xRot >= 360.0f) xRot -= 360.0f;
this->yRot = yRot;
this->xRot = xRot;
}
void Entity::setPos(double x, double y, double z) {
this->x = x;
this->y = y;
this->z = z;
float w = bbWidth / 2;
float h = bbHeight;
bb->set(x - w, y - heightOffset + ySlideOffset, z - w, x + w,
y - heightOffset + ySlideOffset + h, z + w);
}
void Entity::turn(float xo, float yo) {
float xRotOld = xRot;
float yRotOld = yRot;
yRot += xo * 0.15f;
xRot -= yo * 0.15f;
if (xRot < -90) xRot = -90;
if (xRot > 90) xRot = 90;
xRotO += xRot - xRotOld;
yRotO += yRot - yRotOld;
}
void Entity::interpolateTurn(float xo, float yo) {
yRot += xo * 0.15f;
xRot -= yo * 0.15f;
if (xRot < -90) xRot = -90;
if (xRot > 90) xRot = 90;
}
void Entity::tick() { baseTick(); }
void Entity::baseTick() {
// 4J Stu - Not needed
// util.Timer.push("entityBaseTick");
if (riding != NULL && riding->removed) riding = nullptr;
tickCount++;
walkDistO = walkDist;
xo = x;
yo = y;
zo = z;
xRotO = xRot;
yRotO = yRot;
if (isSprinting() && !isInWater() && canCreateParticles()) {
int xt = Mth::floor(x);
int yt = Mth::floor(y - 0.2f - this->heightOffset);
int zt = Mth::floor(z);
int t = level->getTile(xt, yt, zt);
int d = level->getData(xt, yt, zt);
if (t > 0) {
level->addParticle(PARTICLE_TILECRACK(t, d),
x + (random->nextFloat() - 0.5) * bbWidth,
bb->y0 + 0.1,
z + (random->nextFloat() - 0.5) * bbWidth,
-xd * 4, 1.5, -zd * 4);
}
}
if (updateInWaterState()) {
if (!wasInWater && !firstTick && canCreateParticles()) {
float speed =
Mth::sqrt(xd * xd * 0.2f + yd * yd + zd * zd * 0.2f) * 0.2f;
if (speed > 1) speed = 1;
MemSect(31);
level->playSound(
shared_from_this(), eSoundType_RANDOM_SPLASH, speed,
1 + (random->nextFloat() - random->nextFloat()) * 0.4f);
MemSect(0);
float yt = (float)Mth::floor(bb->y0);
for (int i = 0; i < 1 + bbWidth * 20; i++) {
float xo = (random->nextFloat() * 2 - 1) * bbWidth;
float zo = (random->nextFloat() * 2 - 1) * bbWidth;
level->addParticle(eParticleType_bubble, x + xo, yt + 1, z + zo,
xd, yd - random->nextFloat() * 0.2f, zd);
}
for (int i = 0; i < 1 + bbWidth * 20; i++) {
float xo = (random->nextFloat() * 2 - 1) * bbWidth;
float zo = (random->nextFloat() * 2 - 1) * bbWidth;
level->addParticle(eParticleType_splash, x + xo, yt + 1, z + zo,
xd, yd, zd);
}
}
fallDistance = 0;
wasInWater = true;
onFire = 0;
} else {
wasInWater = false;
}
if (level->isClientSide) {
onFire = 0;
} else {
if (onFire > 0) {
if (fireImmune) {
onFire -= 4;
if (onFire < 0) onFire = 0;
} else {
if (onFire % 20 == 0) {
hurt(DamageSource::onFire, 1);
}
onFire--;
}
}
}
if (isInLava()) {
lavaHurt();
fallDistance *= .5f;
}
if (y < -64) {
outOfWorld();
}
if (!level->isClientSide) {
setSharedFlag(FLAG_ONFIRE, onFire > 0);
setSharedFlag(FLAG_RIDING, riding != NULL);
}
firstTick = false;
// 4J Stu - Unused
// util.Timer.pop();
}
void Entity::lavaHurt() {
if (fireImmune) {
} else {
hurt(DamageSource::lava, 4);
setOnFire(15);
}
}
void Entity::setOnFire(int numberOfSeconds) {
int newValue = numberOfSeconds * SharedConstants::TICKS_PER_SECOND;
newValue = ProtectionEnchantment::getFireAfterDampener(shared_from_this(),
newValue);
if (onFire < newValue) {
onFire = newValue;
}
}
void Entity::clearFire() { onFire = 0; }
void Entity::outOfWorld() { remove(); }
bool Entity::isFree(float xa, float ya, float za, float grow) {
AABB* box = bb->grow(grow, grow, grow)->cloneMove(xa, ya, za);
AABBList* aABBs = level->getCubes(shared_from_this(), box);
if (!aABBs->empty()) return false;
if (level->containsAnyLiquid(box)) return false;
return true;
}
bool Entity::isFree(double xa, double ya, double za) {
AABB* box = bb->cloneMove(xa, ya, za);
AABBList* aABBs = level->getCubes(shared_from_this(), box);
if (!aABBs->empty()) return false;
if (level->containsAnyLiquid(box)) return false;
return true;
}
void Entity::move(double xa, double ya, double za,
bool noEntityCubes) // 4J - added noEntityCubes parameter
{
if (noPhysics) {
bb->move(xa, ya, za);
x = (bb->x0 + bb->x1) / 2.0f;
y = bb->y0 + heightOffset - ySlideOffset;
z = (bb->z0 + bb->z1) / 2.0f;
return;
}
ySlideOffset *= 0.4f;
double xo = x;
double zo = z;
if (isStuckInWeb) {
isStuckInWeb = false;
xa *= 0.25f;
ya *= 0.05f;
za *= 0.25f;
xd = 0.0f;
yd = 0.0f;
zd = 0.0f;
}
double xaOrg = xa;
double yaOrg = ya;
double zaOrg = za;
AABB* bbOrg = bb->copy();
bool isPlayerSneaking =
onGround && isSneaking() &&
std::dynamic_pointer_cast<Player>(shared_from_this()) != NULL;
if (isPlayerSneaking) {
double d = 0.05;
while (xa != 0 &&
level->getCubes(shared_from_this(), bb->cloneMove(xa, -1.0, 0))
->empty()) {
if (xa < d && xa >= -d)
xa = 0;
else if (xa > 0)
xa -= d;
else
xa += d;
xaOrg = xa;
}
while (za != 0 &&
level->getCubes(shared_from_this(), bb->cloneMove(0, -1.0, za))
->empty()) {
if (za < d && za >= -d)
za = 0;
else if (za > 0)
za -= d;
else
za += d;
zaOrg = za;
}
while (xa != 0 && za != 0 &&
level->getCubes(shared_from_this(), bb->cloneMove(xa, -1.0, za))
->empty()) {
if (xa < d && xa >= -d)
xa = 0;
else if (xa > 0)
xa -= d;
else
xa += d;
if (za < d && za >= -d)
za = 0;
else if (za > 0)
za -= d;
else
za += d;
xaOrg = xa;
zaOrg = za;
}
}
AABBList* aABBs = level->getCubes(
shared_from_this(), bb->expand(xa, ya, za), noEntityCubes, true);
// LAND FIRST, then x and z
AUTO_VAR(itEndAABB, aABBs->end());
// 4J Stu - Particles (and possibly other entities) don't have xChunk and
// zChunk set, so calculate the chunk instead
int xc = Mth::floor(x / 16);
int zc = Mth::floor(z / 16);
if (!level->isClientSide || level->reallyHasChunk(xc, zc)) {
// 4J Stu - It's horrible that the client is doing any movement at all!
// But if we don't have the chunk data then all the collision info will
// be incorrect as well
for (AUTO_VAR(it, aABBs->begin()); it != itEndAABB; it++)
ya = (*it)->clipYCollide(bb, ya);
bb->move(0, ya, 0);
}
if (!slide && yaOrg != ya) {
xa = ya = za = 0;
}
bool og = onGround || (yaOrg != ya && yaOrg < 0);
itEndAABB = aABBs->end();
for (AUTO_VAR(it, aABBs->begin()); it != itEndAABB; it++)
xa = (*it)->clipXCollide(bb, xa);
bb->move(xa, 0, 0);
if (!slide && xaOrg != xa) {
xa = ya = za = 0;
}
itEndAABB = aABBs->end();
for (AUTO_VAR(it, aABBs->begin()); it != itEndAABB; it++)
za = (*it)->clipZCollide(bb, za);
bb->move(0, 0, za);
if (!slide && zaOrg != za) {
xa = ya = za = 0;
}
if (footSize > 0 && og && (isPlayerSneaking || ySlideOffset < 0.05f) &&
((xaOrg != xa) || (zaOrg != za))) {
double xaN = xa;
double yaN = ya;
double zaN = za;
xa = xaOrg;
ya = footSize;
za = zaOrg;
AABB* normal = bb->copy();
bb->set(bbOrg);
// 4J - added extra expand, as if we don't move up by footSize by
// hitting a block above us, then overall we could be trying to move as
// much as footSize downwards, so we'd better include cubes under our
// feet in this list of things we might possibly collide with
aABBs = level->getCubes(shared_from_this(),
bb->expand(xa, ya, za)->expand(0, -ya, 0),
false, true);
// LAND FIRST, then x and z
itEndAABB = aABBs->end();
if (!level->isClientSide || level->reallyHasChunk(xc, zc)) {
// 4J Stu - It's horrible that the client is doing any movement at
// all! But if we don't have the chunk data then all the collision
// info will be incorrect as well
for (AUTO_VAR(it, aABBs->begin()); it != itEndAABB; it++)
ya = (*it)->clipYCollide(bb, ya);
bb->move(0, ya, 0);
}
if (!slide && yaOrg != ya) {
xa = ya = za = 0;
}
itEndAABB = aABBs->end();
for (AUTO_VAR(it, aABBs->begin()); it != itEndAABB; it++)
xa = (*it)->clipXCollide(bb, xa);
bb->move(xa, 0, 0);
if (!slide && xaOrg != xa) {
xa = ya = za = 0;
}
itEndAABB = aABBs->end();
for (AUTO_VAR(it, aABBs->begin()); it != itEndAABB; it++)
za = (*it)->clipZCollide(bb, za);
bb->move(0, 0, za);
if (!slide && zaOrg != za) {
xa = ya = za = 0;
}
if (!slide && yaOrg != ya) {
xa = ya = za = 0;
} else {
ya = -footSize;
// LAND FIRST, then x and z
itEndAABB = aABBs->end();
for (AUTO_VAR(it, aABBs->begin()); it != itEndAABB; it++)
ya = (*it)->clipYCollide(bb, ya);
bb->move(0, ya, 0);
}
if (xaN * xaN + zaN * zaN >= xa * xa + za * za) {
xa = xaN;
ya = yaN;
za = zaN;
bb->set(normal);
} else {
double ss = bb->y0 - (int)bb->y0;
if (ss > 0) {
ySlideOffset += (float)(ss + 0.01);
}
}
}
x = (bb->x0 + bb->x1) / 2.0f;
y = bb->y0 + heightOffset - ySlideOffset;
z = (bb->z0 + bb->z1) / 2.0f;
horizontalCollision = (xaOrg != xa) || (zaOrg != za);
verticalCollision = !m_ignoreVerticalCollisions && (yaOrg != ya);
onGround = !m_ignoreVerticalCollisions && yaOrg != ya && yaOrg < 0;
collision = horizontalCollision || verticalCollision;
checkFallDamage(ya, onGround);
if (xaOrg != xa) xd = 0;
if (yaOrg != ya) yd = 0;
if (zaOrg != za) zd = 0;
double xm = x - xo;
double zm = z - zo;
if (makeStepSound() && !isPlayerSneaking && riding == NULL) {
walkDist += (float)(sqrt(xm * xm + zm * zm) * 0.6);
int xt = Mth::floor(x);
int yt = Mth::floor(y - 0.2f - this->heightOffset);
int zt = Mth::floor(z);
int t = level->getTile(xt, yt, zt);
if (t == 0) {
int renderShape = level->getTileRenderShape(xt, yt - 1, zt);
if (renderShape == Tile::SHAPE_FENCE ||
renderShape == Tile::SHAPE_WALL ||
renderShape == Tile::SHAPE_FENCE_GATE) {
t = level->getTile(xt, yt - 1, zt);
}
}
if (walkDist > nextStep && t > 0) {
nextStep = (int)walkDist + 1;
playStepSound(xt, yt, zt, t);
Tile::tiles[t]->stepOn(level, xt, yt, zt, shared_from_this());
}
}
checkInsideTiles();
bool water = this->isInWaterOrRain();
if (level->containsFireTile(bb->shrink(0.001, 0.001, 0.001))) {
burn(1);
if (!water) {
onFire++;
if (onFire == 0) setOnFire(8);
}
} else {
if (onFire <= 0) {
onFire = -flameTime;
}
}
if (water && onFire > 0) {
level->playSound(
shared_from_this(), eSoundType_RANDOM_FIZZ, 0.7f,
1.6f + (random->nextFloat() - random->nextFloat()) * 0.4f);
onFire = -flameTime;
}
}
void Entity::checkInsideTiles() {
int x0 = Mth::floor(bb->x0 + 0.001);
int y0 = Mth::floor(bb->y0 + 0.001);
int z0 = Mth::floor(bb->z0 + 0.001);
int x1 = Mth::floor(bb->x1 - 0.001);
int y1 = Mth::floor(bb->y1 - 0.001);
int z1 = Mth::floor(bb->z1 - 0.001);
if (level->hasChunksAt(x0, y0, z0, x1, y1, z1)) {
for (int x = x0; x <= x1; x++)
for (int y = y0; y <= y1; y++)
for (int z = z0; z <= z1; z++) {
int t = level->getTile(x, y, z);
if (t > 0) {
Tile::tiles[t]->entityInside(level, x, y, z,
shared_from_this());
}
}
}
}
void Entity::playStepSound(int xt, int yt, int zt, int t) {
const Tile::SoundType* soundType = Tile::tiles[t]->soundType;
MemSect(31);
if (GetType() == eTYPE_PLAYER) {
// should we turn off step sounds?
unsigned int uiAnimOverrideBitmask =
getAnimOverrideBitmask(); // this is masked for custom anim off,
// and force anim
if ((uiAnimOverrideBitmask & (1 << HumanoidModel::eAnim_NoLegAnim)) !=
0) {
return;
}
MultiPlayerLevel* mplevel = (MultiPlayerLevel*)level;
if (mplevel) {
if (level->getTile(xt, yt + 1, zt) == Tile::topSnow_Id) {
soundType = Tile::topSnow->soundType;
mplevel->playLocalSound(
(double)xt + 0.5, (double)yt, (double)zt + 0.5,
soundType->getStepSound(), soundType->getVolume() * 0.15f,
soundType->getPitch());
} else if (!Tile::tiles[t]->material->isLiquid()) {
mplevel->playLocalSound(
(double)xt + 0.5, (double)yt, (double)zt + 0.5,
soundType->getStepSound(), soundType->getVolume() * 0.15f,
soundType->getPitch());
}
} else {
if (level->getTile(xt, yt + 1, zt) == Tile::topSnow_Id) {
soundType = Tile::topSnow->soundType;
level->playLocalSound(
(double)xt + 0.5, (double)yt, (double)zt + 0.5,
soundType->getStepSound(), soundType->getVolume() * 0.15f,
soundType->getPitch());
} else if (!Tile::tiles[t]->material->isLiquid()) {
level->playLocalSound(
(double)xt + 0.5, (double)yt, (double)zt + 0.5,
soundType->getStepSound(), soundType->getVolume() * 0.15f,
soundType->getPitch());
}
}
} else {
if (level->getTile(xt, yt + 1, zt) == Tile::topSnow_Id) {
soundType = Tile::topSnow->soundType;
level->playSound(shared_from_this(), soundType->getStepSound(),
soundType->getVolume() * 0.15f,
soundType->getPitch());
} else if (!Tile::tiles[t]->material->isLiquid()) {
level->playSound(shared_from_this(), soundType->getStepSound(),
soundType->getVolume() * 0.15f,
soundType->getPitch());
}
}
MemSect(0);
}
void Entity::playSound(int iSound, float volume, float pitch) {
level->playSound(shared_from_this(), iSound, volume, pitch);
}
bool Entity::makeStepSound() { return true; }
void Entity::checkFallDamage(double ya, bool onGround) {
if (onGround) {
if (fallDistance > 0) {
if (std::dynamic_pointer_cast<Mob>(shared_from_this()) != NULL) {
int xt = Mth::floor(x);
int yt = Mth::floor(y - 0.2f - this->heightOffset);
int zt = Mth::floor(z);
int t = level->getTile(xt, yt, zt);
if (t == 0 &&
level->getTile(xt, yt - 1, zt) == Tile::fence_Id) {
t = level->getTile(xt, yt - 1, zt);
}
if (t > 0) {
Tile::tiles[t]->fallOn(level, xt, yt, zt,
shared_from_this(), fallDistance);
}
}
causeFallDamage(fallDistance);
fallDistance = 0;
}
} else {
if (ya < 0) fallDistance -= (float)ya;
}
}
AABB* Entity::getCollideBox() { return NULL; }
void Entity::burn(int dmg) {
if (!fireImmune) {
hurt(DamageSource::inFire, dmg);
}
}
bool Entity::isFireImmune() { return fireImmune; }
void Entity::causeFallDamage(float distance) {
if (rider.lock() != NULL) rider.lock()->causeFallDamage(distance);
}
bool Entity::isInWaterOrRain() {
return wasInWater ||
(level->isRainingAt(Mth::floor(x), Mth::floor(y), Mth::floor(z)));
}
bool Entity::isInWater() { return wasInWater; }
bool Entity::updateInWaterState() {
return level->checkAndHandleWater(
bb->grow(0, -0.4f, 0)->shrink(0.001, 0.001, 0.001), Material::water,
shared_from_this());
}
bool Entity::isUnderLiquid(Material* material) {
double yp = y + getHeadHeight();
int xt = Mth::floor(x);
int yt = Mth::floor(
yp); // 4J - this used to be a nested pair of floors for some reason
int zt = Mth::floor(z);
int t = level->getTile(xt, yt, zt);
if (t != 0 && Tile::tiles[t]->material == material) {
float hh = LiquidTile::getHeight(level->getData(xt, yt, zt)) - 1 / 9.0f;
float h = yt + 1 - hh;
return yp < h;
}
return false;
}
float Entity::getHeadHeight() { return 0; }
bool Entity::isInLava() {
return level->containsMaterial(bb->grow(-0.1f, -0.4f, -0.1f),
Material::lava);
}
void Entity::moveRelative(float xa, float za, float speed) {
float dist = xa * xa + za * za;
if (dist < 0.01f * 0.01f) return;
dist = sqrt(dist);
if (dist < 1) dist = 1;
dist = speed / dist;
xa *= dist;
za *= dist;
float sinVar = Mth::sin(yRot * PI / 180);
float cosVar = Mth::cos(yRot * PI / 180);
xd += xa * cosVar - za * sinVar;
zd += za * cosVar + xa * sinVar;
}
// 4J - change brought forward from 1.8.2
int Entity::getLightColor(float a) {
int xTile = Mth::floor(x);
int zTile = Mth::floor(z);
if (level->hasChunkAt(xTile, 0, zTile)) {
double hh = (bb->y1 - bb->y0) * 0.66;
int yTile = Mth::floor(y - this->heightOffset + hh);
return level->getLightColor(xTile, yTile, zTile, 0);
}
return 0;
}
// 4J - changes brought forward from 1.8.2
float Entity::getBrightness(float a) {
int xTile = Mth::floor(x);
int zTile = Mth::floor(z);
if (level->hasChunkAt(xTile, 0, zTile)) {
double hh = (bb->y1 - bb->y0) * 0.66;
int yTile = Mth::floor(y - this->heightOffset + hh);
return level->getBrightness(xTile, yTile, zTile);
}
return 0;
}
void Entity::setLevel(Level* level) { this->level = level; }
void Entity::absMoveTo(double x, double y, double z, float yRot, float xRot) {
this->xo = this->x = x;
this->yo = this->y = y;
this->zo = this->z = z;
this->yRotO = this->yRot = yRot;
this->xRotO = this->xRot = xRot;
ySlideOffset = 0;
double yRotDiff = yRotO - yRot;
if (yRotDiff < -180) yRotO += 360;
if (yRotDiff >= 180) yRotO -= 360;
this->setPos(this->x, this->y, this->z);
this->setRot(yRot, xRot);
}
void Entity::moveTo(double x, double y, double z, float yRot, float xRot) {
this->xOld = this->xo = this->x = x;
this->yOld = this->yo = this->y = y + heightOffset;
this->zOld = this->zo = this->z = z;
this->yRot = yRot;
this->xRot = xRot;
this->setPos(this->x, this->y, this->z);
}
float Entity::distanceTo(std::shared_ptr<Entity> e) {
float xd = (float)(x - e->x);
float yd = (float)(y - e->y);
float zd = (float)(z - e->z);
return sqrt(xd * xd + yd * yd + zd * zd);
}
double Entity::distanceToSqr(double x2, double y2, double z2) {
double xd = (x - x2);
double yd = (y - y2);
double zd = (z - z2);
return xd * xd + yd * yd + zd * zd;
}
double Entity::distanceTo(double x2, double y2, double z2) {
double xd = (x - x2);
double yd = (y - y2);
double zd = (z - z2);
return sqrt(xd * xd + yd * yd + zd * zd);
}
double Entity::distanceToSqr(std::shared_ptr<Entity> e) {
double xd = x - e->x;
double yd = y - e->y;
double zd = z - e->z;
return xd * xd + yd * yd + zd * zd;
}
void Entity::playerTouch(std::shared_ptr<Player> player) {}
void Entity::push(std::shared_ptr<Entity> e) {
if (e->rider.lock().get() == this || e->riding.get() == this) return;
double xa = e->x - x;
double za = e->z - z;
double dd = Mth::asbMax(xa, za);
if (dd >= 0.01f) {
dd = sqrt(dd);
xa /= dd;
za /= dd;
double pow = 1 / dd;
if (pow > 1) pow = 1;
xa *= pow;
za *= pow;
xa *= 0.05f;
za *= 0.05f;
xa *= 1 - pushthrough;
za *= 1 - pushthrough;
this->push(-xa, 0, -za);
e->push(xa, 0, za);
}
}
void Entity::push(double xa, double ya, double za) {
xd += xa;
yd += ya;
zd += za;
this->hasImpulse = true;
}
void Entity::markHurt() { this->hurtMarked = true; }
bool Entity::hurt(DamageSource* source, int damage) {
markHurt();
return false;
}
bool Entity::intersects(double x0, double y0, double z0, double x1, double y1,
double z1) {
return bb->intersects(x0, y0, z0, x1, y1, z1);
}
bool Entity::isPickable() { return false; }
bool Entity::isPushable() { return false; }
bool Entity::isShootable() { return false; }
void Entity::awardKillScore(std::shared_ptr<Entity> victim, int score) {}
bool Entity::shouldRender(Vec3* c) {
double xd = x - c->x;
double yd = y - c->y;
double zd = z - c->z;
double distance = xd * xd + yd * yd + zd * zd;
return shouldRenderAtSqrDistance(distance);
}
bool Entity::shouldRenderAtSqrDistance(double distance) {
double size = bb->getSize();
size *= 64.0f * viewScale;
return distance < size * size;
}
// 4J - used to be std::wstring return type, returning L""
int Entity::getTexture() { return -1; }
bool Entity::isCreativeModeAllowed() { return false; }
bool Entity::save(CompoundTag* entityTag) {
std::wstring id = getEncodeId();
if (removed || id.empty()) {
return false;
}
// TODO Is this fine to be casting to a non-const char pointer?
entityTag->putString(L"id", id);
saveWithoutId(entityTag);
return true;
}
void Entity::saveWithoutId(CompoundTag* entityTag) {
entityTag->put(L"Pos", newDoubleList(3, x, y + ySlideOffset, z));
entityTag->put(L"Motion", newDoubleList(3, xd, yd, zd));
entityTag->put(L"Rotation", newFloatList(2, yRot, xRot));
entityTag->putFloat(L"FallDistance", fallDistance);
entityTag->putShort(L"Fire", (short)onFire);
entityTag->putShort(L"Air", (short)getAirSupply());
entityTag->putBoolean(L"OnGround", onGround);
addAdditonalSaveData(entityTag);
}
void Entity::load(CompoundTag* tag) {
// 4jcraft changed c style cast of templated class
// to getting the actual type and casting when needed
ListTag<Tag>* pos = tag->getList(L"Pos");
ListTag<Tag>* motion = tag->getList(L"Motion");
ListTag<Tag>* rotation = tag->getList(L"Rotation");
xd = ((DoubleTag*)motion->get(0))->data;
yd = ((DoubleTag*)motion->get(1))->data;
zd = ((DoubleTag*)motion->get(2))->data;
if (abs(xd) > 10.0) {
xd = 0;
}
if (abs(yd) > 10.0) {
yd = 0;
}
if (abs(zd) > 10.0) {
zd = 0;
}
xo = xOld = x = ((DoubleTag*)pos->get(0))->data;
yo = yOld = y = ((DoubleTag*)pos->get(1))->data;
zo = zOld = z = ((DoubleTag*)pos->get(2))->data;
yRotO = yRot = ((FloatTag*)rotation->get(0))->data;
xRotO = xRot = ((FloatTag*)rotation->get(1))->data;
fallDistance = tag->getFloat(L"FallDistance");
onFire = tag->getShort(L"Fire");
setAirSupply(tag->getShort(L"Air"));
onGround = tag->getBoolean(L"OnGround");
setPos(x, y, z);
setRot(yRot, xRot);
readAdditionalSaveData(tag);
}
const std::wstring Entity::getEncodeId() {
return EntityIO::getEncodeId(shared_from_this());
}
ListTag<DoubleTag>* Entity::newDoubleList(unsigned int number,
double firstValue, ...) {
ListTag<DoubleTag>* res = new ListTag<DoubleTag>();
// Add the first parameter to the ListTag
res->add(new DoubleTag(L"", firstValue));
va_list vl;
va_start(vl, firstValue);
double val;
for (unsigned int i = 1; i < number; i++) {
val = va_arg(vl, double);
res->add(new DoubleTag(L"", val));
}
va_end(vl);
return res;
}
ListTag<FloatTag>* Entity::newFloatList(unsigned int number, float firstValue,
float secondValue) {
ListTag<FloatTag>* res = new ListTag<FloatTag>();
// Add the first parameter to the ListTag
res->add(new FloatTag(L"", firstValue));
// TODO - 4J Stu For some reason the va_list wasn't working correctly here
// We only make a list of two floats so just overriding and not using
// va_list
res->add(new FloatTag(L"", secondValue));
/*
va_list vl;
va_start(vl,firstValue);
float val;
for (unsigned int i = 1; i < number; i++)
{
val = va_arg(vl,float);
res->add(new FloatTag(val));
}
va_end(vl);
*/
return res;
}
float Entity::getShadowHeightOffs() { return bbHeight / 2; }
std::shared_ptr<ItemEntity> Entity::spawnAtLocation(int resource, int count) {
return spawnAtLocation(resource, count, 0);
}
std::shared_ptr<ItemEntity> Entity::spawnAtLocation(int resource, int count,
float yOffs) {
return spawnAtLocation(
std::shared_ptr<ItemInstance>(new ItemInstance(resource, count, 0)),
yOffs);
}
std::shared_ptr<ItemEntity> Entity::spawnAtLocation(
std::shared_ptr<ItemInstance> itemInstance, float yOffs) {
std::shared_ptr<ItemEntity> ie = std::shared_ptr<ItemEntity>(
new ItemEntity(level, x, y + yOffs, z, itemInstance));
ie->throwTime = 10;
level->addEntity(ie);
return ie;
}
bool Entity::isAlive() { return !removed; }
bool Entity::isInWall() {
for (int i = 0; i < 8; i++) {
float xo = ((i >> 0) % 2 - 0.5f) * bbWidth * 0.8f;
float yo = ((i >> 1) % 2 - 0.5f) * 0.1f;
float zo = ((i >> 2) % 2 - 0.5f) * bbWidth * 0.8f;
int xt = Mth::floor(x + xo);
int yt = Mth::floor(y + this->getHeadHeight() + yo);
int zt = Mth::floor(z + zo);
if (level->isSolidBlockingTile(xt, yt, zt)) {
return true;
}
}
return false;
}
bool Entity::interact(std::shared_ptr<Player> player) { return false; }
AABB* Entity::getCollideAgainstBox(std::shared_ptr<Entity> entity) {
return NULL;
}
void Entity::rideTick() {
if (riding->removed) {
riding = nullptr;
return;
}
xd = yd = zd = 0;
tick();
if (riding == NULL) return;
// Sets riders old&new position to it's mount's old&new position (plus the
// ride y-seperatation).
riding->positionRider();
yRideRotA += (riding->yRot - riding->yRotO);
xRideRotA += (riding->xRot - riding->xRotO);
// Wrap rotation angles.
while (yRideRotA >= 180) yRideRotA -= 360;
while (yRideRotA < -180) yRideRotA += 360;
while (xRideRotA >= 180) xRideRotA -= 360;
while (xRideRotA < -180) xRideRotA += 360;
double yra = yRideRotA * 0.5;
double xra = xRideRotA * 0.5;
// Cap rotation speed.
float max = 10;
if (yra > max) yra = max;
if (yra < -max) yra = -max;
if (xra > max) xra = max;
if (xra < -max) xra = -max;
yRideRotA -= yra;
xRideRotA -= xra;
yRot += (float)yra;
xRot += (float)xra;
}
void Entity::positionRider() {
std::shared_ptr<Entity> lockedRider = rider.lock();
if (lockedRider) {
std::shared_ptr<Player> player =
std::dynamic_pointer_cast<Player>(lockedRider);
if (!(player && player->isLocalPlayer())) {
lockedRider->xOld = xOld;
lockedRider->yOld =
yOld + getRideHeight() + lockedRider->getRidingHeight();
lockedRider->zOld = zOld;
}
lockedRider->setPos(
x, y + getRideHeight() + lockedRider->getRidingHeight(), z);
}
}
double Entity::getRidingHeight() { return heightOffset; }
double Entity::getRideHeight() { return bbHeight * .75; }
void Entity::ride(std::shared_ptr<Entity> e) {
xRideRotA = 0;
yRideRotA = 0;
if (e == NULL) {
if (riding != NULL) {
// 4J Stu - Position should already be updated before the
// SetRidingPacket comes in
if (!level->isClientSide)
moveTo(riding->x, riding->bb->y0 + riding->bbHeight, riding->z,
yRot, xRot);
riding->rider = std::weak_ptr<Entity>();
}
riding = nullptr;
return;
}
if (riding != NULL) {
riding->rider = std::weak_ptr<Entity>();
}
riding = e;
e->rider = shared_from_this();
}
// 4J Stu - Brought forward from 12w36 to fix #46282 - TU5: Gameplay: Exiting
// the minecart in a tight corridor damages the player
void Entity::findStandUpPosition(std::shared_ptr<Entity> vehicle) {
AABB* boundingBox;
double fallbackX = vehicle->x;
double fallbackY = vehicle->bb->y0 + vehicle->bbHeight;
double fallbackZ = vehicle->z;
for (double xDiff = -1.5; xDiff < 2; xDiff += 1.5) {
for (double zDiff = -1.5; zDiff < 2; zDiff += 1.5) {
if (xDiff == 0 && zDiff == 0) {
continue;
}
int xToInt = (int)(this->x + xDiff);
int zToInt = (int)(this->z + zDiff);
// 4J Stu - Added loop over y to restaring the bb into 2 block high
// spaces if required (eg the track block plus 1 air block above it
// for minecarts)
for (double yDiff = 1.0; yDiff >= 0; yDiff -= 0.5) {
boundingBox = this->bb->cloneMove(xDiff, yDiff, zDiff);
if (level->getTileCubes(boundingBox, true)->size() == 0) {
if (level->isTopSolidBlocking(
xToInt, (int)(y - (1 - yDiff)), zToInt)) {
this->moveTo(this->x + xDiff, this->y + yDiff,
this->z + zDiff, yRot, xRot);
return;
} else if (level->isTopSolidBlocking(
xToInt, (int)(y - (1 - yDiff)) - 1,
zToInt) ||
level->getMaterial(xToInt,
(int)(y - (1 - yDiff)) - 1,
zToInt) == Material::water) {
fallbackX = x + xDiff;
fallbackY = y + yDiff;
fallbackZ = z + zDiff;
}
}
}
}
}
this->moveTo(fallbackX, fallbackY, fallbackZ, yRot, xRot);
}
void Entity::lerpTo(double x, double y, double z, float yRot, float xRot,
int steps) {
setPos(x, y, z);
setRot(yRot, xRot);
// 4J - don't know what this special y collision is specifically for, but
// its definitely bad news for arrows as they are actually Meant to
// intersect the geometry they land in slightly.
if (GetType() != eTYPE_ARROW) {
AABBList* collisions = level->getCubes(
shared_from_this(), bb->shrink(1 / 32.0, 0, 1 / 32.0));
if (!collisions->empty()) {
double yTop = 0;
AUTO_VAR(itEnd, collisions->end());
for (AUTO_VAR(it, collisions->begin()); it != itEnd; it++) {
AABB* ab = *it; // collisions->at(i);
if (ab->y1 > yTop) yTop = ab->y1;
}
y += yTop - bb->y0;
setPos(x, y, z);
}
}
}
float Entity::getPickRadius() { return 0.1f; }
Vec3* Entity::getLookAngle() { return NULL; }
void Entity::handleInsidePortal() {}
void Entity::lerpMotion(double xd, double yd, double zd) {
this->xd = xd;
this->yd = yd;
this->zd = zd;
}
void Entity::handleEntityEvent(uint8_t eventId) {}
void Entity::animateHurt() {}
void Entity::prepareCustomTextures() {}
ItemInstanceArray Entity::getEquipmentSlots() // ItemInstance[]
{
return ItemInstanceArray(); // Default ctor creates NULL internal array
}
// 4J Stu - Brought forward change from 1.3 to fix #64688 - Customer
// Encountered: TU7: Content: Art: Aura of enchanted item is not displayed for
// other players in online game
void Entity::setEquippedSlot(int slot, std::shared_ptr<ItemInstance> item) {}
bool Entity::isOnFire() { return onFire > 0 || getSharedFlag(FLAG_ONFIRE); }
bool Entity::isRiding() { return riding != NULL || getSharedFlag(FLAG_RIDING); }
bool Entity::isSneaking() { return getSharedFlag(FLAG_SNEAKING); }
void Entity::setSneaking(bool value) { setSharedFlag(FLAG_SNEAKING, value); }
bool Entity::isIdle() { return getSharedFlag(FLAG_IDLEANIM); }
void Entity::setIsIdle(bool value) { setSharedFlag(FLAG_IDLEANIM, value); }
bool Entity::isSprinting() { return getSharedFlag(FLAG_SPRINTING); }
void Entity::setSprinting(bool value) { setSharedFlag(FLAG_SPRINTING, value); }
bool Entity::isInvisible() { return getSharedFlag(FLAG_INVISIBLE); }
bool Entity::isInvisibleTo(std::shared_ptr<Player> plr) {
return isInvisible();
}
void Entity::setInvisible(bool value) { setSharedFlag(FLAG_INVISIBLE, value); }
bool Entity::isWeakened() { return getSharedFlag(FLAG_EFFECT_WEAKENED); }
void Entity::setWeakened(bool value) {
setSharedFlag(FLAG_EFFECT_WEAKENED, value);
}
bool Entity::isUsingItemFlag() { return getSharedFlag(FLAG_USING_ITEM); }
void Entity::setUsingItemFlag(bool value) {
setSharedFlag(FLAG_USING_ITEM, value);
}
bool Entity::getSharedFlag(int flag) {
return (entityData->getByte(DATA_SHARED_FLAGS_ID) & (1 << flag)) != 0;
}
void Entity::setSharedFlag(int flag, bool value) {
uint8_t currentValue = entityData->getByte(DATA_SHARED_FLAGS_ID);
if (value) {
entityData->set(DATA_SHARED_FLAGS_ID,
(uint8_t)(currentValue | (1 << flag)));
} else {
entityData->set(DATA_SHARED_FLAGS_ID,
(uint8_t)(currentValue & ~(1 << flag)));
}
}
// 4J Stu - Brought forward from 1.2.3 to fix 38654 - Gameplay: Player will take
// damage when air bubbles are present if resuming game from load/autosave
// underwater.
int Entity::getAirSupply() { return entityData->getShort(DATA_AIR_SUPPLY_ID); }
// 4J Stu - Brought forward from 1.2.3 to fix 38654 - Gameplay: Player will take
// damage when air bubbles are present if resuming game from load/autosave
// underwater.
void Entity::setAirSupply(int supply) {
entityData->set(DATA_AIR_SUPPLY_ID, (short)supply);
}
void Entity::thunderHit(const LightningBolt* lightningBolt) {
burn(5);
onFire++;
if (onFire == 0) setOnFire(8);
}
void Entity::killed(std::shared_ptr<Mob> mob) {}
bool Entity::checkInTile(double x, double y, double z) {
int xTile = Mth::floor(x);
int yTile = Mth::floor(y);
int zTile = Mth::floor(z);
double xd = x - (xTile);
double yd = y - (yTile);
double zd = z - (zTile);
if (level->isSolidBlockingTile(xTile, yTile, zTile)) {
bool west = !level->isSolidBlockingTile(xTile - 1, yTile, zTile);
bool east = !level->isSolidBlockingTile(xTile + 1, yTile, zTile);
bool up = !level->isSolidBlockingTile(xTile, yTile - 1, zTile);
bool down = !level->isSolidBlockingTile(xTile, yTile + 1, zTile);
bool north = !level->isSolidBlockingTile(xTile, yTile, zTile - 1);
bool south = !level->isSolidBlockingTile(xTile, yTile, zTile + 1);
int dir = -1;
double closest = 9999;
if (west && xd < closest) {
closest = xd;
dir = 0;
}
if (east && 1 - xd < closest) {
closest = 1 - xd;
dir = 1;
}
if (up && yd < closest) {
closest = yd;
dir = 2;
}
if (down && 1 - yd < closest) {
closest = 1 - yd;
dir = 3;
}
if (north && zd < closest) {
closest = zd;
dir = 4;
}
if (south && 1 - zd < closest) {
closest = 1 - zd;
dir = 5;
}
float speed = random->nextFloat() * 0.2f + 0.1f;
if (dir == 0) this->xd = -speed;
if (dir == 1) this->xd = +speed;
if (dir == 2) this->yd = -speed;
if (dir == 3) this->yd = +speed;
if (dir == 4) this->zd = -speed;
if (dir == 5) this->zd = +speed;
return true;
}
return false;
}
void Entity::makeStuckInWeb() {
isStuckInWeb = true;
fallDistance = 0;
}
std::wstring Entity::getAName() {
std::wstring id = EntityIO::getEncodeId(shared_from_this());
if (id.empty()) id = L"generic";
return L"entity." + id + _toString(entityId);
// return I18n.get("entity." + id + ".name");
}
std::vector<std::shared_ptr<Entity> >* Entity::getSubEntities() { return NULL; }
bool Entity::is(std::shared_ptr<Entity> other) {
return shared_from_this() == other;
}
float Entity::getYHeadRot() { return 0; }
void Entity::setYHeadRot(float yHeadRot) {}
bool Entity::isAttackable() { return true; }
bool Entity::isInvulnerable() { return false; }
void Entity::copyPosition(std::shared_ptr<Entity> target) {
moveTo(target->x, target->y, target->z, target->yRot, target->xRot);
}
void Entity::setAnimOverrideBitmask(unsigned int uiBitmask) {
m_uiAnimOverrideBitmask = uiBitmask;
app.DebugPrintf("!!! Setting anim override bitmask to %d\n", uiBitmask);
}
unsigned int Entity::getAnimOverrideBitmask() {
if (app.GetGameSettings(eGameSetting_CustomSkinAnim) == 0) {
// We have a force animation for some skins (claptrap)
// 4J-PB - treat all the eAnim_Disable flags as a force anim
unsigned int uiIgnoreUserCustomSkinAnimSettingMask =
(1 << HumanoidModel::eAnim_ForceAnim) |
(1 << HumanoidModel::eAnim_DisableRenderArm0) |
(1 << HumanoidModel::eAnim_DisableRenderArm1) |
(1 << HumanoidModel::eAnim_DisableRenderTorso) |
(1 << HumanoidModel::eAnim_DisableRenderLeg0) |
(1 << HumanoidModel::eAnim_DisableRenderLeg1) |
(1 << HumanoidModel::eAnim_DisableRenderHair);
if ((m_uiAnimOverrideBitmask &
HumanoidModel::m_staticBitmaskIgnorePlayerCustomAnimSetting) !=
0) {
return m_uiAnimOverrideBitmask;
}
return 0;
}
return m_uiAnimOverrideBitmask;
}
Reference in a new issue View git blame Copy permalink