2014-04-24 17:03:47 -04:00
|
|
|
|
2012-06-14 09:06:06 -04:00
|
|
|
#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules
|
|
|
|
|
2012-09-23 18:09:57 -04:00
|
|
|
#include "Entity.h"
|
2018-08-28 20:51:25 -04:00
|
|
|
#include "Player.h"
|
2020-04-03 02:57:01 -04:00
|
|
|
#include "../BlockInfo.h"
|
2013-08-19 05:39:13 -04:00
|
|
|
#include "../World.h"
|
|
|
|
#include "../Root.h"
|
2014-03-11 12:32:33 -04:00
|
|
|
#include "../Matrix4.h"
|
2013-08-19 05:39:13 -04:00
|
|
|
#include "../ClientHandle.h"
|
|
|
|
#include "../Chunk.h"
|
|
|
|
#include "../Simulator/FluidSimulator.h"
|
2013-12-08 06:17:54 -05:00
|
|
|
#include "../Bindings/PluginManager.h"
|
2017-05-11 08:34:36 -04:00
|
|
|
#include "../LineBlockTracer.h"
|
2018-08-28 20:51:25 -04:00
|
|
|
#include "../Items/ItemHandler.h"
|
2014-08-21 06:08:38 -04:00
|
|
|
#include "../FastRandom.h"
|
2015-05-26 21:35:28 -04:00
|
|
|
#include "../NetherPortalScanner.h"
|
2018-07-23 05:24:00 -04:00
|
|
|
#include "../BoundingBox.h"
|
2012-06-14 09:06:06 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2017-06-15 11:06:50 -04:00
|
|
|
static UInt32 GetNextUniqueID(void)
|
|
|
|
{
|
|
|
|
static std::atomic<UInt32> counter(1);
|
|
|
|
return counter.fetch_add(1);
|
|
|
|
}
|
|
|
|
|
2012-06-14 09:06:06 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2017-06-15 11:06:50 -04:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// cEntity:
|
2012-06-14 09:06:06 -04:00
|
|
|
|
2019-09-29 08:59:24 -04:00
|
|
|
cEntity::cEntity(eEntityType a_EntityType, Vector3d a_Pos, double a_Width, double a_Height):
|
2017-06-15 11:06:50 -04:00
|
|
|
m_UniqueID(GetNextUniqueID()),
|
2015-03-21 10:18:17 -04:00
|
|
|
m_Health(1),
|
|
|
|
m_MaxHealth(1),
|
|
|
|
m_AttachedTo(nullptr),
|
|
|
|
m_Attachee(nullptr),
|
2020-04-21 18:16:28 -04:00
|
|
|
m_bDirtyHead(false),
|
|
|
|
m_bDirtyOrientation(false),
|
2015-03-21 10:18:17 -04:00
|
|
|
m_bHasSentNoSpeed(true),
|
|
|
|
m_bOnGround(false),
|
|
|
|
m_Gravity(-9.81f),
|
2015-03-31 11:03:35 -04:00
|
|
|
m_AirDrag(0.02f),
|
2020-03-07 06:56:02 -05:00
|
|
|
m_LastSentPosition(a_Pos),
|
2019-09-29 08:59:24 -04:00
|
|
|
m_LastPosition(a_Pos),
|
2015-03-21 10:18:17 -04:00
|
|
|
m_EntityType(a_EntityType),
|
|
|
|
m_World(nullptr),
|
|
|
|
m_IsFireproof(false),
|
|
|
|
m_TicksSinceLastBurnDamage(0),
|
|
|
|
m_TicksSinceLastLavaDamage(0),
|
|
|
|
m_TicksSinceLastFireDamage(0),
|
|
|
|
m_TicksLeftBurning(0),
|
|
|
|
m_TicksSinceLastVoidDamage(0),
|
2018-01-14 13:44:45 -05:00
|
|
|
m_IsInFire(false),
|
|
|
|
m_IsInLava(false),
|
|
|
|
m_IsInWater(false),
|
|
|
|
m_IsHeadInWater(false),
|
2017-08-25 09:44:36 -04:00
|
|
|
m_AirLevel(MAX_AIR_LEVEL),
|
|
|
|
m_AirTickTimer(DROWNING_TICKS),
|
2015-03-21 10:18:17 -04:00
|
|
|
m_TicksAlive(0),
|
2016-02-07 12:07:14 -05:00
|
|
|
m_IsTicking(false),
|
|
|
|
m_ParentChunk(nullptr),
|
2015-03-21 10:18:17 -04:00
|
|
|
m_HeadYaw(0.0),
|
|
|
|
m_Rot(0.0, 0.0, 0.0),
|
2019-09-29 08:59:24 -04:00
|
|
|
m_Position(a_Pos),
|
2015-03-21 10:18:17 -04:00
|
|
|
m_WaterSpeed(0, 0, 0),
|
|
|
|
m_Mass (0.001), // Default 1g
|
|
|
|
m_Width(a_Width),
|
|
|
|
m_Height(a_Height),
|
|
|
|
m_InvulnerableTicks(0)
|
2012-06-14 09:06:06 -04:00
|
|
|
{
|
2020-04-05 08:41:14 -04:00
|
|
|
m_WorldChangeInfo.m_NewWorld = nullptr;
|
2012-06-14 09:06:06 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cEntity::~cEntity()
|
|
|
|
{
|
2016-02-07 12:07:14 -05:00
|
|
|
|
2014-01-24 03:57:12 -05:00
|
|
|
// Before deleting, the entity needs to have been removed from the world, if ever added
|
2014-10-20 16:55:07 -04:00
|
|
|
ASSERT((m_World == nullptr) || !m_World->HasEntity(m_UniqueID));
|
2016-02-07 12:07:14 -05:00
|
|
|
ASSERT(!IsTicking());
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2014-01-16 14:31:06 -05:00
|
|
|
/*
|
|
|
|
// DEBUG:
|
2018-09-24 16:33:39 -04:00
|
|
|
FLOGD("Deleting entity {0} at pos {1:.2f} ~ [{2}, {3}]; ptr {4}",
|
2012-06-14 09:06:06 -04:00
|
|
|
m_UniqueID,
|
2018-09-24 16:33:39 -04:00
|
|
|
m_Pos,
|
|
|
|
GetChunkX(), GetChunkZ(),
|
|
|
|
static_cast<void *>(this)
|
|
|
|
);
|
2014-01-16 14:31:06 -05:00
|
|
|
*/
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2014-10-20 16:55:07 -04:00
|
|
|
if (m_AttachedTo != nullptr)
|
2013-03-03 14:05:11 -05:00
|
|
|
{
|
|
|
|
Detach();
|
|
|
|
}
|
2014-10-20 16:55:07 -04:00
|
|
|
if (m_Attachee != nullptr)
|
2013-03-03 14:05:11 -05:00
|
|
|
{
|
|
|
|
m_Attachee->Detach();
|
|
|
|
}
|
2012-06-14 09:06:06 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-02-02 18:55:29 -05:00
|
|
|
const char * cEntity::GetClass(void) const
|
|
|
|
{
|
|
|
|
return "cEntity";
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const char * cEntity::GetClassStatic(void)
|
|
|
|
{
|
|
|
|
return "cEntity";
|
|
|
|
}
|
2012-08-24 03:58:26 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2012-12-21 07:21:20 -05:00
|
|
|
const char * cEntity::GetParentClass(void) const
|
|
|
|
{
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2016-12-19 15:12:23 -05:00
|
|
|
bool cEntity::Initialize(OwnedEntity a_Self, cWorld & a_EntityWorld)
|
2012-06-14 09:06:06 -04:00
|
|
|
{
|
2016-12-19 15:12:23 -05:00
|
|
|
if (cPluginManager::Get()->CallHookSpawningEntity(a_EntityWorld, *this))
|
2013-08-08 03:13:13 -04:00
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2014-01-16 14:31:06 -05:00
|
|
|
/*
|
|
|
|
// DEBUG:
|
2018-09-24 16:33:39 -04:00
|
|
|
FLOGD("Initializing entity #{0} ({1}) at {2:.02f}",
|
|
|
|
m_UniqueID, GetClass(), m_Pos
|
2013-04-13 17:02:10 -04:00
|
|
|
);
|
2014-01-16 14:31:06 -05:00
|
|
|
*/
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2016-02-07 12:07:14 -05:00
|
|
|
ASSERT(m_World == nullptr);
|
|
|
|
ASSERT(GetParentChunk() == nullptr);
|
2020-05-02 18:37:35 -04:00
|
|
|
SetWorld(&a_EntityWorld);
|
2016-12-19 15:12:23 -05:00
|
|
|
a_EntityWorld.AddEntity(std::move(a_Self));
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2020-03-05 05:52:34 -05:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void cEntity::OnAddToWorld(cWorld & a_World)
|
|
|
|
{
|
2013-08-25 15:25:13 -04:00
|
|
|
// Spawn the entity on the clients:
|
2020-03-05 05:52:34 -05:00
|
|
|
m_LastSentPosition = GetPosition();
|
|
|
|
a_World.BroadcastSpawnEntity(*this);
|
|
|
|
BroadcastLeashedMobs();
|
|
|
|
}
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2017-08-21 04:46:41 -04:00
|
|
|
|
2020-03-05 05:52:34 -05:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void cEntity::OnRemoveFromWorld(cWorld & a_World)
|
|
|
|
{
|
|
|
|
RemoveAllLeashedMobs();
|
|
|
|
a_World.BroadcastDestroyEntity(*this);
|
2012-06-14 09:06:06 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-04-13 17:02:10 -04:00
|
|
|
void cEntity::WrapHeadYaw(void)
|
2013-04-02 02:48:31 -04:00
|
|
|
{
|
2013-12-08 07:08:56 -05:00
|
|
|
m_HeadYaw = NormalizeAngleDegrees(m_HeadYaw);
|
2013-04-02 02:48:31 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2018-07-26 17:24:36 -04:00
|
|
|
|
2013-04-13 17:02:10 -04:00
|
|
|
void cEntity::WrapRotation(void)
|
2012-06-14 09:06:06 -04:00
|
|
|
{
|
2013-12-08 07:08:56 -05:00
|
|
|
m_Rot.x = NormalizeAngleDegrees(m_Rot.x);
|
2013-12-08 12:54:04 -05:00
|
|
|
m_Rot.y = NormalizeAngleDegrees(m_Rot.y);
|
2012-06-14 09:06:06 -04:00
|
|
|
}
|
|
|
|
|
2013-04-13 17:02:10 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
2018-07-26 17:24:36 -04:00
|
|
|
|
2013-04-13 17:02:10 -04:00
|
|
|
void cEntity::WrapSpeed(void)
|
2013-03-22 02:33:10 -04:00
|
|
|
{
|
2014-06-16 10:12:50 -04:00
|
|
|
m_Speed.x = Clamp(m_Speed.x, -78.0, 78.0);
|
|
|
|
m_Speed.y = Clamp(m_Speed.y, -78.0, 78.0);
|
|
|
|
m_Speed.z = Clamp(m_Speed.z, -78.0, 78.0);
|
2013-03-22 02:33:10 -04:00
|
|
|
}
|
|
|
|
|
2012-06-14 09:06:06 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2016-02-07 12:07:14 -05:00
|
|
|
void cEntity::SetParentChunk(cChunk * a_Chunk)
|
|
|
|
{
|
|
|
|
m_ParentChunk = a_Chunk;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-03-05 05:52:34 -05:00
|
|
|
void cEntity::Destroy()
|
2012-06-14 09:06:06 -04:00
|
|
|
{
|
2016-02-07 12:07:14 -05:00
|
|
|
SetIsTicking(false);
|
|
|
|
|
2017-08-21 04:46:41 -04:00
|
|
|
// Unleash leashed mobs
|
|
|
|
while (!m_LeashedMobs.empty())
|
|
|
|
{
|
|
|
|
m_LeashedMobs.front()->Unleash(true, true);
|
|
|
|
}
|
|
|
|
|
2017-09-05 10:11:35 -04:00
|
|
|
auto ParentChunkCoords = cChunkDef::BlockToChunk(GetPosition());
|
|
|
|
m_World->QueueTask([this, ParentChunkCoords](cWorld & a_World)
|
2016-02-07 12:07:14 -05:00
|
|
|
{
|
|
|
|
LOGD("Destroying entity #%i (%s) from chunk (%d, %d)",
|
|
|
|
this->GetUniqueID(), this->GetClass(),
|
2017-09-05 10:11:35 -04:00
|
|
|
ParentChunkCoords.m_ChunkX, ParentChunkCoords.m_ChunkZ
|
2016-02-07 12:07:14 -05:00
|
|
|
);
|
2017-12-21 06:36:58 -05:00
|
|
|
UNUSED(ParentChunkCoords); // Non Debug mode only
|
2016-12-19 15:12:23 -05:00
|
|
|
|
|
|
|
// Make sure that RemoveEntity returned a valid smart pointer
|
|
|
|
// Also, not storing the returned pointer means automatic destruction
|
2017-09-05 10:11:35 -04:00
|
|
|
VERIFY(a_World.RemoveEntity(*this));
|
2016-02-07 12:07:14 -05:00
|
|
|
});
|
|
|
|
Destroyed();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void cEntity::DestroyNoScheduling(bool a_ShouldBroadcast)
|
|
|
|
{
|
|
|
|
SetIsTicking(false);
|
2013-06-25 02:36:59 -04:00
|
|
|
if (a_ShouldBroadcast)
|
|
|
|
{
|
|
|
|
m_World->BroadcastDestroyEntity(*this);
|
|
|
|
}
|
2013-04-02 02:48:31 -04:00
|
|
|
|
2012-06-14 09:06:06 -04:00
|
|
|
Destroyed();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-07-01 06:39:56 -04:00
|
|
|
void cEntity::TakeDamage(cEntity & a_Attacker)
|
|
|
|
{
|
|
|
|
int RawDamage = a_Attacker.GetRawDamageAgainst(*this);
|
|
|
|
TakeDamage(dtAttack, &a_Attacker, RawDamage, a_Attacker.GetKnockbackAmountAgainst(*this));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void cEntity::TakeDamage(eDamageType a_DamageType, cEntity * a_Attacker, int a_RawDamage, double a_KnockbackAmount)
|
|
|
|
{
|
2020-05-06 03:24:39 -04:00
|
|
|
float FinalDamage = static_cast<float>(a_RawDamage);
|
2020-03-22 06:39:32 -04:00
|
|
|
float ArmorCover = GetArmorCoverAgainst(a_Attacker, a_DamageType, a_RawDamage);
|
|
|
|
|
|
|
|
ApplyArmorDamage(static_cast<int>(ArmorCover));
|
2017-07-23 05:46:38 -04:00
|
|
|
|
2020-03-22 06:39:32 -04:00
|
|
|
cEntity::TakeDamage(a_DamageType, a_Attacker, a_RawDamage, FinalDamage, a_KnockbackAmount);
|
2013-07-01 06:39:56 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2016-01-22 13:55:46 -05:00
|
|
|
void cEntity::TakeDamage(eDamageType a_DamageType, UInt32 a_AttackerID, int a_RawDamage, double a_KnockbackAmount)
|
|
|
|
{
|
2017-09-11 17:20:49 -04:00
|
|
|
m_World->DoWithEntityByID(a_AttackerID, [=](cEntity & a_Attacker)
|
2016-01-22 13:55:46 -05:00
|
|
|
{
|
|
|
|
cPawn * Attacker;
|
2017-09-11 17:20:49 -04:00
|
|
|
if (a_Attacker.IsPawn())
|
2016-01-22 13:55:46 -05:00
|
|
|
{
|
2017-09-11 17:20:49 -04:00
|
|
|
Attacker = static_cast<cPawn*>(&a_Attacker);
|
2016-01-22 13:55:46 -05:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Attacker = nullptr;
|
|
|
|
}
|
|
|
|
|
2017-09-11 17:20:49 -04:00
|
|
|
TakeDamage(a_DamageType, Attacker, a_RawDamage, a_KnockbackAmount);
|
2016-01-22 13:55:46 -05:00
|
|
|
return true;
|
|
|
|
}
|
2017-09-11 17:20:49 -04:00
|
|
|
);
|
2016-01-22 13:55:46 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2019-08-08 06:51:38 -04:00
|
|
|
void cEntity::TakeDamage(eDamageType a_DamageType, cEntity * a_Attacker, int a_RawDamage, float a_FinalDamage, double a_KnockbackAmount)
|
2013-07-01 06:39:56 -04:00
|
|
|
{
|
|
|
|
TakeDamageInfo TDI;
|
|
|
|
TDI.DamageType = a_DamageType;
|
2016-01-16 07:16:47 -05:00
|
|
|
if ((a_Attacker != nullptr) && a_Attacker->IsPawn())
|
|
|
|
{
|
|
|
|
TDI.Attacker = a_Attacker;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
TDI.Attacker = nullptr;
|
|
|
|
}
|
2020-03-22 06:39:32 -04:00
|
|
|
|
|
|
|
if (a_RawDamage <= 0)
|
|
|
|
{
|
|
|
|
a_RawDamage = 0;
|
|
|
|
}
|
|
|
|
|
2013-07-01 06:39:56 -04:00
|
|
|
TDI.RawDamage = a_RawDamage;
|
2020-03-22 06:39:32 -04:00
|
|
|
|
|
|
|
if (a_FinalDamage <= 0)
|
|
|
|
{
|
|
|
|
a_FinalDamage = 0;
|
|
|
|
}
|
|
|
|
|
2013-07-01 06:39:56 -04:00
|
|
|
TDI.FinalDamage = a_FinalDamage;
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2013-12-22 15:04:17 -05:00
|
|
|
Vector3d Heading(0, 0, 0);
|
2014-10-20 16:55:07 -04:00
|
|
|
if (a_Attacker != nullptr)
|
2013-12-22 15:04:17 -05:00
|
|
|
{
|
2017-08-13 07:40:23 -04:00
|
|
|
Heading = a_Attacker->GetLookVector();
|
2013-12-22 15:04:17 -05:00
|
|
|
}
|
|
|
|
|
2020-03-19 13:13:41 -04:00
|
|
|
int KnockbackHeight = 3;
|
|
|
|
|
|
|
|
if (IsPlayer())
|
|
|
|
{
|
|
|
|
KnockbackHeight = 8;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Apply slight height to knockback
|
|
|
|
Vector3d FinalKnockback = Vector3d(Heading.x * a_KnockbackAmount, Heading.y + KnockbackHeight, Heading.z * a_KnockbackAmount);
|
|
|
|
|
|
|
|
TDI.Knockback = FinalKnockback;
|
2013-07-01 06:39:56 -04:00
|
|
|
DoTakeDamage(TDI);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-01-16 14:00:49 -05:00
|
|
|
void cEntity::SetYawFromSpeed(void)
|
2013-09-07 11:14:37 -04:00
|
|
|
{
|
|
|
|
const double EPS = 0.0000001;
|
2014-09-22 03:22:36 -04:00
|
|
|
if ((std::abs(m_Speed.x) < EPS) && (std::abs(m_Speed.z) < EPS))
|
2013-09-07 11:14:37 -04:00
|
|
|
{
|
|
|
|
// atan2() may overflow or is undefined, pick any number
|
2014-01-16 14:00:49 -05:00
|
|
|
SetYaw(0);
|
2013-09-07 11:14:37 -04:00
|
|
|
return;
|
|
|
|
}
|
2014-10-20 16:55:07 -04:00
|
|
|
SetYaw(atan2(m_Speed.x, m_Speed.z) * 180 / M_PI);
|
2013-09-07 11:14:37 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void cEntity::SetPitchFromSpeed(void)
|
|
|
|
{
|
|
|
|
const double EPS = 0.0000001;
|
2014-07-17 16:15:34 -04:00
|
|
|
double xz = sqrt(m_Speed.x * m_Speed.x + m_Speed.z * m_Speed.z); // Speed XZ-plane component
|
2014-09-22 03:22:36 -04:00
|
|
|
if ((std::abs(xz) < EPS) && (std::abs(m_Speed.y) < EPS))
|
2013-09-07 11:14:37 -04:00
|
|
|
{
|
|
|
|
// atan2() may overflow or is undefined, pick any number
|
|
|
|
SetPitch(0);
|
|
|
|
return;
|
|
|
|
}
|
2014-10-20 16:55:07 -04:00
|
|
|
SetPitch(atan2(m_Speed.y, xz) * 180 / M_PI);
|
2013-09-07 11:14:37 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-04-25 18:32:30 -04:00
|
|
|
bool cEntity::DoTakeDamage(TakeDamageInfo & a_TDI)
|
2013-07-01 06:39:56 -04:00
|
|
|
{
|
|
|
|
if (m_Health <= 0)
|
|
|
|
{
|
|
|
|
// Can't take damage if already dead
|
2014-04-25 18:32:30 -04:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (m_InvulnerableTicks > 0)
|
|
|
|
{
|
|
|
|
// Entity is invulnerable
|
|
|
|
return false;
|
2013-07-01 06:39:56 -04:00
|
|
|
}
|
|
|
|
|
2014-07-23 10:32:09 -04:00
|
|
|
if (cRoot::Get()->GetPluginManager()->CallHookTakeDamage(*this, a_TDI))
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-10-20 16:55:07 -04:00
|
|
|
if ((a_TDI.Attacker != nullptr) && (a_TDI.Attacker->IsPlayer()))
|
2013-12-22 15:04:17 -05:00
|
|
|
{
|
2018-05-02 03:50:36 -04:00
|
|
|
cPlayer * Player = static_cast<cPlayer *>(a_TDI.Attacker);
|
2014-05-12 14:38:52 -04:00
|
|
|
|
2014-07-23 10:32:09 -04:00
|
|
|
Player->GetEquippedItem().GetHandler()->OnEntityAttack(Player, this);
|
|
|
|
|
2014-06-07 22:58:41 -04:00
|
|
|
// TODO: Better damage increase, and check for enchantments (and use magic critical instead of plain)
|
2018-01-17 16:12:24 -05:00
|
|
|
|
|
|
|
// IsOnGround() only is false if the player is moving downwards
|
|
|
|
// Ref: https://minecraft.gamepedia.com/Damage#Critical_Hits
|
|
|
|
if (!Player->IsOnGround())
|
|
|
|
{
|
|
|
|
if ((a_TDI.DamageType == dtAttack) || (a_TDI.DamageType == dtArrowAttack))
|
|
|
|
{
|
2019-08-11 05:39:43 -04:00
|
|
|
a_TDI.FinalDamage *= 1.5f; // 150% damage
|
2018-01-17 16:12:24 -05:00
|
|
|
m_World->BroadcastEntityAnimation(*this, 4); // Critical hit
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-01 08:31:05 -04:00
|
|
|
const cEnchantments & Enchantments = Player->GetEquippedItem().m_Enchantments;
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2015-07-29 11:04:03 -04:00
|
|
|
int SharpnessLevel = static_cast<int>(Enchantments.GetLevel(cEnchantments::enchSharpness));
|
|
|
|
int SmiteLevel = static_cast<int>(Enchantments.GetLevel(cEnchantments::enchSmite));
|
|
|
|
int BaneOfArthropodsLevel = static_cast<int>(Enchantments.GetLevel(cEnchantments::enchBaneOfArthropods));
|
2014-08-19 06:38:15 -04:00
|
|
|
|
|
|
|
if (SharpnessLevel > 0)
|
|
|
|
{
|
2019-08-11 05:39:43 -04:00
|
|
|
a_TDI.FinalDamage += 1.25f * SharpnessLevel;
|
2014-08-19 06:38:15 -04:00
|
|
|
}
|
|
|
|
else if (SmiteLevel > 0)
|
|
|
|
{
|
|
|
|
if (IsMob())
|
|
|
|
{
|
2018-05-02 03:50:36 -04:00
|
|
|
cMonster * Monster = static_cast<cMonster *>(this);
|
2014-08-19 06:38:15 -04:00
|
|
|
switch (Monster->GetMobType())
|
|
|
|
{
|
2014-09-17 13:40:10 -04:00
|
|
|
case mtSkeleton:
|
|
|
|
case mtWither:
|
2018-02-03 06:24:19 -05:00
|
|
|
case mtZombie:
|
2014-09-17 13:40:10 -04:00
|
|
|
case mtZombiePigman:
|
2018-02-03 06:24:19 -05:00
|
|
|
case mtZombieVillager:
|
2014-08-19 06:38:15 -04:00
|
|
|
{
|
2019-08-11 05:39:43 -04:00
|
|
|
a_TDI.FinalDamage += 2.5f * SmiteLevel;
|
2014-08-19 06:38:15 -04:00
|
|
|
break;
|
|
|
|
}
|
2014-09-22 18:23:56 -04:00
|
|
|
default: break;
|
2014-08-19 06:38:15 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (BaneOfArthropodsLevel > 0)
|
2013-12-22 15:04:17 -05:00
|
|
|
{
|
2014-08-19 06:38:15 -04:00
|
|
|
if (IsMob())
|
|
|
|
{
|
2018-05-02 03:50:36 -04:00
|
|
|
cMonster * Monster = static_cast<cMonster *>(this);
|
2014-08-19 06:38:15 -04:00
|
|
|
switch (Monster->GetMobType())
|
|
|
|
{
|
2014-09-17 13:40:10 -04:00
|
|
|
case mtSpider:
|
|
|
|
case mtCaveSpider:
|
|
|
|
case mtSilverfish:
|
2014-08-19 06:38:15 -04:00
|
|
|
{
|
2019-08-11 05:39:43 -04:00
|
|
|
a_TDI.FinalDamage += 2.5f * BaneOfArthropodsLevel;
|
2017-08-21 04:51:26 -04:00
|
|
|
// The duration of the effect is a random value between 1 and 1.5 seconds at level I,
|
|
|
|
// increasing the max duration by 0.5 seconds each level
|
|
|
|
// Ref: https://minecraft.gamepedia.com/Enchanting#Bane_of_Arthropods
|
|
|
|
int Duration = 20 + GetRandomProvider().RandInt(BaneOfArthropodsLevel * 10); // Duration in ticks
|
|
|
|
Monster->AddEntityEffect(cEntityEffect::effSlowness, Duration, 4);
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2014-08-19 06:38:15 -04:00
|
|
|
break;
|
2017-08-21 04:51:26 -04:00
|
|
|
}
|
2014-08-22 05:49:49 -04:00
|
|
|
default: break;
|
2014-08-19 06:38:15 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-29 11:04:03 -04:00
|
|
|
int FireAspectLevel = static_cast<int>(Enchantments.GetLevel(cEnchantments::enchFireAspect));
|
2014-08-19 06:38:15 -04:00
|
|
|
if (FireAspectLevel > 0)
|
|
|
|
{
|
|
|
|
int BurnTicks = 3;
|
|
|
|
|
|
|
|
if (FireAspectLevel > 1)
|
|
|
|
{
|
|
|
|
BurnTicks += 4 * (FireAspectLevel - 1);
|
|
|
|
}
|
2018-01-14 13:44:45 -05:00
|
|
|
if (!IsMob() && !IsInWater())
|
2014-08-19 10:08:17 -04:00
|
|
|
{
|
|
|
|
StartBurning(BurnTicks * 20);
|
|
|
|
}
|
2018-01-14 13:44:45 -05:00
|
|
|
else if (IsMob() && !IsInWater())
|
2014-08-19 10:08:17 -04:00
|
|
|
{
|
2018-05-02 03:50:36 -04:00
|
|
|
cMonster * Monster = static_cast<cMonster *>(this);
|
2014-08-19 10:08:17 -04:00
|
|
|
switch (Monster->GetMobType())
|
|
|
|
{
|
2014-09-17 13:40:10 -04:00
|
|
|
case mtGhast:
|
|
|
|
case mtZombiePigman:
|
|
|
|
case mtMagmaCube:
|
2014-09-03 04:29:10 -04:00
|
|
|
{
|
2014-08-19 10:08:17 -04:00
|
|
|
break;
|
2017-08-21 04:51:26 -04:00
|
|
|
}
|
2014-08-19 10:47:33 -04:00
|
|
|
default: StartBurning(BurnTicks * 20);
|
2014-08-19 10:08:17 -04:00
|
|
|
}
|
|
|
|
}
|
2014-08-22 05:49:49 -04:00
|
|
|
}
|
2014-08-19 06:38:15 -04:00
|
|
|
|
2015-05-19 14:32:10 -04:00
|
|
|
unsigned int ThornsLevel = 0;
|
2014-09-01 08:35:52 -04:00
|
|
|
const cItem ArmorItems[] = { GetEquippedHelmet(), GetEquippedChestplate(), GetEquippedLeggings(), GetEquippedBoots() };
|
2014-08-22 05:49:49 -04:00
|
|
|
for (size_t i = 0; i < ARRAYCOUNT(ArmorItems); i++)
|
|
|
|
{
|
2014-09-01 08:35:52 -04:00
|
|
|
const cItem & Item = ArmorItems[i];
|
|
|
|
ThornsLevel = std::max(ThornsLevel, Item.m_Enchantments.GetLevel(cEnchantments::enchThorns));
|
2014-08-22 05:49:49 -04:00
|
|
|
}
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2014-08-22 05:49:49 -04:00
|
|
|
if (ThornsLevel > 0)
|
|
|
|
{
|
2015-07-29 11:04:03 -04:00
|
|
|
int Chance = static_cast<int>(ThornsLevel * 15);
|
2014-08-22 05:49:49 -04:00
|
|
|
|
2017-06-13 15:35:30 -04:00
|
|
|
auto & Random = GetRandomProvider();
|
2014-08-22 05:49:49 -04:00
|
|
|
|
2017-06-13 15:35:30 -04:00
|
|
|
if (Random.RandBool(Chance / 100.0))
|
2014-08-22 05:49:49 -04:00
|
|
|
{
|
2019-09-27 11:51:44 -04:00
|
|
|
a_TDI.Attacker->TakeDamage(dtAttack, this, 0, Random.RandReal(1.0f, 4.0f), 0);
|
2014-08-22 05:49:49 -04:00
|
|
|
}
|
2014-08-19 06:38:15 -04:00
|
|
|
}
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2015-07-29 11:04:03 -04:00
|
|
|
Player->GetStatManager().AddValue(statDamageDealt, static_cast<StatValue>(floor(a_TDI.FinalDamage * 10 + 0.5)));
|
2013-12-22 15:04:17 -05:00
|
|
|
}
|
2014-08-22 05:49:49 -04:00
|
|
|
|
2019-08-08 06:51:38 -04:00
|
|
|
m_Health -= a_TDI.FinalDamage;
|
2017-11-22 08:47:52 -05:00
|
|
|
m_Health = std::max(m_Health, 0.0f);
|
2013-07-01 06:39:56 -04:00
|
|
|
|
2014-09-01 08:31:05 -04:00
|
|
|
// Add knockback:
|
2014-10-20 16:55:07 -04:00
|
|
|
if ((IsMob() || IsPlayer()) && (a_TDI.Attacker != nullptr))
|
2014-01-12 08:28:37 -05:00
|
|
|
{
|
2020-03-19 13:13:41 -04:00
|
|
|
SetSpeed(a_TDI.Knockback);
|
2014-01-12 08:28:37 -05:00
|
|
|
}
|
2013-12-22 15:04:17 -05:00
|
|
|
|
2014-04-12 08:16:48 -04:00
|
|
|
m_World->BroadcastEntityStatus(*this, esGenericHurt);
|
2013-07-01 06:39:56 -04:00
|
|
|
|
2014-04-25 18:32:30 -04:00
|
|
|
m_InvulnerableTicks = 10;
|
|
|
|
|
2013-07-01 06:39:56 -04:00
|
|
|
if (m_Health <= 0)
|
|
|
|
{
|
2014-07-04 05:55:09 -04:00
|
|
|
KilledBy(a_TDI);
|
2014-05-12 10:05:09 -04:00
|
|
|
|
2014-10-20 16:55:07 -04:00
|
|
|
if (a_TDI.Attacker != nullptr)
|
2014-05-12 10:05:09 -04:00
|
|
|
{
|
|
|
|
a_TDI.Attacker->Killed(this);
|
|
|
|
}
|
2013-07-01 06:39:56 -04:00
|
|
|
}
|
2014-04-25 18:32:30 -04:00
|
|
|
return true;
|
2013-07-01 06:39:56 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int cEntity::GetRawDamageAgainst(const cEntity & a_Receiver)
|
|
|
|
{
|
|
|
|
// Returns the hitpoints that this pawn can deal to a_Receiver using its equipped items
|
2017-08-24 05:19:40 -04:00
|
|
|
// Ref: https://minecraft.gamepedia.com/Damage#Dealing_damage as of 2012_12_20
|
2013-07-01 06:39:56 -04:00
|
|
|
switch (this->GetEquippedWeapon().m_ItemType)
|
|
|
|
{
|
|
|
|
case E_ITEM_WOODEN_SWORD: return 4;
|
|
|
|
case E_ITEM_GOLD_SWORD: return 4;
|
|
|
|
case E_ITEM_STONE_SWORD: return 5;
|
|
|
|
case E_ITEM_IRON_SWORD: return 6;
|
|
|
|
case E_ITEM_DIAMOND_SWORD: return 7;
|
|
|
|
|
|
|
|
case E_ITEM_WOODEN_AXE: return 3;
|
|
|
|
case E_ITEM_GOLD_AXE: return 3;
|
|
|
|
case E_ITEM_STONE_AXE: return 4;
|
|
|
|
case E_ITEM_IRON_AXE: return 5;
|
|
|
|
case E_ITEM_DIAMOND_AXE: return 6;
|
|
|
|
|
|
|
|
case E_ITEM_WOODEN_PICKAXE: return 2;
|
|
|
|
case E_ITEM_GOLD_PICKAXE: return 2;
|
|
|
|
case E_ITEM_STONE_PICKAXE: return 3;
|
|
|
|
case E_ITEM_IRON_PICKAXE: return 4;
|
|
|
|
case E_ITEM_DIAMOND_PICKAXE: return 5;
|
|
|
|
|
|
|
|
case E_ITEM_WOODEN_SHOVEL: return 1;
|
|
|
|
case E_ITEM_GOLD_SHOVEL: return 1;
|
|
|
|
case E_ITEM_STONE_SHOVEL: return 2;
|
|
|
|
case E_ITEM_IRON_SHOVEL: return 3;
|
|
|
|
case E_ITEM_DIAMOND_SHOVEL: return 4;
|
|
|
|
}
|
|
|
|
// All other equipped items give a damage of 1:
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2018-07-26 17:24:36 -04:00
|
|
|
|
2017-07-23 05:46:38 -04:00
|
|
|
void cEntity::ApplyArmorDamage(int DamageBlocked)
|
|
|
|
{
|
|
|
|
// cEntities don't necessarily have armor to damage.
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-07-01 06:39:56 -04:00
|
|
|
|
2014-04-25 22:49:08 -04:00
|
|
|
bool cEntity::ArmorCoversAgainst(eDamageType a_DamageType)
|
2013-07-01 06:39:56 -04:00
|
|
|
{
|
2017-08-24 05:19:40 -04:00
|
|
|
// Ref.: https://minecraft.gamepedia.com/Armor#Effects as of 2012_12_20
|
2013-07-01 06:39:56 -04:00
|
|
|
switch (a_DamageType)
|
|
|
|
{
|
|
|
|
case dtOnFire:
|
|
|
|
case dtSuffocating:
|
|
|
|
case dtDrowning: // TODO: This one could be a special case - in various MC versions (PC vs XBox) it is and isn't armor-protected
|
2017-07-23 05:46:38 -04:00
|
|
|
case dtEnderPearl:
|
2013-07-01 06:39:56 -04:00
|
|
|
case dtStarving:
|
|
|
|
case dtInVoid:
|
|
|
|
case dtPoisoning:
|
2014-06-09 00:51:55 -04:00
|
|
|
case dtWithering:
|
2013-07-01 06:39:56 -04:00
|
|
|
case dtPotionOfHarming:
|
|
|
|
case dtFalling:
|
|
|
|
case dtLightning:
|
2014-02-02 07:47:17 -05:00
|
|
|
case dtPlugin:
|
2013-07-01 06:39:56 -04:00
|
|
|
{
|
2014-04-25 22:49:08 -04:00
|
|
|
return false;
|
|
|
|
}
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2014-04-25 22:49:08 -04:00
|
|
|
case dtAttack:
|
|
|
|
case dtArrowAttack:
|
|
|
|
case dtCactusContact:
|
|
|
|
case dtLavaContact:
|
|
|
|
case dtFireContact:
|
|
|
|
case dtExplosion:
|
|
|
|
{
|
|
|
|
return true;
|
2013-07-01 06:39:56 -04:00
|
|
|
}
|
|
|
|
}
|
2018-02-04 18:07:12 -05:00
|
|
|
UNREACHABLE("Unsupported damage type");
|
2014-04-25 22:49:08 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-03-22 06:39:32 -04:00
|
|
|
float cEntity::GetEnchantmentCoverAgainst(const cEntity * a_Attacker, eDamageType a_DamageType, int a_Damage)
|
2017-07-23 05:46:38 -04:00
|
|
|
{
|
2017-09-11 17:20:49 -04:00
|
|
|
int TotalEPF = 0;
|
2017-07-23 05:46:38 -04:00
|
|
|
|
|
|
|
const cItem ArmorItems[] = { GetEquippedHelmet(), GetEquippedChestplate(), GetEquippedLeggings(), GetEquippedBoots() };
|
|
|
|
for (size_t i = 0; i < ARRAYCOUNT(ArmorItems); i++)
|
|
|
|
{
|
|
|
|
const cItem & Item = ArmorItems[i];
|
|
|
|
|
|
|
|
if ((a_DamageType != dtInVoid) && (a_DamageType != dtAdmin) && (a_DamageType != dtStarving))
|
|
|
|
{
|
|
|
|
TotalEPF += static_cast<int>(Item.m_Enchantments.GetLevel(cEnchantments::enchProtection)) * 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((a_DamageType == dtBurning) || (a_DamageType == dtFireContact) || (a_DamageType == dtLavaContact))
|
|
|
|
{
|
|
|
|
TotalEPF += static_cast<int>(Item.m_Enchantments.GetLevel(cEnchantments::enchFireProtection)) * 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((a_DamageType == dtFalling) || (a_DamageType == dtEnderPearl))
|
|
|
|
{
|
|
|
|
TotalEPF += static_cast<int>(Item.m_Enchantments.GetLevel(cEnchantments::enchFeatherFalling)) * 3;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (a_DamageType == dtExplosion)
|
|
|
|
{
|
|
|
|
TotalEPF += static_cast<int>(Item.m_Enchantments.GetLevel(cEnchantments::enchBlastProtection)) * 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Note: Also blocks against fire charges, etc.
|
|
|
|
if (a_DamageType == dtProjectile)
|
|
|
|
{
|
|
|
|
TotalEPF += static_cast<int>(Item.m_Enchantments.GetLevel(cEnchantments::enchProjectileProtection)) * 2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
int CappedEPF = std::min(20, TotalEPF);
|
2020-03-22 06:39:32 -04:00
|
|
|
return (a_Damage * CappedEPF / 25.0f);
|
2017-07-23 05:46:38 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2018-07-23 05:24:00 -04:00
|
|
|
float cEntity::GetEnchantmentBlastKnockbackReduction()
|
|
|
|
{
|
|
|
|
UInt32 MaxLevel = 0;
|
|
|
|
|
|
|
|
const cItem ArmorItems[] = { GetEquippedHelmet(), GetEquippedChestplate(), GetEquippedLeggings(), GetEquippedBoots() };
|
|
|
|
|
|
|
|
for (auto & Item : ArmorItems)
|
|
|
|
{
|
|
|
|
UInt32 Level = Item.m_Enchantments.GetLevel(cEnchantments::enchBlastProtection);
|
|
|
|
if (Level > MaxLevel)
|
|
|
|
{
|
|
|
|
// Get max blast protection
|
|
|
|
MaxLevel = Level;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Max blast protect level is 4, each level provide 15% knock back reduction
|
|
|
|
MaxLevel = std::min<UInt32>(MaxLevel, 4);
|
|
|
|
return MaxLevel * 0.15f;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-03-22 06:39:32 -04:00
|
|
|
float cEntity::GetArmorCoverAgainst(const cEntity * a_Attacker, eDamageType a_DamageType, int a_Damage)
|
2014-04-25 22:49:08 -04:00
|
|
|
{
|
|
|
|
// Returns the hitpoints out of a_RawDamage that the currently equipped armor would cover
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2014-04-25 22:49:08 -04:00
|
|
|
// Filter out damage types that are not protected by armor:
|
2014-12-05 10:59:11 -05:00
|
|
|
if (!ArmorCoversAgainst(a_DamageType))
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2013-07-01 06:39:56 -04:00
|
|
|
// Add up all armor points:
|
2017-08-24 05:19:40 -04:00
|
|
|
// Ref.: https://minecraft.gamepedia.com/Armor#Defense_points
|
2013-07-01 06:39:56 -04:00
|
|
|
int ArmorValue = 0;
|
2017-07-23 05:46:38 -04:00
|
|
|
int Toughness = 0;
|
2013-07-01 06:39:56 -04:00
|
|
|
switch (GetEquippedHelmet().m_ItemType)
|
|
|
|
{
|
|
|
|
case E_ITEM_LEATHER_CAP: ArmorValue += 1; break;
|
|
|
|
case E_ITEM_GOLD_HELMET: ArmorValue += 2; break;
|
|
|
|
case E_ITEM_CHAIN_HELMET: ArmorValue += 2; break;
|
|
|
|
case E_ITEM_IRON_HELMET: ArmorValue += 2; break;
|
2017-07-23 05:46:38 -04:00
|
|
|
case E_ITEM_DIAMOND_HELMET: ArmorValue += 3; Toughness += 2; break;
|
2013-07-01 06:39:56 -04:00
|
|
|
}
|
|
|
|
switch (GetEquippedChestplate().m_ItemType)
|
|
|
|
{
|
|
|
|
case E_ITEM_LEATHER_TUNIC: ArmorValue += 3; break;
|
|
|
|
case E_ITEM_GOLD_CHESTPLATE: ArmorValue += 5; break;
|
|
|
|
case E_ITEM_CHAIN_CHESTPLATE: ArmorValue += 5; break;
|
|
|
|
case E_ITEM_IRON_CHESTPLATE: ArmorValue += 6; break;
|
2017-07-23 05:46:38 -04:00
|
|
|
case E_ITEM_DIAMOND_CHESTPLATE: ArmorValue += 8; Toughness += 2; break;
|
2013-07-01 06:39:56 -04:00
|
|
|
}
|
|
|
|
switch (GetEquippedLeggings().m_ItemType)
|
|
|
|
{
|
|
|
|
case E_ITEM_LEATHER_PANTS: ArmorValue += 2; break;
|
|
|
|
case E_ITEM_GOLD_LEGGINGS: ArmorValue += 3; break;
|
|
|
|
case E_ITEM_CHAIN_LEGGINGS: ArmorValue += 4; break;
|
|
|
|
case E_ITEM_IRON_LEGGINGS: ArmorValue += 5; break;
|
2017-07-23 05:46:38 -04:00
|
|
|
case E_ITEM_DIAMOND_LEGGINGS: ArmorValue += 6; Toughness += 2; break;
|
2013-07-01 06:39:56 -04:00
|
|
|
}
|
|
|
|
switch (GetEquippedBoots().m_ItemType)
|
|
|
|
{
|
|
|
|
case E_ITEM_LEATHER_BOOTS: ArmorValue += 1; break;
|
|
|
|
case E_ITEM_GOLD_BOOTS: ArmorValue += 1; break;
|
|
|
|
case E_ITEM_CHAIN_BOOTS: ArmorValue += 1; break;
|
|
|
|
case E_ITEM_IRON_BOOTS: ArmorValue += 2; break;
|
2017-07-23 05:46:38 -04:00
|
|
|
case E_ITEM_DIAMOND_BOOTS: ArmorValue += 3; Toughness += 2; break;
|
2013-07-01 06:39:56 -04:00
|
|
|
}
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2013-07-01 06:39:56 -04:00
|
|
|
// TODO: Special armor cases, such as wool, saddles, dog's collar
|
2017-08-24 05:19:40 -04:00
|
|
|
// Ref.: https://minecraft.gamepedia.com/Armor#Mob_armor as of 2012_12_20
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2020-03-22 06:39:32 -04:00
|
|
|
float Reduction = std::max(ArmorValue / 5.0f, ArmorValue - a_Damage / (2.0f + Toughness / 4.0f));
|
|
|
|
return (a_Damage * std::min(20.0f, Reduction) / 25.0f);
|
2013-07-01 06:39:56 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
double cEntity::GetKnockbackAmountAgainst(const cEntity & a_Receiver)
|
|
|
|
{
|
2020-03-19 13:13:41 -04:00
|
|
|
// Default knockback for entities
|
|
|
|
double Knockback = 10;
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2017-08-13 07:40:23 -04:00
|
|
|
// If we're sprinting, bump up the knockback
|
|
|
|
if (IsSprinting())
|
|
|
|
{
|
2020-03-19 13:13:41 -04:00
|
|
|
Knockback = 15;
|
2017-08-13 07:40:23 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
// Check for knockback enchantments (punch only applies to shot arrows)
|
|
|
|
unsigned int KnockbackLevel = GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchKnockback);
|
2020-03-19 13:13:41 -04:00
|
|
|
unsigned int KnockbackLevelMultiplier = 8;
|
|
|
|
|
|
|
|
Knockback += KnockbackLevelMultiplier * KnockbackLevel;
|
2017-08-13 07:40:23 -04:00
|
|
|
|
|
|
|
return Knockback;
|
2013-07-01 06:39:56 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-07-04 05:55:09 -04:00
|
|
|
void cEntity::KilledBy(TakeDamageInfo & a_TDI)
|
2013-07-01 06:39:56 -04:00
|
|
|
{
|
|
|
|
m_Health = 0;
|
|
|
|
|
2014-07-16 06:38:52 -04:00
|
|
|
cRoot::Get()->GetPluginManager()->CallHookKilling(*this, a_TDI.Attacker, a_TDI);
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2013-07-01 06:39:56 -04:00
|
|
|
if (m_Health > 0)
|
|
|
|
{
|
|
|
|
// Plugin wants to 'unkill' the pawn. Abort
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-06-02 11:06:18 -04:00
|
|
|
// If the victim is a player the hook is handled by the cPlayer class
|
|
|
|
if (!IsPlayer())
|
|
|
|
{
|
|
|
|
AString emptystring = AString("");
|
|
|
|
cRoot::Get()->GetPluginManager()->CallHookKilled(*this, a_TDI, emptystring);
|
|
|
|
}
|
|
|
|
|
2014-02-02 07:47:17 -05:00
|
|
|
// Drop loot:
|
2013-07-01 06:39:56 -04:00
|
|
|
cItems Drops;
|
2014-07-04 05:55:09 -04:00
|
|
|
GetDrops(Drops, a_TDI.Attacker);
|
2013-07-01 06:39:56 -04:00
|
|
|
m_World->SpawnItemPickups(Drops, GetPosX(), GetPosY(), GetPosZ());
|
|
|
|
|
2014-04-12 08:16:48 -04:00
|
|
|
m_World->BroadcastEntityStatus(*this, esGenericDead);
|
2013-07-01 06:39:56 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void cEntity::Heal(int a_HitPoints)
|
|
|
|
{
|
|
|
|
m_Health += a_HitPoints;
|
2014-08-03 01:35:29 -04:00
|
|
|
m_Health = std::min(m_Health, m_MaxHealth);
|
2013-07-01 06:39:56 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2017-11-22 08:47:52 -05:00
|
|
|
void cEntity::SetHealth(float a_Health)
|
2013-07-07 11:09:05 -04:00
|
|
|
{
|
2017-11-22 08:47:52 -05:00
|
|
|
m_Health = Clamp(a_Health, 0.0f, m_MaxHealth);
|
2013-07-07 11:09:05 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2015-01-11 16:12:26 -05:00
|
|
|
void cEntity::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk)
|
2012-06-14 09:06:06 -04:00
|
|
|
{
|
2016-02-07 12:07:14 -05:00
|
|
|
ASSERT(IsTicking());
|
|
|
|
ASSERT(GetWorld() != nullptr);
|
2014-07-20 04:43:07 -04:00
|
|
|
m_TicksAlive++;
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2014-04-25 18:32:30 -04:00
|
|
|
if (m_InvulnerableTicks > 0)
|
|
|
|
{
|
|
|
|
m_InvulnerableTicks--;
|
|
|
|
}
|
|
|
|
|
2018-01-14 13:44:45 -05:00
|
|
|
// Non-players are destroyed as soon as they fall out of the world:
|
2016-04-18 14:58:57 -04:00
|
|
|
if ((GetPosY() < 0) && (!IsPlayer()))
|
|
|
|
{
|
|
|
|
Destroy();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-10-20 16:55:07 -04:00
|
|
|
if (m_AttachedTo != nullptr)
|
2013-03-03 14:05:11 -05:00
|
|
|
{
|
2015-07-21 16:25:37 -04:00
|
|
|
SetPosition(m_AttachedTo->GetPosition());
|
2013-03-03 14:05:11 -05:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-04-12 08:16:48 -04:00
|
|
|
if (!a_Chunk.IsValid())
|
2013-07-24 16:36:12 -04:00
|
|
|
{
|
2014-04-12 08:16:48 -04:00
|
|
|
return;
|
|
|
|
}
|
2014-01-24 18:58:51 -05:00
|
|
|
|
2020-04-13 12:38:06 -04:00
|
|
|
// Position changed -> Super::Tick() called:
|
2019-08-11 05:39:43 -04:00
|
|
|
GET_AND_VERIFY_CURRENT_CHUNK(NextChunk, POSX_TOINT, POSZ_TOINT);
|
2014-03-05 17:12:48 -05:00
|
|
|
|
2018-01-14 13:44:45 -05:00
|
|
|
// Set swim states (water, lava, and fire):
|
|
|
|
SetSwimState(*NextChunk);
|
|
|
|
|
|
|
|
// Handle catching on fire and burning:
|
2014-04-12 08:16:48 -04:00
|
|
|
TickBurning(*NextChunk);
|
2014-01-24 18:58:51 -05:00
|
|
|
|
2018-01-14 13:44:45 -05:00
|
|
|
// Damage players if they are in the void
|
2014-04-12 08:16:48 -04:00
|
|
|
if (GetPosY() < VOID_BOUNDARY)
|
|
|
|
{
|
|
|
|
TickInVoid(*NextChunk);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
m_TicksSinceLastVoidDamage = 0;
|
|
|
|
}
|
2014-03-05 17:12:48 -05:00
|
|
|
|
2018-01-14 13:44:45 -05:00
|
|
|
// Handle cactus damage or destruction:
|
2017-07-02 01:39:19 -04:00
|
|
|
if (
|
2018-01-16 14:13:17 -05:00
|
|
|
IsMob() || IsPickup() ||
|
2018-05-02 03:50:36 -04:00
|
|
|
(IsPlayer() && !((static_cast<cPlayer *>(this))->IsGameModeCreative() || (static_cast<cPlayer *>(this))->IsGameModeSpectator()))
|
2017-07-02 01:39:19 -04:00
|
|
|
)
|
2014-05-18 17:41:42 -04:00
|
|
|
{
|
|
|
|
DetectCacti();
|
|
|
|
}
|
2018-01-14 13:44:45 -05:00
|
|
|
|
|
|
|
// Handle drowning:
|
2014-04-12 08:16:48 -04:00
|
|
|
if (IsMob() || IsPlayer())
|
|
|
|
{
|
|
|
|
HandleAir();
|
2014-07-29 11:36:24 -04:00
|
|
|
}
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2014-07-22 12:26:48 -04:00
|
|
|
if (!DetectPortal()) // Our chunk is invalid if we have moved to another world
|
|
|
|
{
|
|
|
|
// None of the above functions changed position, we remain in the chunk of NextChunk
|
|
|
|
HandlePhysics(a_Dt, *NextChunk);
|
2014-03-05 17:12:48 -05:00
|
|
|
}
|
2014-01-24 18:58:51 -05:00
|
|
|
}
|
2013-03-03 14:05:11 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2015-01-11 16:12:26 -05:00
|
|
|
void cEntity::HandlePhysics(std::chrono::milliseconds a_Dt, cChunk & a_Chunk)
|
2013-04-22 03:18:03 -04:00
|
|
|
{
|
2014-04-12 08:16:48 -04:00
|
|
|
int BlockX = POSX_TOINT;
|
|
|
|
int BlockY = POSY_TOINT;
|
|
|
|
int BlockZ = POSZ_TOINT;
|
|
|
|
|
2020-04-13 12:38:06 -04:00
|
|
|
// Position changed -> Super::HandlePhysics() called
|
2019-08-11 05:39:43 -04:00
|
|
|
GET_AND_VERIFY_CURRENT_CHUNK(NextChunk, BlockX, BlockZ);
|
2014-04-12 08:16:48 -04:00
|
|
|
|
2013-06-18 04:24:34 -04:00
|
|
|
// TODO Add collision detection with entities.
|
2015-01-11 16:12:26 -05:00
|
|
|
auto DtSec = std::chrono::duration_cast<std::chrono::duration<double>>(a_Dt);
|
2014-04-12 08:16:48 -04:00
|
|
|
Vector3d NextPos = Vector3d(GetPosX(), GetPosY(), GetPosZ());
|
|
|
|
Vector3d NextSpeed = Vector3d(GetSpeedX(), GetSpeedY(), GetSpeedZ());
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2013-06-18 04:24:34 -04:00
|
|
|
if ((BlockY >= cChunkDef::Height) || (BlockY < 0))
|
|
|
|
{
|
2014-07-17 16:59:02 -04:00
|
|
|
// Outside of the world
|
2015-01-11 16:12:26 -05:00
|
|
|
AddSpeedY(m_Gravity * DtSec.count());
|
|
|
|
AddPosition(GetSpeed() * DtSec.count());
|
2013-06-18 04:24:34 -04:00
|
|
|
return;
|
|
|
|
}
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2014-04-12 08:16:48 -04:00
|
|
|
int RelBlockX = BlockX - (NextChunk->GetPosX() * cChunkDef::Width);
|
|
|
|
int RelBlockZ = BlockZ - (NextChunk->GetPosZ() * cChunkDef::Width);
|
2014-07-21 09:19:48 -04:00
|
|
|
BLOCKTYPE BlockIn = NextChunk->GetBlock( RelBlockX, BlockY, RelBlockZ);
|
2014-04-12 08:16:48 -04:00
|
|
|
BLOCKTYPE BlockBelow = (BlockY > 0) ? NextChunk->GetBlock(RelBlockX, BlockY - 1, RelBlockZ) : E_BLOCK_AIR;
|
2014-03-05 17:12:48 -05:00
|
|
|
if (!cBlockInfo::IsSolid(BlockIn)) // Making sure we are not inside a solid block
|
2013-04-22 03:18:03 -04:00
|
|
|
{
|
2014-03-05 17:12:48 -05:00
|
|
|
if (m_bOnGround) // check if it's still on the ground
|
2013-04-22 03:18:03 -04:00
|
|
|
{
|
2014-03-05 17:12:48 -05:00
|
|
|
if (!cBlockInfo::IsSolid(BlockBelow)) // Check if block below is air or water.
|
2013-04-22 03:18:03 -04:00
|
|
|
{
|
2014-03-05 17:12:48 -05:00
|
|
|
m_bOnGround = false;
|
2013-04-22 03:18:03 -04:00
|
|
|
}
|
|
|
|
}
|
2014-03-05 17:12:48 -05:00
|
|
|
}
|
2020-03-22 20:05:47 -04:00
|
|
|
else if (!(IsMinecart() || IsTNT() || (IsPickup() && (m_TicksAlive < 15))))
|
2014-03-05 17:12:48 -05:00
|
|
|
{
|
|
|
|
// Push out entity.
|
|
|
|
BLOCKTYPE GotBlock;
|
2013-09-04 12:52:15 -04:00
|
|
|
|
2014-03-05 17:12:48 -05:00
|
|
|
static const struct
|
|
|
|
{
|
|
|
|
int x, y, z;
|
|
|
|
} gCrossCoords[] =
|
|
|
|
{
|
|
|
|
{ 1, 0, 0},
|
|
|
|
{-1, 0, 0},
|
|
|
|
{ 0, 0, 1},
|
|
|
|
{ 0, 0, -1},
|
|
|
|
} ;
|
|
|
|
|
|
|
|
bool IsNoAirSurrounding = true;
|
|
|
|
for (size_t i = 0; i < ARRAYCOUNT(gCrossCoords); i++)
|
|
|
|
{
|
2014-04-12 08:16:48 -04:00
|
|
|
if (!NextChunk->UnboundedRelGetBlockType(RelBlockX + gCrossCoords[i].x, BlockY, RelBlockZ + gCrossCoords[i].z, GotBlock))
|
2013-09-11 17:10:29 -04:00
|
|
|
{
|
2014-03-05 17:12:48 -05:00
|
|
|
// The pickup is too close to an unloaded chunk, bail out of any physics handling
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!cBlockInfo::IsSolid(GotBlock))
|
2013-09-15 14:49:08 -04:00
|
|
|
{
|
2014-03-05 17:12:48 -05:00
|
|
|
NextPos.x += gCrossCoords[i].x;
|
|
|
|
NextPos.z += gCrossCoords[i].z;
|
|
|
|
IsNoAirSurrounding = false;
|
|
|
|
break;
|
2013-09-15 14:49:08 -04:00
|
|
|
}
|
2014-03-05 17:12:48 -05:00
|
|
|
} // for i - gCrossCoords[]
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2014-03-05 17:12:48 -05:00
|
|
|
if (IsNoAirSurrounding)
|
|
|
|
{
|
|
|
|
NextPos.y += 0.5;
|
|
|
|
}
|
2013-09-13 14:54:50 -04:00
|
|
|
|
2017-06-04 00:35:02 -04:00
|
|
|
m_bHasSentNoSpeed = false; // this unlocks movement sending to client in BroadcastMovementUpdate function
|
2014-03-05 17:12:48 -05:00
|
|
|
m_bOnGround = true;
|
2013-09-05 16:41:47 -04:00
|
|
|
|
2014-03-05 17:12:48 -05:00
|
|
|
/*
|
|
|
|
// DEBUG:
|
2018-09-24 16:33:39 -04:00
|
|
|
FLOGD("Entity #{0} ({1}) is inside a block at {{2}}",
|
|
|
|
m_UniqueID, GetClass(), Vector3i{BlockX, BlockY, BlockZ}
|
2014-03-05 17:12:48 -05:00
|
|
|
);
|
|
|
|
*/
|
|
|
|
}
|
2013-04-22 03:18:03 -04:00
|
|
|
|
2014-03-05 17:12:48 -05:00
|
|
|
if (!m_bOnGround)
|
|
|
|
{
|
2015-01-18 05:02:17 -05:00
|
|
|
double fallspeed;
|
2014-03-05 17:12:48 -05:00
|
|
|
if (IsBlockWater(BlockIn))
|
2013-04-22 03:18:03 -04:00
|
|
|
{
|
2015-01-11 16:12:26 -05:00
|
|
|
fallspeed = m_Gravity * DtSec.count() / 3; // Fall 3x slower in water
|
2015-01-18 05:02:17 -05:00
|
|
|
ApplyFriction(NextSpeed, 0.7, static_cast<float>(DtSec.count()));
|
2014-03-05 17:12:48 -05:00
|
|
|
}
|
|
|
|
else if (BlockIn == E_BLOCK_COBWEB)
|
|
|
|
{
|
|
|
|
NextSpeed.y *= 0.05; // Reduce overall falling speed
|
2014-09-13 17:49:05 -04:00
|
|
|
fallspeed = 0; // No falling
|
2013-04-22 03:18:03 -04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-03-05 17:12:48 -05:00
|
|
|
// Normal gravity
|
2015-01-11 16:12:26 -05:00
|
|
|
fallspeed = m_Gravity * DtSec.count();
|
2015-03-31 11:03:35 -04:00
|
|
|
NextSpeed -= NextSpeed * (m_AirDrag * 20.0f) * DtSec.count();
|
2014-03-05 17:12:48 -05:00
|
|
|
}
|
2015-01-18 05:02:17 -05:00
|
|
|
NextSpeed.y += static_cast<float>(fallspeed);
|
2016-07-18 16:10:00 -04:00
|
|
|
|
|
|
|
// A real boat floats
|
|
|
|
if (IsBoat())
|
|
|
|
{
|
|
|
|
// Find top water block and sit there
|
|
|
|
int NextBlockY = BlockY;
|
|
|
|
BLOCKTYPE NextBlock = NextChunk->GetBlock(RelBlockX, NextBlockY, RelBlockZ);
|
|
|
|
while (IsBlockWater(NextBlock))
|
|
|
|
{
|
|
|
|
NextBlock = NextChunk->GetBlock(RelBlockX, ++NextBlockY, RelBlockZ);
|
|
|
|
}
|
|
|
|
NextPos.y = NextBlockY - 0.5;
|
|
|
|
NextSpeed.y = 0;
|
|
|
|
}
|
2014-03-05 17:12:48 -05:00
|
|
|
}
|
2014-09-12 15:50:24 -04:00
|
|
|
else
|
2014-03-05 17:12:48 -05:00
|
|
|
{
|
2015-01-18 05:02:17 -05:00
|
|
|
ApplyFriction(NextSpeed, 0.7, static_cast<float>(DtSec.count()));
|
2014-03-05 17:12:48 -05:00
|
|
|
}
|
2013-05-21 01:51:38 -04:00
|
|
|
|
2014-03-05 17:12:48 -05:00
|
|
|
// Adjust X and Z speed for COBWEB temporary. This speed modification should be handled inside block handlers since we
|
|
|
|
// might have different speed modifiers according to terrain.
|
|
|
|
if (BlockIn == E_BLOCK_COBWEB)
|
|
|
|
{
|
|
|
|
NextSpeed.x *= 0.25;
|
|
|
|
NextSpeed.z *= 0.25;
|
|
|
|
}
|
2014-07-17 16:15:34 -04:00
|
|
|
|
|
|
|
// Get water direction
|
2018-07-27 05:01:53 -04:00
|
|
|
Vector3f WaterDir = m_World->GetWaterSimulator()->GetFlowingDirection(BlockX, BlockY, BlockZ);
|
2013-04-22 03:18:03 -04:00
|
|
|
|
2017-05-11 08:34:36 -04:00
|
|
|
m_WaterSpeed *= 0.9; // Reduce speed each tick
|
2013-04-22 03:18:03 -04:00
|
|
|
|
2018-07-27 05:01:53 -04:00
|
|
|
auto AdjustSpeed = [](double & a_WaterSpeed, float a_WaterDir)
|
2017-05-11 08:34:36 -04:00
|
|
|
{
|
2018-07-27 05:01:53 -04:00
|
|
|
if (std::abs(a_WaterDir) > (0.05f / 0.4f))
|
|
|
|
{
|
|
|
|
a_WaterSpeed = 0.4 * a_WaterDir;
|
|
|
|
}
|
|
|
|
else if (std::abs(a_WaterSpeed) < 0.05)
|
|
|
|
{
|
|
|
|
a_WaterSpeed = 0.0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
AdjustSpeed(m_WaterSpeed.x, WaterDir.x);
|
|
|
|
AdjustSpeed(m_WaterSpeed.z, WaterDir.z);
|
2013-04-22 03:18:03 -04:00
|
|
|
|
2014-03-05 17:12:48 -05:00
|
|
|
NextSpeed += m_WaterSpeed;
|
2013-04-22 03:18:03 -04:00
|
|
|
|
2015-03-30 19:42:32 -04:00
|
|
|
if (NextSpeed.SqrLength() > 0.0f)
|
2014-03-05 17:12:48 -05:00
|
|
|
{
|
2017-05-11 08:34:36 -04:00
|
|
|
Vector3d HitCoords;
|
|
|
|
Vector3i HitBlockCoords;
|
|
|
|
eBlockFace HitBlockFace;
|
2017-05-28 14:56:17 -04:00
|
|
|
Vector3d wantNextPos = NextPos + NextSpeed * DtSec.count();
|
|
|
|
auto isHit = cLineBlockTracer::FirstSolidHitTrace(*GetWorld(), NextPos, wantNextPos, HitCoords, HitBlockCoords, HitBlockFace);
|
|
|
|
if (isHit)
|
2013-04-22 03:18:03 -04:00
|
|
|
{
|
2018-07-27 05:01:53 -04:00
|
|
|
// Set our position to where the block was hit:
|
|
|
|
NextPos = HitCoords;
|
2017-05-11 08:34:36 -04:00
|
|
|
|
2018-07-27 05:01:53 -04:00
|
|
|
// Avoid movement in the direction of the blockface that has been hit and correct for collision box:
|
|
|
|
double HalfWidth = GetWidth() / 2.0;
|
2017-05-11 08:34:36 -04:00
|
|
|
switch (HitBlockFace)
|
|
|
|
{
|
|
|
|
case BLOCK_FACE_XM:
|
2018-07-27 05:01:53 -04:00
|
|
|
{
|
|
|
|
NextSpeed.x = 0;
|
|
|
|
NextPos.x -= HalfWidth;
|
|
|
|
break;
|
|
|
|
}
|
2017-05-11 08:34:36 -04:00
|
|
|
case BLOCK_FACE_XP:
|
2014-12-05 10:59:11 -05:00
|
|
|
{
|
2017-05-11 08:34:36 -04:00
|
|
|
NextSpeed.x = 0;
|
2018-07-27 05:01:53 -04:00
|
|
|
NextPos.x += HalfWidth;
|
2017-05-11 08:34:36 -04:00
|
|
|
break;
|
2014-12-05 10:59:11 -05:00
|
|
|
}
|
2017-05-11 08:34:36 -04:00
|
|
|
case BLOCK_FACE_YM:
|
2018-07-27 05:01:53 -04:00
|
|
|
{
|
|
|
|
NextSpeed.y = 0;
|
|
|
|
NextPos.y -= GetHeight();
|
|
|
|
break;
|
|
|
|
}
|
2017-05-11 08:34:36 -04:00
|
|
|
case BLOCK_FACE_YP:
|
2014-12-05 10:59:11 -05:00
|
|
|
{
|
2017-05-11 08:34:36 -04:00
|
|
|
NextSpeed.y = 0;
|
2018-07-27 05:01:53 -04:00
|
|
|
// We hit the ground, adjust the position to the top of the block:
|
|
|
|
m_bOnGround = true;
|
|
|
|
NextPos.y = HitBlockCoords.y + 1;
|
2017-05-11 08:34:36 -04:00
|
|
|
break;
|
2014-12-05 10:59:11 -05:00
|
|
|
}
|
2017-05-11 08:34:36 -04:00
|
|
|
case BLOCK_FACE_ZM:
|
2018-07-27 05:01:53 -04:00
|
|
|
{
|
|
|
|
NextSpeed.z = 0;
|
|
|
|
NextPos.z -= HalfWidth;
|
|
|
|
break;
|
|
|
|
}
|
2017-05-11 08:34:36 -04:00
|
|
|
case BLOCK_FACE_ZP:
|
2014-12-05 10:59:11 -05:00
|
|
|
{
|
2017-05-11 08:34:36 -04:00
|
|
|
NextSpeed.z = 0;
|
2018-07-27 05:01:53 -04:00
|
|
|
NextPos.z += HalfWidth;
|
2017-05-11 08:34:36 -04:00
|
|
|
break;
|
2014-12-05 10:59:11 -05:00
|
|
|
}
|
2017-05-11 08:34:36 -04:00
|
|
|
default:
|
2015-11-10 08:02:07 -05:00
|
|
|
{
|
2017-05-11 08:34:36 -04:00
|
|
|
break;
|
2015-11-10 08:02:07 -05:00
|
|
|
}
|
2013-04-22 03:18:03 -04:00
|
|
|
}
|
|
|
|
}
|
2017-05-28 14:56:17 -04:00
|
|
|
else
|
|
|
|
{
|
|
|
|
// We didn't hit anything, so move:
|
|
|
|
NextPos += (NextSpeed * DtSec.count());
|
|
|
|
}
|
2017-05-11 08:34:36 -04:00
|
|
|
}
|
2014-03-05 17:12:48 -05:00
|
|
|
|
2014-04-12 08:16:48 -04:00
|
|
|
SetPosition(NextPos);
|
|
|
|
SetSpeed(NextSpeed);
|
2013-04-22 03:18:03 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-09-13 17:49:05 -04:00
|
|
|
void cEntity::ApplyFriction(Vector3d & a_Speed, double a_SlowdownMultiplier, float a_Dt)
|
|
|
|
{
|
|
|
|
if (a_Speed.SqrLength() > 0.0004f)
|
|
|
|
{
|
|
|
|
a_Speed.x *= a_SlowdownMultiplier / (1 + a_Dt);
|
|
|
|
if (fabs(a_Speed.x) < 0.05)
|
|
|
|
{
|
|
|
|
a_Speed.x = 0;
|
|
|
|
}
|
|
|
|
a_Speed.z *= a_SlowdownMultiplier / (1 + a_Dt);
|
|
|
|
if (fabs(a_Speed.z) < 0.05)
|
|
|
|
{
|
|
|
|
a_Speed.z = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-07-01 06:39:56 -04:00
|
|
|
void cEntity::TickBurning(cChunk & a_Chunk)
|
|
|
|
{
|
2017-08-22 10:05:13 -04:00
|
|
|
// If we're about to change worlds, then we can't accurately determine whether we're in lava (#3939)
|
2020-03-05 05:52:34 -05:00
|
|
|
if (IsWorldChangeScheduled())
|
2017-08-22 10:05:13 -04:00
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-07-01 14:37:27 -04:00
|
|
|
// Remember the current burning state:
|
|
|
|
bool HasBeenBurning = (m_TicksLeftBurning > 0);
|
2014-04-18 07:59:14 -04:00
|
|
|
|
2017-09-07 04:59:08 -04:00
|
|
|
// Fireproof entities burn out on the next tick
|
|
|
|
if (IsFireproof())
|
|
|
|
{
|
|
|
|
m_TicksLeftBurning = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Fire is extinguished by rain
|
2017-12-26 16:25:57 -05:00
|
|
|
if (GetWorld()->IsWeatherWetAtXYZ(GetPosition().Floor()))
|
2014-04-18 07:59:14 -04:00
|
|
|
{
|
2017-12-26 16:25:57 -05:00
|
|
|
m_TicksLeftBurning = 0;
|
2014-04-18 07:59:14 -04:00
|
|
|
}
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2013-07-01 06:39:56 -04:00
|
|
|
// Do the burning damage:
|
|
|
|
if (m_TicksLeftBurning > 0)
|
|
|
|
{
|
|
|
|
m_TicksSinceLastBurnDamage++;
|
|
|
|
if (m_TicksSinceLastBurnDamage >= BURN_TICKS_PER_DAMAGE)
|
|
|
|
{
|
2015-10-31 11:24:45 -04:00
|
|
|
if (!IsFireproof())
|
2014-04-22 08:36:39 -04:00
|
|
|
{
|
2014-10-20 16:55:07 -04:00
|
|
|
TakeDamage(dtOnFire, nullptr, BURN_DAMAGE, 0);
|
2014-04-22 08:36:39 -04:00
|
|
|
}
|
2013-07-01 14:37:27 -04:00
|
|
|
m_TicksSinceLastBurnDamage = 0;
|
2013-07-01 06:39:56 -04:00
|
|
|
}
|
|
|
|
m_TicksLeftBurning--;
|
|
|
|
}
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2018-01-14 13:44:45 -05:00
|
|
|
if (IsInWater())
|
2013-07-01 06:39:56 -04:00
|
|
|
{
|
|
|
|
// Extinguish the fire
|
|
|
|
m_TicksLeftBurning = 0;
|
|
|
|
}
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2018-01-14 13:44:45 -05:00
|
|
|
if (IsInLava())
|
2013-07-01 06:39:56 -04:00
|
|
|
{
|
|
|
|
// Burn:
|
|
|
|
m_TicksLeftBurning = BURN_TICKS;
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2013-07-01 06:39:56 -04:00
|
|
|
// Periodically damage:
|
|
|
|
m_TicksSinceLastLavaDamage++;
|
2013-07-01 14:37:27 -04:00
|
|
|
if (m_TicksSinceLastLavaDamage >= LAVA_TICKS_PER_DAMAGE)
|
2013-07-01 06:39:56 -04:00
|
|
|
{
|
2015-10-31 11:24:45 -04:00
|
|
|
if (!IsFireproof())
|
2014-04-22 08:36:39 -04:00
|
|
|
{
|
2014-10-20 16:55:07 -04:00
|
|
|
TakeDamage(dtLavaContact, nullptr, LAVA_DAMAGE, 0);
|
2014-04-22 08:36:39 -04:00
|
|
|
}
|
2013-07-01 06:39:56 -04:00
|
|
|
m_TicksSinceLastLavaDamage = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
m_TicksSinceLastLavaDamage = 0;
|
|
|
|
}
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2018-01-14 13:44:45 -05:00
|
|
|
if (IsInFire())
|
2013-07-01 06:39:56 -04:00
|
|
|
{
|
|
|
|
// Burn:
|
|
|
|
m_TicksLeftBurning = BURN_TICKS;
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2013-07-01 06:39:56 -04:00
|
|
|
// Periodically damage:
|
|
|
|
m_TicksSinceLastFireDamage++;
|
|
|
|
if (m_TicksSinceLastFireDamage >= FIRE_TICKS_PER_DAMAGE)
|
|
|
|
{
|
2018-01-14 13:44:45 -05:00
|
|
|
if (!IsFireproof() && !IsInLava())
|
2014-04-22 08:36:39 -04:00
|
|
|
{
|
2014-10-20 16:55:07 -04:00
|
|
|
TakeDamage(dtFireContact, nullptr, FIRE_DAMAGE, 0);
|
2014-04-22 08:36:39 -04:00
|
|
|
}
|
2013-07-01 14:37:27 -04:00
|
|
|
m_TicksSinceLastFireDamage = 0;
|
2013-07-01 06:39:56 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
m_TicksSinceLastFireDamage = 0;
|
|
|
|
}
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2013-07-01 06:39:56 -04:00
|
|
|
// If just started / finished burning, notify descendants:
|
|
|
|
if ((m_TicksLeftBurning > 0) && !HasBeenBurning)
|
|
|
|
{
|
|
|
|
OnStartedBurning();
|
|
|
|
}
|
|
|
|
else if ((m_TicksLeftBurning <= 0) && HasBeenBurning)
|
|
|
|
{
|
|
|
|
OnFinishedBurning();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-09-10 18:01:02 -04:00
|
|
|
void cEntity::TickInVoid(cChunk & a_Chunk)
|
|
|
|
{
|
|
|
|
if (m_TicksSinceLastVoidDamage == 20)
|
|
|
|
{
|
2014-10-20 16:55:07 -04:00
|
|
|
TakeDamage(dtInVoid, nullptr, 2, 0);
|
2013-09-10 18:01:02 -04:00
|
|
|
m_TicksSinceLastVoidDamage = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
m_TicksSinceLastVoidDamage++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-05-23 06:33:30 -04:00
|
|
|
void cEntity::DetectCacti(void)
|
2014-05-18 17:41:42 -04:00
|
|
|
{
|
2018-01-16 14:13:17 -05:00
|
|
|
int MinX = FloorC(GetPosX() - m_Width / 2);
|
|
|
|
int MaxX = FloorC(GetPosX() + m_Width / 2);
|
|
|
|
int MinZ = FloorC(GetPosZ() - m_Width / 2);
|
|
|
|
int MaxZ = FloorC(GetPosZ() + m_Width / 2);
|
|
|
|
int MinY = Clamp(POSY_TOINT, 0, cChunkDef::Height - 1);
|
|
|
|
int MaxY = Clamp(FloorC(GetPosY() + m_Height), 0, cChunkDef::Height - 1);
|
|
|
|
|
|
|
|
for (int x = MinX; x <= MaxX; x++)
|
2014-05-18 17:41:42 -04:00
|
|
|
{
|
2018-01-16 14:13:17 -05:00
|
|
|
for (int z = MinZ; z <= MaxZ; z++)
|
|
|
|
{
|
|
|
|
for (int y = MinY; y <= MaxY; y++)
|
|
|
|
{
|
|
|
|
if (GetWorld()->GetBlock(x, y, z) == E_BLOCK_CACTUS)
|
|
|
|
{
|
|
|
|
TakeDamage(dtCactusContact, nullptr, 1, 0);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
} // for y
|
|
|
|
} // for z
|
|
|
|
} // for x
|
2014-05-18 17:41:42 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2018-07-26 17:24:36 -04:00
|
|
|
|
2014-07-22 12:26:48 -04:00
|
|
|
bool cEntity::DetectPortal()
|
2014-05-31 17:28:51 -04:00
|
|
|
{
|
2020-03-05 05:52:34 -05:00
|
|
|
// If somebody scheduled a world change, do nothing.
|
|
|
|
if (IsWorldChangeScheduled())
|
2015-05-26 21:35:28 -04:00
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-07-20 05:46:45 -04:00
|
|
|
if (GetWorld()->GetDimension() == dimOverworld)
|
2014-06-04 15:00:55 -04:00
|
|
|
{
|
2015-03-21 10:20:31 -04:00
|
|
|
if (GetWorld()->GetLinkedNetherWorldName().empty() && GetWorld()->GetLinkedEndWorldName().empty())
|
2014-07-21 17:49:06 -04:00
|
|
|
{
|
2014-07-23 16:12:59 -04:00
|
|
|
// Teleportation to either dimension not enabled, don't bother proceeding
|
2014-07-22 12:26:48 -04:00
|
|
|
return false;
|
2014-07-21 17:49:06 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (GetWorld()->GetLinkedOverworldName().empty())
|
|
|
|
{
|
2014-07-23 16:12:59 -04:00
|
|
|
// Overworld teleportation disabled, abort
|
2014-07-22 12:26:48 -04:00
|
|
|
return false;
|
2014-06-04 15:00:55 -04:00
|
|
|
}
|
|
|
|
|
2014-05-31 17:28:51 -04:00
|
|
|
int X = POSX_TOINT, Y = POSY_TOINT, Z = POSZ_TOINT;
|
|
|
|
if ((Y > 0) && (Y < cChunkDef::Height))
|
|
|
|
{
|
|
|
|
switch (GetWorld()->GetBlock(X, Y, Z))
|
|
|
|
{
|
|
|
|
case E_BLOCK_NETHER_PORTAL:
|
|
|
|
{
|
2014-07-21 17:49:06 -04:00
|
|
|
if (m_PortalCooldownData.m_ShouldPreventTeleportation)
|
2014-06-04 15:00:55 -04:00
|
|
|
{
|
2014-07-23 16:12:59 -04:00
|
|
|
// Just exited a portal, don't teleport again
|
2014-07-22 12:26:48 -04:00
|
|
|
return false;
|
2014-06-04 15:00:55 -04:00
|
|
|
}
|
|
|
|
|
2020-03-05 14:33:43 -05:00
|
|
|
if ((m_AttachedTo != nullptr) || (m_Attachee != nullptr))
|
|
|
|
{
|
|
|
|
// Don't let attached entities change worlds, like players riding a minecart
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-05-02 03:50:36 -04:00
|
|
|
if (IsPlayer() && !(static_cast<cPlayer *>(this))->IsGameModeCreative() && (m_PortalCooldownData.m_TicksDelayed != 80))
|
2014-06-12 10:21:07 -04:00
|
|
|
{
|
2014-07-23 16:12:59 -04:00
|
|
|
// Delay teleportation for four seconds if the entity is a non-creative player
|
2014-07-21 17:49:06 -04:00
|
|
|
m_PortalCooldownData.m_TicksDelayed++;
|
2014-07-22 12:26:48 -04:00
|
|
|
return false;
|
2014-06-12 10:21:07 -04:00
|
|
|
}
|
2014-07-21 17:49:06 -04:00
|
|
|
m_PortalCooldownData.m_TicksDelayed = 0;
|
2014-06-12 10:21:07 -04:00
|
|
|
|
2016-08-27 02:37:54 -04:00
|
|
|
// Nether portal in the nether
|
2014-08-03 00:44:02 -04:00
|
|
|
if (GetWorld()->GetDimension() == dimNether)
|
2014-05-31 17:28:51 -04:00
|
|
|
{
|
2014-08-03 00:44:02 -04:00
|
|
|
if (GetWorld()->GetLinkedOverworldName().empty())
|
2014-06-12 10:21:07 -04:00
|
|
|
{
|
2014-08-03 00:44:02 -04:00
|
|
|
return false;
|
2014-06-12 10:21:07 -04:00
|
|
|
}
|
2016-08-27 02:37:54 -04:00
|
|
|
cWorld * DestinationWorld = cRoot::Get()->GetWorld(GetWorld()->GetLinkedOverworldName());
|
|
|
|
eDimension DestionationDim = DestinationWorld->GetDimension();
|
2014-08-03 00:44:02 -04:00
|
|
|
|
|
|
|
m_PortalCooldownData.m_ShouldPreventTeleportation = true; // Stop portals from working on respawn
|
|
|
|
|
|
|
|
if (IsPlayer())
|
2014-05-31 17:28:51 -04:00
|
|
|
{
|
2015-05-09 03:25:09 -04:00
|
|
|
// Send a respawn packet before world is loaded / generated so the client isn't left in limbo
|
2018-05-02 03:50:36 -04:00
|
|
|
(static_cast<cPlayer *>(this))->GetClientHandle()->SendRespawn(DestionationDim);
|
2014-05-31 17:28:51 -04:00
|
|
|
}
|
2015-05-26 21:35:28 -04:00
|
|
|
|
|
|
|
Vector3d TargetPos = GetPosition();
|
|
|
|
TargetPos.x *= 8.0;
|
|
|
|
TargetPos.z *= 8.0;
|
|
|
|
|
2016-02-08 05:06:14 -05:00
|
|
|
cWorld * TargetWorld = cRoot::Get()->GetWorld(GetWorld()->GetLinkedOverworldName());
|
|
|
|
ASSERT(TargetWorld != nullptr); // The linkage checker should have prevented this at startup. See cWorld::start()
|
2016-08-27 02:37:54 -04:00
|
|
|
LOGD("Jumping %s -> %s", DimensionToString(dimNether).c_str(), DimensionToString(DestionationDim).c_str());
|
2020-04-10 16:08:19 -04:00
|
|
|
new cNetherPortalScanner(*this, *TargetWorld, TargetPos, cChunkDef::Height);
|
2015-06-13 17:09:43 -04:00
|
|
|
return true;
|
2014-08-03 00:44:02 -04:00
|
|
|
}
|
2016-08-27 02:37:54 -04:00
|
|
|
// Nether portal in the overworld
|
2014-08-03 00:44:02 -04:00
|
|
|
else
|
|
|
|
{
|
2015-03-21 10:20:31 -04:00
|
|
|
if (GetWorld()->GetLinkedNetherWorldName().empty())
|
2014-08-03 00:44:02 -04:00
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2016-08-27 02:37:54 -04:00
|
|
|
cWorld * DestinationWorld = cRoot::Get()->GetWorld(GetWorld()->GetLinkedNetherWorldName());
|
|
|
|
eDimension DestionationDim = DestinationWorld->GetDimension();
|
2014-08-03 00:44:02 -04:00
|
|
|
|
|
|
|
m_PortalCooldownData.m_ShouldPreventTeleportation = true;
|
|
|
|
|
|
|
|
if (IsPlayer())
|
|
|
|
{
|
2016-08-27 02:37:54 -04:00
|
|
|
if (DestionationDim == dimNether)
|
|
|
|
{
|
2018-05-02 03:50:36 -04:00
|
|
|
static_cast<cPlayer *>(this)->AwardAchievement(achEnterPortal);
|
2016-08-27 02:37:54 -04:00
|
|
|
}
|
|
|
|
|
2018-05-02 03:50:36 -04:00
|
|
|
static_cast<cPlayer *>(this)->GetClientHandle()->SendRespawn(DestionationDim);
|
2014-08-03 00:44:02 -04:00
|
|
|
}
|
2015-05-26 21:35:28 -04:00
|
|
|
|
|
|
|
Vector3d TargetPos = GetPosition();
|
|
|
|
TargetPos.x /= 8.0;
|
|
|
|
TargetPos.z /= 8.0;
|
|
|
|
|
2016-02-08 05:06:14 -05:00
|
|
|
cWorld * TargetWorld = cRoot::Get()->GetWorld(GetWorld()->GetLinkedNetherWorldName());
|
|
|
|
ASSERT(TargetWorld != nullptr); // The linkage checker should have prevented this at startup. See cWorld::start()
|
2016-08-27 02:37:54 -04:00
|
|
|
LOGD("Jumping %s -> %s", DimensionToString(dimOverworld).c_str(), DimensionToString(DestionationDim).c_str());
|
2020-04-10 16:08:19 -04:00
|
|
|
new cNetherPortalScanner(*this, *TargetWorld, TargetPos, (cChunkDef::Height / 2));
|
2015-06-13 17:09:43 -04:00
|
|
|
return true;
|
2014-05-31 17:28:51 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
case E_BLOCK_END_PORTAL:
|
|
|
|
{
|
2014-07-21 17:49:06 -04:00
|
|
|
if (m_PortalCooldownData.m_ShouldPreventTeleportation)
|
2014-06-04 15:00:55 -04:00
|
|
|
{
|
2014-07-22 12:26:48 -04:00
|
|
|
return false;
|
2014-06-04 15:00:55 -04:00
|
|
|
}
|
|
|
|
|
2020-03-05 14:33:43 -05:00
|
|
|
if ((m_AttachedTo != nullptr) || (m_Attachee != nullptr))
|
|
|
|
{
|
|
|
|
// Don't let attached entities change worlds, like players riding a minecart
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-08-27 02:37:54 -04:00
|
|
|
// End portal in the end
|
2014-08-03 00:44:02 -04:00
|
|
|
if (GetWorld()->GetDimension() == dimEnd)
|
2014-05-31 17:28:51 -04:00
|
|
|
{
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2014-08-03 00:44:02 -04:00
|
|
|
if (GetWorld()->GetLinkedOverworldName().empty())
|
2014-05-31 17:28:51 -04:00
|
|
|
{
|
2014-08-03 00:44:02 -04:00
|
|
|
return false;
|
|
|
|
}
|
2016-08-27 02:37:54 -04:00
|
|
|
cWorld * DestinationWorld = cRoot::Get()->GetWorld(GetWorld()->GetLinkedOverworldName());
|
|
|
|
eDimension DestionationDim = DestinationWorld->GetDimension();
|
|
|
|
|
2014-06-01 13:46:59 -04:00
|
|
|
|
2014-08-03 00:44:02 -04:00
|
|
|
m_PortalCooldownData.m_ShouldPreventTeleportation = true;
|
2014-06-12 10:21:07 -04:00
|
|
|
|
2014-08-03 00:44:02 -04:00
|
|
|
if (IsPlayer())
|
2014-05-31 17:28:51 -04:00
|
|
|
{
|
2018-05-02 03:50:36 -04:00
|
|
|
cPlayer * Player = static_cast<cPlayer *>(this);
|
2016-08-27 02:37:54 -04:00
|
|
|
if (Player->GetBedWorld() == DestinationWorld)
|
|
|
|
{
|
|
|
|
Player->TeleportToCoords(Player->GetLastBedPos().x, Player->GetLastBedPos().y, Player->GetLastBedPos().z);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Player->TeleportToCoords(DestinationWorld->GetSpawnX(), DestinationWorld->GetSpawnY(), DestinationWorld->GetSpawnZ());
|
|
|
|
}
|
|
|
|
Player->GetClientHandle()->SendRespawn(DestionationDim);
|
2014-08-03 00:44:02 -04:00
|
|
|
}
|
2014-07-20 05:46:45 -04:00
|
|
|
|
2016-02-08 05:06:14 -05:00
|
|
|
cWorld * TargetWorld = cRoot::Get()->GetWorld(GetWorld()->GetLinkedOverworldName());
|
|
|
|
ASSERT(TargetWorld != nullptr); // The linkage checker should have prevented this at startup. See cWorld::start()
|
2016-08-27 02:37:54 -04:00
|
|
|
LOGD("Jumping %s -> %s", DimensionToString(dimEnd).c_str(), DimensionToString(DestionationDim).c_str());
|
2020-04-10 16:08:19 -04:00
|
|
|
return MoveToWorld(*TargetWorld, false);
|
2014-08-03 00:44:02 -04:00
|
|
|
}
|
2016-08-27 02:37:54 -04:00
|
|
|
// End portal in the overworld
|
2014-08-03 00:44:02 -04:00
|
|
|
else
|
|
|
|
{
|
2015-03-21 10:20:31 -04:00
|
|
|
if (GetWorld()->GetLinkedEndWorldName().empty())
|
2014-08-03 00:44:02 -04:00
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2016-08-27 02:37:54 -04:00
|
|
|
cWorld * DestinationWorld = cRoot::Get()->GetWorld(GetWorld()->GetLinkedEndWorldName());
|
|
|
|
eDimension DestionationDim = DestinationWorld->GetDimension();
|
2014-06-12 10:21:07 -04:00
|
|
|
|
2014-08-03 00:44:02 -04:00
|
|
|
m_PortalCooldownData.m_ShouldPreventTeleportation = true;
|
2014-06-12 10:21:07 -04:00
|
|
|
|
2014-08-03 00:44:02 -04:00
|
|
|
if (IsPlayer())
|
|
|
|
{
|
2016-08-27 02:37:54 -04:00
|
|
|
if (DestionationDim == dimEnd)
|
|
|
|
{
|
2018-05-02 03:50:36 -04:00
|
|
|
static_cast<cPlayer *>(this)->AwardAchievement(achEnterTheEnd);
|
2016-08-27 02:37:54 -04:00
|
|
|
}
|
2018-05-02 03:50:36 -04:00
|
|
|
static_cast<cPlayer *>(this)->GetClientHandle()->SendRespawn(DestionationDim);
|
2014-05-31 17:28:51 -04:00
|
|
|
}
|
2014-08-03 00:44:02 -04:00
|
|
|
|
2016-02-08 05:06:14 -05:00
|
|
|
cWorld * TargetWorld = cRoot::Get()->GetWorld(GetWorld()->GetLinkedEndWorldName());
|
|
|
|
ASSERT(TargetWorld != nullptr); // The linkage checker should have prevented this at startup. See cWorld::start()
|
2016-08-27 02:37:54 -04:00
|
|
|
LOGD("Jumping %s -> %s", DimensionToString(dimOverworld).c_str(), DimensionToString(DestionationDim).c_str());
|
2020-04-10 16:08:19 -04:00
|
|
|
return MoveToWorld(*TargetWorld, false);
|
2014-05-31 17:28:51 -04:00
|
|
|
}
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2014-05-31 17:28:51 -04:00
|
|
|
}
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
}
|
2014-06-12 10:21:07 -04:00
|
|
|
|
|
|
|
// Allow portals to work again
|
2014-07-21 17:49:06 -04:00
|
|
|
m_PortalCooldownData.m_ShouldPreventTeleportation = false;
|
2014-07-23 16:12:59 -04:00
|
|
|
m_PortalCooldownData.m_TicksDelayed = 0;
|
2014-07-22 12:26:48 -04:00
|
|
|
return false;
|
2014-05-31 17:28:51 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-03-05 05:52:34 -05:00
|
|
|
void cEntity::DoMoveToWorld(const sWorldChangeInfo & a_WorldChangeInfo)
|
2014-05-31 17:28:51 -04:00
|
|
|
{
|
2020-03-05 05:52:34 -05:00
|
|
|
ASSERT(a_WorldChangeInfo.m_NewWorld != nullptr);
|
2014-06-12 10:21:07 -04:00
|
|
|
|
2020-03-05 05:52:34 -05:00
|
|
|
if (a_WorldChangeInfo.m_SetPortalCooldown)
|
2014-05-31 17:28:51 -04:00
|
|
|
{
|
2020-03-05 05:52:34 -05:00
|
|
|
m_PortalCooldownData.m_TicksDelayed = 0;
|
|
|
|
m_PortalCooldownData.m_ShouldPreventTeleportation = true;
|
2014-05-31 17:28:51 -04:00
|
|
|
}
|
|
|
|
|
2020-03-05 05:52:34 -05:00
|
|
|
if (GetWorld() == a_WorldChangeInfo.m_NewWorld)
|
2015-05-18 16:29:39 -04:00
|
|
|
{
|
2020-03-05 05:52:34 -05:00
|
|
|
// Moving to same world, don't need to remove from world
|
|
|
|
SetPosition(a_WorldChangeInfo.m_NewPosition);
|
|
|
|
return;
|
2015-05-18 16:29:39 -04:00
|
|
|
}
|
|
|
|
|
2020-03-05 05:52:34 -05:00
|
|
|
LOGD("Warping entity #%i (%s) from world \"%s\" to \"%s\". Source chunk: (%d, %d) ",
|
|
|
|
GetUniqueID(), GetClass(),
|
|
|
|
m_World->GetName(), a_WorldChangeInfo.m_NewWorld->GetName(),
|
|
|
|
GetChunkX(), GetChunkZ()
|
|
|
|
);
|
|
|
|
|
2020-03-05 14:33:43 -05:00
|
|
|
// If entity is attached to another entity, detach, to prevent client side effects
|
|
|
|
Detach();
|
|
|
|
|
2016-02-07 12:07:14 -05:00
|
|
|
// Stop ticking, in preperation for detaching from this world.
|
|
|
|
SetIsTicking(false);
|
2016-02-02 10:37:21 -05:00
|
|
|
|
2020-03-05 05:52:34 -05:00
|
|
|
// Remove from the old world
|
|
|
|
auto Self = m_World->RemoveEntity(*this);
|
2014-05-31 17:28:51 -04:00
|
|
|
|
2020-03-05 05:52:34 -05:00
|
|
|
// Update entity before calling hook
|
|
|
|
ResetPosition(a_WorldChangeInfo.m_NewPosition);
|
|
|
|
SetWorld(a_WorldChangeInfo.m_NewWorld);
|
2017-09-05 10:11:35 -04:00
|
|
|
|
2020-03-05 05:52:34 -05:00
|
|
|
cRoot::Get()->GetPluginManager()->CallHookEntityChangedWorld(*this, *m_World);
|
2015-05-26 21:35:28 -04:00
|
|
|
|
2020-03-05 05:52:34 -05:00
|
|
|
// Don't do anything after adding as the old world's CS no longer protects us
|
|
|
|
a_WorldChangeInfo.m_NewWorld->AddEntity(std::move(Self));
|
2014-05-31 17:28:51 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-04-10 16:08:19 -04:00
|
|
|
bool cEntity::MoveToWorld(cWorld & a_World, Vector3d a_NewPosition, bool a_SetPortalCooldown, bool a_ShouldSendRespawn)
|
2016-03-30 04:38:45 -04:00
|
|
|
{
|
2020-03-05 05:52:34 -05:00
|
|
|
// Ask the plugins if the entity is allowed to change world
|
2020-04-10 16:08:19 -04:00
|
|
|
if (cRoot::Get()->GetPluginManager()->CallHookEntityChangingWorld(*this, a_World))
|
2020-03-05 05:52:34 -05:00
|
|
|
{
|
|
|
|
// A Plugin isn't allowing the entity to change world
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2020-04-10 16:08:19 -04:00
|
|
|
const auto OldWorld = m_WorldChangeInfo.m_NewWorld;
|
|
|
|
|
|
|
|
// Create new world change info
|
|
|
|
// (The last warp command always takes precedence)
|
|
|
|
m_WorldChangeInfo = { &a_World, a_NewPosition, a_SetPortalCooldown, a_ShouldSendRespawn };
|
|
|
|
|
|
|
|
if (OldWorld != nullptr)
|
2020-04-05 08:41:14 -04:00
|
|
|
{
|
|
|
|
// Avoid scheduling multiple warp tasks
|
2020-04-10 16:08:19 -04:00
|
|
|
// Only move ahead if we came from a "not warping" state
|
2020-04-05 08:41:14 -04:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO: move to capture when C++14
|
|
|
|
const auto EntityID = GetUniqueID();
|
2020-03-05 05:52:34 -05:00
|
|
|
|
2020-04-05 08:41:14 -04:00
|
|
|
/* Requirements:
|
|
|
|
Only one world change in-flight at any time
|
|
|
|
No ticking during world changes
|
|
|
|
The last invocation takes effect
|
|
|
|
|
|
|
|
As of writing, cWorld ticks entities, clients, and then processes tasks
|
|
|
|
We may call MoveToWorld (any number of times - consider multiple /portal commands within a tick) in the first and second stages
|
|
|
|
Queue a task onto the third stage to invoke DoMoveToWorld ONCE with the last given destination world
|
|
|
|
Store entity IDs in case client tick found the player disconnected and immediately destroys the object
|
|
|
|
|
|
|
|
After the move begins, no further calls to MoveToWorld is possible since neither the client nor entity is ticked
|
|
|
|
This remains until the warp is complete and the destination world resumes ticking.
|
|
|
|
*/
|
|
|
|
GetWorld()->QueueTask(
|
|
|
|
[EntityID](cWorld & a_CurWorld)
|
|
|
|
{
|
|
|
|
a_CurWorld.DoWithEntityByID(
|
|
|
|
EntityID,
|
|
|
|
[](cEntity & a_Entity)
|
|
|
|
{
|
|
|
|
auto & WCI = a_Entity.m_WorldChangeInfo;
|
|
|
|
a_Entity.DoMoveToWorld(WCI);
|
|
|
|
WCI.m_NewWorld = nullptr;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
);
|
|
|
|
}
|
|
|
|
);
|
2020-03-05 05:52:34 -05:00
|
|
|
|
|
|
|
return true;
|
2016-03-30 04:38:45 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-04-10 16:08:19 -04:00
|
|
|
bool cEntity::MoveToWorld(cWorld & a_World, bool a_ShouldSendRespawn)
|
2016-03-30 04:38:45 -04:00
|
|
|
{
|
2020-04-10 16:08:19 -04:00
|
|
|
return MoveToWorld(a_World, a_ShouldSendRespawn, Vector3d(a_World.GetSpawnX(), a_World.GetSpawnY(), a_World.GetSpawnZ()));
|
2016-03-30 04:38:45 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-07-21 17:49:06 -04:00
|
|
|
bool cEntity::MoveToWorld(const AString & a_WorldName, bool a_ShouldSendRespawn)
|
|
|
|
{
|
|
|
|
cWorld * World = cRoot::Get()->GetWorld(a_WorldName);
|
2014-10-20 16:55:07 -04:00
|
|
|
if (World == nullptr)
|
2014-07-21 17:49:06 -04:00
|
|
|
{
|
|
|
|
LOG("%s: Couldn't find world \"%s\".", __FUNCTION__, a_WorldName.c_str());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2020-04-10 16:08:19 -04:00
|
|
|
return MoveToWorld(*World, Vector3d(World->GetSpawnX(), World->GetSpawnY(), World->GetSpawnZ()), false, a_ShouldSendRespawn);
|
2014-07-21 17:49:06 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-01-24 18:58:51 -05:00
|
|
|
void cEntity::SetSwimState(cChunk & a_Chunk)
|
|
|
|
{
|
2018-01-14 13:44:45 -05:00
|
|
|
m_IsInFire = false;
|
|
|
|
m_IsInLava = false;
|
|
|
|
m_IsInWater = false;
|
|
|
|
m_IsHeadInWater = false;
|
|
|
|
|
2015-07-29 11:04:03 -04:00
|
|
|
int RelY = FloorC(GetPosY() + 0.1);
|
2017-09-10 12:45:18 -04:00
|
|
|
int HeadRelY = CeilC(GetPosY() + GetHeight()) - 1;
|
|
|
|
ASSERT(RelY <= HeadRelY);
|
|
|
|
if ((RelY < 0) || (HeadRelY >= cChunkDef::Height))
|
2014-01-24 18:58:51 -05:00
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-01-14 13:44:45 -05:00
|
|
|
int MinRelX = FloorC(GetPosX() - m_Width / 2) - a_Chunk.GetPosX() * cChunkDef::Width;
|
|
|
|
int MaxRelX = FloorC(GetPosX() + m_Width / 2) - a_Chunk.GetPosX() * cChunkDef::Width;
|
|
|
|
int MinRelZ = FloorC(GetPosZ() - m_Width / 2) - a_Chunk.GetPosZ() * cChunkDef::Width;
|
|
|
|
int MaxRelZ = FloorC(GetPosZ() + m_Width / 2) - a_Chunk.GetPosZ() * cChunkDef::Width;
|
|
|
|
int MinY = Clamp(POSY_TOINT, 0, cChunkDef::Height - 1);
|
|
|
|
int MaxY = Clamp(FloorC(GetPosY() + m_Height), 0, cChunkDef::Height - 1);
|
|
|
|
|
|
|
|
for (int x = MinRelX; x <= MaxRelX; x++)
|
|
|
|
{
|
|
|
|
for (int z = MinRelZ; z <= MaxRelZ; z++)
|
|
|
|
{
|
|
|
|
for (int y = MinY; y <= MaxY; y++)
|
|
|
|
{
|
|
|
|
BLOCKTYPE Block;
|
|
|
|
if (!a_Chunk.UnboundedRelGetBlockType(x, y, z, Block))
|
|
|
|
{
|
|
|
|
LOGD("SetSwimState failure: RelX = %d, RelY = %d, RelZ = %d, Pos = %.02f, %.02f}",
|
|
|
|
x, y, z, GetPosX(), GetPosZ()
|
|
|
|
);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Block == E_BLOCK_FIRE)
|
|
|
|
{
|
|
|
|
m_IsInFire = true;
|
|
|
|
}
|
|
|
|
else if (IsBlockLava(Block))
|
|
|
|
{
|
|
|
|
m_IsInLava = true;
|
|
|
|
}
|
|
|
|
else if (IsBlockWater(Block))
|
|
|
|
{
|
|
|
|
m_IsInWater = true;
|
|
|
|
}
|
|
|
|
} // for y
|
|
|
|
} // for z
|
|
|
|
} // for x
|
|
|
|
|
|
|
|
// Check if the entity's head is in water.
|
2014-03-05 17:12:48 -05:00
|
|
|
int RelX = POSX_TOINT - a_Chunk.GetPosX() * cChunkDef::Width;
|
|
|
|
int RelZ = POSZ_TOINT - a_Chunk.GetPosZ() * cChunkDef::Width;
|
2018-01-14 13:44:45 -05:00
|
|
|
int HeadHeight = CeilC(GetPosY() + GetHeight()) - 1;
|
|
|
|
BLOCKTYPE BlockIn;
|
|
|
|
if (!a_Chunk.UnboundedRelGetBlockType(RelX, HeadHeight, RelZ, BlockIn))
|
2014-01-24 18:58:51 -05:00
|
|
|
{
|
2018-01-14 13:44:45 -05:00
|
|
|
LOGD("SetSwimState failure: RelX = %d, RelY = %d, RelZ = %d, Pos = %.02f, %.02f}",
|
|
|
|
RelX, HeadHeight, RelZ, GetPosX(), GetPosZ()
|
2014-04-24 17:03:47 -04:00
|
|
|
);
|
2014-01-24 18:58:51 -05:00
|
|
|
return;
|
|
|
|
}
|
2018-01-14 13:44:45 -05:00
|
|
|
m_IsHeadInWater = IsBlockWater(BlockIn);
|
2014-01-24 18:58:51 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2016-02-07 12:07:14 -05:00
|
|
|
void cEntity::SetIsTicking(bool a_IsTicking)
|
|
|
|
{
|
|
|
|
m_IsTicking = a_IsTicking;
|
|
|
|
ASSERT(!(m_IsTicking && (m_ParentChunk == nullptr))); // We shouldn't be ticking if we have no parent chunk
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-06-16 10:12:50 -04:00
|
|
|
void cEntity::DoSetSpeed(double a_SpeedX, double a_SpeedY, double a_SpeedZ)
|
|
|
|
{
|
|
|
|
m_Speed.Set(a_SpeedX, a_SpeedY, a_SpeedZ);
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2014-06-16 10:12:50 -04:00
|
|
|
WrapSpeed();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-01-24 18:58:51 -05:00
|
|
|
void cEntity::HandleAir(void)
|
|
|
|
{
|
2017-08-24 05:19:40 -04:00
|
|
|
// Ref.: https://minecraft.gamepedia.com/Chunk_format
|
2017-08-29 16:29:06 -04:00
|
|
|
// See if the entity is /submerged/ water (head is in water)
|
2014-01-24 18:58:51 -05:00
|
|
|
// Get the type of block the entity is standing in:
|
|
|
|
|
2015-07-29 11:04:03 -04:00
|
|
|
int RespirationLevel = static_cast<int>(GetEquippedHelmet().m_Enchantments.GetLevel(cEnchantments::enchRespiration));
|
2014-08-22 05:49:49 -04:00
|
|
|
|
2018-01-14 13:44:45 -05:00
|
|
|
if (IsHeadInWater())
|
2014-01-24 18:58:51 -05:00
|
|
|
{
|
2014-07-17 16:15:34 -04:00
|
|
|
if (!IsPlayer()) // Players control themselves
|
2014-06-27 18:13:26 -04:00
|
|
|
{
|
2014-07-17 16:15:34 -04:00
|
|
|
SetSpeedY(1); // Float in the water
|
2014-06-27 18:13:26 -04:00
|
|
|
}
|
2014-01-24 18:58:51 -05:00
|
|
|
|
2014-08-22 05:49:49 -04:00
|
|
|
if (RespirationLevel > 0)
|
|
|
|
{
|
2018-05-02 03:50:36 -04:00
|
|
|
static_cast<cPawn *>(this)->AddEntityEffect(cEntityEffect::effNightVision, 200, 5, 0);
|
2014-08-22 05:49:49 -04:00
|
|
|
}
|
|
|
|
|
2014-08-03 01:35:29 -04:00
|
|
|
if (m_AirLevel <= 0)
|
2014-01-24 18:58:51 -05:00
|
|
|
{
|
2014-08-03 05:20:48 -04:00
|
|
|
// Runs the air tick timer to check whether the player should be damaged
|
2014-08-03 01:35:29 -04:00
|
|
|
if (m_AirTickTimer <= 0)
|
2014-01-24 18:58:51 -05:00
|
|
|
{
|
2014-07-17 16:50:58 -04:00
|
|
|
// Damage player
|
2014-10-20 16:55:07 -04:00
|
|
|
TakeDamage(dtDrowning, nullptr, 1, 1, 0);
|
2014-01-24 18:58:51 -05:00
|
|
|
// Reset timer
|
|
|
|
m_AirTickTimer = DROWNING_TICKS;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-04-12 08:16:48 -04:00
|
|
|
m_AirTickTimer--;
|
2014-01-24 18:58:51 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Reduce air supply
|
2014-04-12 08:16:48 -04:00
|
|
|
m_AirLevel--;
|
2014-01-24 18:58:51 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Set the air back to maximum
|
|
|
|
m_AirLevel = MAX_AIR_LEVEL;
|
|
|
|
m_AirTickTimer = DROWNING_TICKS;
|
2014-08-22 05:49:49 -04:00
|
|
|
|
|
|
|
if (RespirationLevel > 0)
|
|
|
|
{
|
|
|
|
m_AirTickTimer = DROWNING_TICKS + (RespirationLevel * 15 * 20);
|
|
|
|
}
|
|
|
|
|
2014-01-24 18:58:51 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2018-04-11 03:39:24 -04:00
|
|
|
void cEntity::ResetPosition(Vector3d a_NewPos)
|
|
|
|
{
|
|
|
|
SetPosition(a_NewPos);
|
|
|
|
m_LastSentPosition = GetPosition();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-07-01 06:39:56 -04:00
|
|
|
void cEntity::OnStartedBurning(void)
|
|
|
|
{
|
|
|
|
// Broadcast the change:
|
2013-07-07 09:06:06 -04:00
|
|
|
m_World->BroadcastEntityMetadata(*this);
|
2013-07-01 06:39:56 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void cEntity::OnFinishedBurning(void)
|
|
|
|
{
|
|
|
|
// Broadcast the change:
|
2013-07-07 09:06:06 -04:00
|
|
|
m_World->BroadcastEntityMetadata(*this);
|
2013-07-01 06:39:56 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2017-11-22 08:47:52 -05:00
|
|
|
void cEntity::SetMaxHealth(float a_MaxHealth)
|
2013-07-01 06:39:56 -04:00
|
|
|
{
|
|
|
|
m_MaxHealth = a_MaxHealth;
|
|
|
|
|
|
|
|
// Reset health, if too high:
|
2014-07-17 16:32:23 -04:00
|
|
|
m_Health = std::min(m_Health, a_MaxHealth);
|
2013-07-01 06:39:56 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-04-23 03:12:37 -04:00
|
|
|
void cEntity::SetIsFireproof(bool a_IsFireproof)
|
2014-04-22 18:59:31 -04:00
|
|
|
{
|
|
|
|
m_IsFireproof = a_IsFireproof;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-07-01 06:39:56 -04:00
|
|
|
void cEntity::StartBurning(int a_TicksLeftBurning)
|
|
|
|
{
|
|
|
|
if (m_TicksLeftBurning > 0)
|
|
|
|
{
|
|
|
|
// Already burning, top up the ticks left burning and bail out:
|
|
|
|
m_TicksLeftBurning = std::max(m_TicksLeftBurning, a_TicksLeftBurning);
|
|
|
|
return;
|
|
|
|
}
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2013-07-01 06:39:56 -04:00
|
|
|
m_TicksLeftBurning = a_TicksLeftBurning;
|
|
|
|
OnStartedBurning();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void cEntity::StopBurning(void)
|
|
|
|
{
|
|
|
|
bool HasBeenBurning = (m_TicksLeftBurning > 0);
|
|
|
|
m_TicksLeftBurning = 0;
|
|
|
|
m_TicksSinceLastBurnDamage = 0;
|
|
|
|
m_TicksSinceLastFireDamage = 0;
|
|
|
|
m_TicksSinceLastLavaDamage = 0;
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2013-07-01 06:39:56 -04:00
|
|
|
// Notify if the entity has stopped burning
|
|
|
|
if (HasBeenBurning)
|
|
|
|
{
|
|
|
|
OnFinishedBurning();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void cEntity::TeleportToEntity(cEntity & a_Entity)
|
|
|
|
{
|
|
|
|
TeleportToCoords(a_Entity.GetPosX(), a_Entity.GetPosY(), a_Entity.GetPosZ());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void cEntity::TeleportToCoords(double a_PosX, double a_PosY, double a_PosZ)
|
|
|
|
{
|
2015-03-05 05:52:42 -05:00
|
|
|
// ask the plugins to allow teleport to the new position.
|
2015-07-21 16:25:37 -04:00
|
|
|
if (!cRoot::Get()->GetPluginManager()->CallHookEntityTeleport(*this, m_LastPosition, Vector3d(a_PosX, a_PosY, a_PosZ)))
|
2015-03-05 05:52:42 -05:00
|
|
|
{
|
2020-05-04 04:10:47 -04:00
|
|
|
SetPosition({a_PosX, a_PosY, a_PosZ});
|
2015-03-05 05:52:42 -05:00
|
|
|
}
|
2013-07-01 06:39:56 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-03-22 02:33:10 -04:00
|
|
|
void cEntity::BroadcastMovementUpdate(const cClientHandle * a_Exclude)
|
|
|
|
{
|
2014-04-23 16:06:46 -04:00
|
|
|
// Process packet sending every two ticks
|
2020-03-04 09:47:51 -05:00
|
|
|
if (GetWorld()->GetWorldAge() % 2 != 0)
|
2013-04-07 02:53:17 -04:00
|
|
|
{
|
2020-03-04 09:47:51 -05:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-05-04 04:10:47 -04:00
|
|
|
if (GetSpeed().SqrLength() > 0.001)
|
2020-03-04 09:47:51 -05:00
|
|
|
{
|
|
|
|
// Movin'
|
|
|
|
m_World->BroadcastEntityVelocity(*this, a_Exclude);
|
|
|
|
m_bHasSentNoSpeed = false;
|
|
|
|
}
|
2020-05-04 04:10:47 -04:00
|
|
|
else if (!m_bHasSentNoSpeed)
|
2020-03-04 09:47:51 -05:00
|
|
|
{
|
|
|
|
// Speed is zero, send this to clients once only as well as an absolute position
|
2020-05-04 04:10:47 -04:00
|
|
|
m_World->BroadcastEntityVelocity(*this, a_Exclude);
|
|
|
|
m_World->BroadcastEntityPosition(*this, a_Exclude);
|
|
|
|
m_LastSentPosition = GetPosition();
|
|
|
|
m_bDirtyOrientation = false;
|
|
|
|
m_bHasSentNoSpeed = true;
|
2020-03-04 09:47:51 -05:00
|
|
|
}
|
2016-01-16 07:16:47 -05:00
|
|
|
|
2020-03-04 09:47:51 -05:00
|
|
|
Vector3i Diff = (GetPosition() * 32.0).Floor() - (m_LastSentPosition * 32.0).Floor();
|
|
|
|
if (Diff.HasNonZeroLength()) // Have we moved?
|
|
|
|
{
|
2020-05-04 04:10:47 -04:00
|
|
|
m_World->BroadcastEntityPosition(*this, a_Exclude);
|
|
|
|
|
|
|
|
// Clients seem to store two positions, one for the velocity packet and one for the teleport / relmove packet
|
|
|
|
// The latter is only changed with a relmove / teleport, and m_LastSentPosition stores this position
|
|
|
|
m_LastSentPosition = GetPosition();
|
|
|
|
m_bDirtyOrientation = false;
|
2013-03-22 02:33:10 -04:00
|
|
|
}
|
2020-03-04 09:47:51 -05:00
|
|
|
|
|
|
|
if (m_bDirtyHead)
|
|
|
|
{
|
|
|
|
m_World->BroadcastEntityHeadLook(*this, a_Exclude);
|
|
|
|
m_bDirtyHead = false;
|
|
|
|
}
|
2020-05-04 04:10:47 -04:00
|
|
|
|
2020-03-04 09:47:51 -05:00
|
|
|
if (m_bDirtyOrientation)
|
|
|
|
{
|
|
|
|
// Send individual update in case above (sending with rel-move packet) wasn't done
|
|
|
|
GetWorld()->BroadcastEntityLook(*this, a_Exclude);
|
|
|
|
m_bDirtyOrientation = false;
|
|
|
|
}
|
2013-03-22 02:33:10 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2018-07-26 17:24:36 -04:00
|
|
|
|
2016-07-18 16:10:00 -04:00
|
|
|
cEntity * cEntity::GetAttached()
|
|
|
|
{
|
|
|
|
return m_AttachedTo;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-03-22 02:33:10 -04:00
|
|
|
|
2013-03-03 14:05:11 -05:00
|
|
|
void cEntity::AttachTo(cEntity * a_AttachTo)
|
|
|
|
{
|
|
|
|
if (m_AttachedTo == a_AttachTo)
|
|
|
|
{
|
|
|
|
// Already attached to that entity, nothing to do here
|
|
|
|
return;
|
|
|
|
}
|
2014-10-20 16:55:07 -04:00
|
|
|
if (m_AttachedTo != nullptr)
|
2014-01-12 18:23:36 -05:00
|
|
|
{
|
|
|
|
// Detach from any previous entity:
|
|
|
|
Detach();
|
|
|
|
}
|
2013-04-02 02:48:31 -04:00
|
|
|
|
1.9 / 1.9.2 / 1.9.3 / 1.9.4 protocol support (#3135)
* Semistable update to 15w31a
I'm going through snapshots in a sequential order since it should make things easier, and since protocol version history is written.
* Update to 15w34b protocol
Also, fix an issue with the Entity Equipment packet from the past version. Clients are able to connect and do stuff!
* Partially update to 15w35e
Chunk data doesn't work, but the client joins. I'm waiting to do chunk data because chunk data has an incomplete format until 15w36d.
* Add '/blk' debug command
This command lets one see what block they are looking at, and makes figuring out what's supposed to be where in a highly broken chunk possible.
* Fix CRLF normalization in CheckBasicStyle.lua
Normally, this doesn't cause an issue, but when running from cygwin, it detects the CR as whitespace and creates thousands of violations for every single line. Lua, when run on windows, will normalize automatically, but when run via cygwin, it won't.
The bug was simply that gsub was returning a replaced version, but not changing the parameter, so the replaced version was ignored.
* Update to 15w40b
This includes chunk serialization. Fully functional chunk serialization for 1.9.
I'm not completely happy with the chunk serialization as-is (correct use of palettes would be great), but cuberite also doesn't skip sending empty chunks so this performance optimization should probably come later. The creation of a full buffer is suboptimal, but it's the easiest way to implement this code.
* Write long-by-long rather than creating a buffer
This is a bit faster and should be equivalent. However, the code still doesn't look too good.
* Update to 15w41a protocol
This includes the new set passengers packet, which works off of the ridden entity, not the rider. That means, among other things, that information about the previously ridden vehicle is needed when detaching. So a new method with that info was added.
* Update to 15w45a
* 15w51b protocol
* Update to 1.9.0 protocol
Closes #3067. There are still a few things that need to be worked out (picking up items, effects, particles, and most importantly inventory), but in general this should work. I'll make a few more changes tomorrow to get the rest of the protocol set up, along with 1.9.1/1.9.2 (which did make a few changes). Chunks, however, _are_ working, along with most other parts of the game (placing/breaking blocks).
* Fix item pickup packet not working
That was a silly mistake, but at least it was an easy one.
* 1.9.2 protocol support
* Fix version info found in server list ping
Thus, the client reports that it can connect rather than saying that the server is out of date. This required creating separate classes for 1.9.1 and 1.9.2, unfortunately.
* Fix build errors generated by clang
These didn't happen in MSVC.
* Add protocol19x.cpp and protocol19x.h to CMakeLists
* Ignore warnings in protocol19x that are ignored in protocol18x
* Document BLOCK_FACE and DIG_STATUS constants
* Fix BLOCK_FACE links and add separate section for DIG_STATUS
* Fix bat animation and object spawning
The causes of both of these are explained in #3135, but the gist is that both were typos.
* Implement Use Item packet
This means that buckets, bows, fishing rods, and several other similar items now work when not looking at a block.
* Handle DIG_STATUS_SWAP_ITEM_IN_HAND
* Add support for spawn eggs and potions
The items are transformed from the 1.9 version to the 1.8 version when reading and transformed back when sending.
* Remove spammy potion debug logging
* Fix wolf collar color metadata
The wrong type was being used, causing several clientside issues (including the screen going black).
* Fix 1.9 chunk sending in the nether
The nether and the end don't send skylight.
* Fix clang build errors
* Fix water bottles becoming mundane potions
This happened because the can become splash potion bit got set incorrectly. Water bottles and mundane potions are only differentiated by the fact that water bottles have a metadata of 0, so setting that bit made it a mundane potion.
Also add missing break statements to the read item NBT switch, which would otherwise break items with custom names and also cause incorrect "Unimplemented NBT data when parsing!" logging.
* Copy Protocol18x as Protocol19x
Aditionally, method and class names have been swapped to clean up other diffs. This commit is only added to make the following diffs more readable; it doesn't make any other changes (beyond class names).
* Make thrown potions use the correct appearence
This was caused by potions now using metadata.
* Add missing api doc for cSplashPotionEntity::GetItem
* Fix compile error in SplashPotionEntity.cpp
* Fix fix of cSplashPotionEntity API doc
* Temporarilly disable fall damage particles
These were causing issues in 1.9 due to the changed effect ID.
* Properly send a kick packet when connecting with an invalid version
This means that the client no longer waits on the server screen with no indication whatsoever. However, right now the server list ping isn't implemented for unknown versions, so it'll only load "Old" on the ping.
I also added a GetVarIntSize method to cByteBuffer. This helps clean up part of the code here (and I think it could clean up other parts), but it may make sense for it to be moved elsewhere (or declared in a different way).
* Handle server list pings from unrecognized versions
This isn't the cleanest way of writing it (it feels odd to use ProtocolRecognizer to send packets, and the addition of m_InPingForUnrecognizedVersion feels like the wrong technique), but it works and I can't think of a better way (apart from creating a full separate protocol class to handle only the ping... which would be worse).
* Use cPacketizer for the disconnect packet
This also should fix clang build errors.
* Add 1.9.3 / 1.9.4 support
* Fix incorrect indentation in APIDesc
2016-05-14 15:12:42 -04:00
|
|
|
// Update state information
|
2013-03-03 14:05:11 -05:00
|
|
|
m_AttachedTo = a_AttachTo;
|
|
|
|
a_AttachTo->m_Attachee = this;
|
1.9 / 1.9.2 / 1.9.3 / 1.9.4 protocol support (#3135)
* Semistable update to 15w31a
I'm going through snapshots in a sequential order since it should make things easier, and since protocol version history is written.
* Update to 15w34b protocol
Also, fix an issue with the Entity Equipment packet from the past version. Clients are able to connect and do stuff!
* Partially update to 15w35e
Chunk data doesn't work, but the client joins. I'm waiting to do chunk data because chunk data has an incomplete format until 15w36d.
* Add '/blk' debug command
This command lets one see what block they are looking at, and makes figuring out what's supposed to be where in a highly broken chunk possible.
* Fix CRLF normalization in CheckBasicStyle.lua
Normally, this doesn't cause an issue, but when running from cygwin, it detects the CR as whitespace and creates thousands of violations for every single line. Lua, when run on windows, will normalize automatically, but when run via cygwin, it won't.
The bug was simply that gsub was returning a replaced version, but not changing the parameter, so the replaced version was ignored.
* Update to 15w40b
This includes chunk serialization. Fully functional chunk serialization for 1.9.
I'm not completely happy with the chunk serialization as-is (correct use of palettes would be great), but cuberite also doesn't skip sending empty chunks so this performance optimization should probably come later. The creation of a full buffer is suboptimal, but it's the easiest way to implement this code.
* Write long-by-long rather than creating a buffer
This is a bit faster and should be equivalent. However, the code still doesn't look too good.
* Update to 15w41a protocol
This includes the new set passengers packet, which works off of the ridden entity, not the rider. That means, among other things, that information about the previously ridden vehicle is needed when detaching. So a new method with that info was added.
* Update to 15w45a
* 15w51b protocol
* Update to 1.9.0 protocol
Closes #3067. There are still a few things that need to be worked out (picking up items, effects, particles, and most importantly inventory), but in general this should work. I'll make a few more changes tomorrow to get the rest of the protocol set up, along with 1.9.1/1.9.2 (which did make a few changes). Chunks, however, _are_ working, along with most other parts of the game (placing/breaking blocks).
* Fix item pickup packet not working
That was a silly mistake, but at least it was an easy one.
* 1.9.2 protocol support
* Fix version info found in server list ping
Thus, the client reports that it can connect rather than saying that the server is out of date. This required creating separate classes for 1.9.1 and 1.9.2, unfortunately.
* Fix build errors generated by clang
These didn't happen in MSVC.
* Add protocol19x.cpp and protocol19x.h to CMakeLists
* Ignore warnings in protocol19x that are ignored in protocol18x
* Document BLOCK_FACE and DIG_STATUS constants
* Fix BLOCK_FACE links and add separate section for DIG_STATUS
* Fix bat animation and object spawning
The causes of both of these are explained in #3135, but the gist is that both were typos.
* Implement Use Item packet
This means that buckets, bows, fishing rods, and several other similar items now work when not looking at a block.
* Handle DIG_STATUS_SWAP_ITEM_IN_HAND
* Add support for spawn eggs and potions
The items are transformed from the 1.9 version to the 1.8 version when reading and transformed back when sending.
* Remove spammy potion debug logging
* Fix wolf collar color metadata
The wrong type was being used, causing several clientside issues (including the screen going black).
* Fix 1.9 chunk sending in the nether
The nether and the end don't send skylight.
* Fix clang build errors
* Fix water bottles becoming mundane potions
This happened because the can become splash potion bit got set incorrectly. Water bottles and mundane potions are only differentiated by the fact that water bottles have a metadata of 0, so setting that bit made it a mundane potion.
Also add missing break statements to the read item NBT switch, which would otherwise break items with custom names and also cause incorrect "Unimplemented NBT data when parsing!" logging.
* Copy Protocol18x as Protocol19x
Aditionally, method and class names have been swapped to clean up other diffs. This commit is only added to make the following diffs more readable; it doesn't make any other changes (beyond class names).
* Make thrown potions use the correct appearence
This was caused by potions now using metadata.
* Add missing api doc for cSplashPotionEntity::GetItem
* Fix compile error in SplashPotionEntity.cpp
* Fix fix of cSplashPotionEntity API doc
* Temporarilly disable fall damage particles
These were causing issues in 1.9 due to the changed effect ID.
* Properly send a kick packet when connecting with an invalid version
This means that the client no longer waits on the server screen with no indication whatsoever. However, right now the server list ping isn't implemented for unknown versions, so it'll only load "Old" on the ping.
I also added a GetVarIntSize method to cByteBuffer. This helps clean up part of the code here (and I think it could clean up other parts), but it may make sense for it to be moved elsewhere (or declared in a different way).
* Handle server list pings from unrecognized versions
This isn't the cleanest way of writing it (it feels odd to use ProtocolRecognizer to send packets, and the addition of m_InPingForUnrecognizedVersion feels like the wrong technique), but it works and I can't think of a better way (apart from creating a full separate protocol class to handle only the ping... which would be worse).
* Use cPacketizer for the disconnect packet
This also should fix clang build errors.
* Add 1.9.3 / 1.9.4 support
* Fix incorrect indentation in APIDesc
2016-05-14 15:12:42 -04:00
|
|
|
if (a_AttachTo != nullptr)
|
|
|
|
{
|
|
|
|
m_World->BroadcastAttachEntity(*this, *a_AttachTo);
|
|
|
|
}
|
2013-03-03 14:05:11 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void cEntity::Detach(void)
|
|
|
|
{
|
2014-10-20 16:55:07 -04:00
|
|
|
if (m_AttachedTo == nullptr)
|
2013-03-03 14:05:11 -05:00
|
|
|
{
|
1.9 / 1.9.2 / 1.9.3 / 1.9.4 protocol support (#3135)
* Semistable update to 15w31a
I'm going through snapshots in a sequential order since it should make things easier, and since protocol version history is written.
* Update to 15w34b protocol
Also, fix an issue with the Entity Equipment packet from the past version. Clients are able to connect and do stuff!
* Partially update to 15w35e
Chunk data doesn't work, but the client joins. I'm waiting to do chunk data because chunk data has an incomplete format until 15w36d.
* Add '/blk' debug command
This command lets one see what block they are looking at, and makes figuring out what's supposed to be where in a highly broken chunk possible.
* Fix CRLF normalization in CheckBasicStyle.lua
Normally, this doesn't cause an issue, but when running from cygwin, it detects the CR as whitespace and creates thousands of violations for every single line. Lua, when run on windows, will normalize automatically, but when run via cygwin, it won't.
The bug was simply that gsub was returning a replaced version, but not changing the parameter, so the replaced version was ignored.
* Update to 15w40b
This includes chunk serialization. Fully functional chunk serialization for 1.9.
I'm not completely happy with the chunk serialization as-is (correct use of palettes would be great), but cuberite also doesn't skip sending empty chunks so this performance optimization should probably come later. The creation of a full buffer is suboptimal, but it's the easiest way to implement this code.
* Write long-by-long rather than creating a buffer
This is a bit faster and should be equivalent. However, the code still doesn't look too good.
* Update to 15w41a protocol
This includes the new set passengers packet, which works off of the ridden entity, not the rider. That means, among other things, that information about the previously ridden vehicle is needed when detaching. So a new method with that info was added.
* Update to 15w45a
* 15w51b protocol
* Update to 1.9.0 protocol
Closes #3067. There are still a few things that need to be worked out (picking up items, effects, particles, and most importantly inventory), but in general this should work. I'll make a few more changes tomorrow to get the rest of the protocol set up, along with 1.9.1/1.9.2 (which did make a few changes). Chunks, however, _are_ working, along with most other parts of the game (placing/breaking blocks).
* Fix item pickup packet not working
That was a silly mistake, but at least it was an easy one.
* 1.9.2 protocol support
* Fix version info found in server list ping
Thus, the client reports that it can connect rather than saying that the server is out of date. This required creating separate classes for 1.9.1 and 1.9.2, unfortunately.
* Fix build errors generated by clang
These didn't happen in MSVC.
* Add protocol19x.cpp and protocol19x.h to CMakeLists
* Ignore warnings in protocol19x that are ignored in protocol18x
* Document BLOCK_FACE and DIG_STATUS constants
* Fix BLOCK_FACE links and add separate section for DIG_STATUS
* Fix bat animation and object spawning
The causes of both of these are explained in #3135, but the gist is that both were typos.
* Implement Use Item packet
This means that buckets, bows, fishing rods, and several other similar items now work when not looking at a block.
* Handle DIG_STATUS_SWAP_ITEM_IN_HAND
* Add support for spawn eggs and potions
The items are transformed from the 1.9 version to the 1.8 version when reading and transformed back when sending.
* Remove spammy potion debug logging
* Fix wolf collar color metadata
The wrong type was being used, causing several clientside issues (including the screen going black).
* Fix 1.9 chunk sending in the nether
The nether and the end don't send skylight.
* Fix clang build errors
* Fix water bottles becoming mundane potions
This happened because the can become splash potion bit got set incorrectly. Water bottles and mundane potions are only differentiated by the fact that water bottles have a metadata of 0, so setting that bit made it a mundane potion.
Also add missing break statements to the read item NBT switch, which would otherwise break items with custom names and also cause incorrect "Unimplemented NBT data when parsing!" logging.
* Copy Protocol18x as Protocol19x
Aditionally, method and class names have been swapped to clean up other diffs. This commit is only added to make the following diffs more readable; it doesn't make any other changes (beyond class names).
* Make thrown potions use the correct appearence
This was caused by potions now using metadata.
* Add missing api doc for cSplashPotionEntity::GetItem
* Fix compile error in SplashPotionEntity.cpp
* Fix fix of cSplashPotionEntity API doc
* Temporarilly disable fall damage particles
These were causing issues in 1.9 due to the changed effect ID.
* Properly send a kick packet when connecting with an invalid version
This means that the client no longer waits on the server screen with no indication whatsoever. However, right now the server list ping isn't implemented for unknown versions, so it'll only load "Old" on the ping.
I also added a GetVarIntSize method to cByteBuffer. This helps clean up part of the code here (and I think it could clean up other parts), but it may make sense for it to be moved elsewhere (or declared in a different way).
* Handle server list pings from unrecognized versions
This isn't the cleanest way of writing it (it feels odd to use ProtocolRecognizer to send packets, and the addition of m_InPingForUnrecognizedVersion feels like the wrong technique), but it works and I can't think of a better way (apart from creating a full separate protocol class to handle only the ping... which would be worse).
* Use cPacketizer for the disconnect packet
This also should fix clang build errors.
* Add 1.9.3 / 1.9.4 support
* Fix incorrect indentation in APIDesc
2016-05-14 15:12:42 -04:00
|
|
|
// Already not attached to any entity, our work is done
|
2013-03-03 14:05:11 -05:00
|
|
|
return;
|
|
|
|
}
|
1.9 / 1.9.2 / 1.9.3 / 1.9.4 protocol support (#3135)
* Semistable update to 15w31a
I'm going through snapshots in a sequential order since it should make things easier, and since protocol version history is written.
* Update to 15w34b protocol
Also, fix an issue with the Entity Equipment packet from the past version. Clients are able to connect and do stuff!
* Partially update to 15w35e
Chunk data doesn't work, but the client joins. I'm waiting to do chunk data because chunk data has an incomplete format until 15w36d.
* Add '/blk' debug command
This command lets one see what block they are looking at, and makes figuring out what's supposed to be where in a highly broken chunk possible.
* Fix CRLF normalization in CheckBasicStyle.lua
Normally, this doesn't cause an issue, but when running from cygwin, it detects the CR as whitespace and creates thousands of violations for every single line. Lua, when run on windows, will normalize automatically, but when run via cygwin, it won't.
The bug was simply that gsub was returning a replaced version, but not changing the parameter, so the replaced version was ignored.
* Update to 15w40b
This includes chunk serialization. Fully functional chunk serialization for 1.9.
I'm not completely happy with the chunk serialization as-is (correct use of palettes would be great), but cuberite also doesn't skip sending empty chunks so this performance optimization should probably come later. The creation of a full buffer is suboptimal, but it's the easiest way to implement this code.
* Write long-by-long rather than creating a buffer
This is a bit faster and should be equivalent. However, the code still doesn't look too good.
* Update to 15w41a protocol
This includes the new set passengers packet, which works off of the ridden entity, not the rider. That means, among other things, that information about the previously ridden vehicle is needed when detaching. So a new method with that info was added.
* Update to 15w45a
* 15w51b protocol
* Update to 1.9.0 protocol
Closes #3067. There are still a few things that need to be worked out (picking up items, effects, particles, and most importantly inventory), but in general this should work. I'll make a few more changes tomorrow to get the rest of the protocol set up, along with 1.9.1/1.9.2 (which did make a few changes). Chunks, however, _are_ working, along with most other parts of the game (placing/breaking blocks).
* Fix item pickup packet not working
That was a silly mistake, but at least it was an easy one.
* 1.9.2 protocol support
* Fix version info found in server list ping
Thus, the client reports that it can connect rather than saying that the server is out of date. This required creating separate classes for 1.9.1 and 1.9.2, unfortunately.
* Fix build errors generated by clang
These didn't happen in MSVC.
* Add protocol19x.cpp and protocol19x.h to CMakeLists
* Ignore warnings in protocol19x that are ignored in protocol18x
* Document BLOCK_FACE and DIG_STATUS constants
* Fix BLOCK_FACE links and add separate section for DIG_STATUS
* Fix bat animation and object spawning
The causes of both of these are explained in #3135, but the gist is that both were typos.
* Implement Use Item packet
This means that buckets, bows, fishing rods, and several other similar items now work when not looking at a block.
* Handle DIG_STATUS_SWAP_ITEM_IN_HAND
* Add support for spawn eggs and potions
The items are transformed from the 1.9 version to the 1.8 version when reading and transformed back when sending.
* Remove spammy potion debug logging
* Fix wolf collar color metadata
The wrong type was being used, causing several clientside issues (including the screen going black).
* Fix 1.9 chunk sending in the nether
The nether and the end don't send skylight.
* Fix clang build errors
* Fix water bottles becoming mundane potions
This happened because the can become splash potion bit got set incorrectly. Water bottles and mundane potions are only differentiated by the fact that water bottles have a metadata of 0, so setting that bit made it a mundane potion.
Also add missing break statements to the read item NBT switch, which would otherwise break items with custom names and also cause incorrect "Unimplemented NBT data when parsing!" logging.
* Copy Protocol18x as Protocol19x
Aditionally, method and class names have been swapped to clean up other diffs. This commit is only added to make the following diffs more readable; it doesn't make any other changes (beyond class names).
* Make thrown potions use the correct appearence
This was caused by potions now using metadata.
* Add missing api doc for cSplashPotionEntity::GetItem
* Fix compile error in SplashPotionEntity.cpp
* Fix fix of cSplashPotionEntity API doc
* Temporarilly disable fall damage particles
These were causing issues in 1.9 due to the changed effect ID.
* Properly send a kick packet when connecting with an invalid version
This means that the client no longer waits on the server screen with no indication whatsoever. However, right now the server list ping isn't implemented for unknown versions, so it'll only load "Old" on the ping.
I also added a GetVarIntSize method to cByteBuffer. This helps clean up part of the code here (and I think it could clean up other parts), but it may make sense for it to be moved elsewhere (or declared in a different way).
* Handle server list pings from unrecognized versions
This isn't the cleanest way of writing it (it feels odd to use ProtocolRecognizer to send packets, and the addition of m_InPingForUnrecognizedVersion feels like the wrong technique), but it works and I can't think of a better way (apart from creating a full separate protocol class to handle only the ping... which would be worse).
* Use cPacketizer for the disconnect packet
This also should fix clang build errors.
* Add 1.9.3 / 1.9.4 support
* Fix incorrect indentation in APIDesc
2016-05-14 15:12:42 -04:00
|
|
|
m_World->BroadcastDetachEntity(*this, *m_AttachedTo);
|
|
|
|
|
2014-10-20 16:55:07 -04:00
|
|
|
m_AttachedTo->m_Attachee = nullptr;
|
|
|
|
m_AttachedTo = nullptr;
|
2012-12-22 05:15:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2012-12-21 07:21:20 -05:00
|
|
|
bool cEntity::IsA(const char * a_ClassName) const
|
2012-06-14 09:06:06 -04:00
|
|
|
{
|
2017-04-01 17:15:08 -04:00
|
|
|
return ((a_ClassName != nullptr) && (strcmp(a_ClassName, "cEntity") == 0));
|
2012-06-14 09:06:06 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2016-02-02 08:44:10 -05:00
|
|
|
bool cEntity::IsAttachedTo(const cEntity * a_Entity) const
|
|
|
|
{
|
2020-05-14 18:15:35 -04:00
|
|
|
return (
|
|
|
|
(m_AttachedTo != nullptr) &&
|
|
|
|
(a_Entity->GetUniqueID() == m_AttachedTo->GetUniqueID())
|
|
|
|
);
|
2016-02-02 08:44:10 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-05-04 04:10:47 -04:00
|
|
|
bool cEntity::IsOrientationDirty() const
|
|
|
|
{
|
|
|
|
return m_bDirtyOrientation;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-04-02 02:48:31 -04:00
|
|
|
void cEntity::SetHeadYaw(double a_HeadYaw)
|
|
|
|
{
|
|
|
|
m_HeadYaw = a_HeadYaw;
|
|
|
|
m_bDirtyHead = true;
|
|
|
|
WrapHeadYaw();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-05-21 08:58:21 -04:00
|
|
|
void cEntity::SetHeight(double a_Height)
|
|
|
|
{
|
|
|
|
m_Height = a_Height;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-04-28 14:54:43 -04:00
|
|
|
void cEntity::SetMass(double a_Mass)
|
|
|
|
{
|
2014-08-03 01:35:29 -04:00
|
|
|
// Make sure that mass is not zero. 1g is the default because we
|
|
|
|
// have to choose a number. It's perfectly legal to have a mass
|
|
|
|
// less than 1g as long as is NOT equal or less than zero.
|
|
|
|
m_Mass = std::max(a_Mass, 0.001);
|
2013-04-28 14:54:43 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-11-02 12:45:48 -04:00
|
|
|
void cEntity::SetYaw(double a_Yaw)
|
2012-06-14 09:06:06 -04:00
|
|
|
{
|
2013-11-02 12:45:48 -04:00
|
|
|
m_Rot.x = a_Yaw;
|
2012-06-14 09:06:06 -04:00
|
|
|
m_bDirtyOrientation = true;
|
2013-04-03 01:11:00 -04:00
|
|
|
WrapRotation();
|
2012-06-14 09:06:06 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-03-09 09:35:43 -05:00
|
|
|
void cEntity::SetPitch(double a_Pitch)
|
2012-06-14 09:06:06 -04:00
|
|
|
{
|
|
|
|
m_Rot.y = a_Pitch;
|
|
|
|
m_bDirtyOrientation = true;
|
2013-04-03 01:11:00 -04:00
|
|
|
WrapRotation();
|
2012-06-14 09:06:06 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-03-09 09:35:43 -05:00
|
|
|
void cEntity::SetRoll(double a_Roll)
|
2012-06-14 09:06:06 -04:00
|
|
|
{
|
|
|
|
m_Rot.z = a_Roll;
|
|
|
|
m_bDirtyOrientation = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-03-09 09:35:43 -05:00
|
|
|
void cEntity::SetSpeed(double a_SpeedX, double a_SpeedY, double a_SpeedZ)
|
|
|
|
{
|
2014-06-16 10:12:50 -04:00
|
|
|
DoSetSpeed(a_SpeedX, a_SpeedY, a_SpeedZ);
|
2013-03-09 09:35:43 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2018-07-26 17:24:36 -04:00
|
|
|
|
2013-03-22 02:33:10 -04:00
|
|
|
void cEntity::SetSpeedX(double a_SpeedX)
|
|
|
|
{
|
2014-06-16 10:12:50 -04:00
|
|
|
SetSpeed(a_SpeedX, m_Speed.y, m_Speed.z);
|
2013-03-22 02:33:10 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2018-07-26 17:24:36 -04:00
|
|
|
|
2013-03-22 02:33:10 -04:00
|
|
|
void cEntity::SetSpeedY(double a_SpeedY)
|
|
|
|
{
|
2014-06-16 10:12:50 -04:00
|
|
|
SetSpeed(m_Speed.x, a_SpeedY, m_Speed.z);
|
2013-03-22 02:33:10 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2018-07-26 17:24:36 -04:00
|
|
|
|
2013-03-22 02:33:10 -04:00
|
|
|
void cEntity::SetSpeedZ(double a_SpeedZ)
|
|
|
|
{
|
2014-06-16 10:12:50 -04:00
|
|
|
SetSpeed(m_Speed.x, m_Speed.y, a_SpeedZ);
|
2013-03-22 02:33:10 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-03-09 09:35:43 -05:00
|
|
|
|
2013-05-21 08:58:21 -04:00
|
|
|
|
|
|
|
void cEntity::SetWidth(double a_Width)
|
|
|
|
{
|
|
|
|
m_Width = a_Width;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2018-07-26 17:24:36 -04:00
|
|
|
|
2013-03-23 00:33:47 -04:00
|
|
|
void cEntity::AddSpeed(double a_AddSpeedX, double a_AddSpeedY, double a_AddSpeedZ)
|
|
|
|
{
|
2015-02-25 20:56:45 -05:00
|
|
|
DoSetSpeed(m_Speed.x + a_AddSpeedX, m_Speed.y + a_AddSpeedY, m_Speed.z + a_AddSpeedZ);
|
2013-03-23 00:33:47 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void cEntity::AddSpeedX(double a_AddSpeedX)
|
|
|
|
{
|
2015-02-25 20:56:45 -05:00
|
|
|
AddSpeed(a_AddSpeedX, 0, 0);
|
2013-03-23 00:33:47 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void cEntity::AddSpeedY(double a_AddSpeedY)
|
|
|
|
{
|
2015-02-25 20:56:45 -05:00
|
|
|
AddSpeed(0, a_AddSpeedY, 0);
|
2013-03-23 00:33:47 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void cEntity::AddSpeedZ(double a_AddSpeedZ)
|
2013-03-03 14:05:11 -05:00
|
|
|
{
|
2015-02-25 20:56:45 -05:00
|
|
|
AddSpeed(0, 0, a_AddSpeedZ);
|
2013-03-03 14:05:11 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-12-16 12:02:33 -05:00
|
|
|
void cEntity::HandleSpeedFromAttachee(float a_Forward, float a_Sideways)
|
|
|
|
{
|
|
|
|
Vector3d LookVector = m_Attachee->GetLookVector();
|
|
|
|
double AddSpeedX = LookVector.x * a_Forward + LookVector.z * a_Sideways;
|
|
|
|
double AddSpeedZ = LookVector.z * a_Forward - LookVector.x * a_Sideways;
|
|
|
|
SetSpeed(AddSpeedX, 0, AddSpeedZ);
|
|
|
|
BroadcastMovementUpdate();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-09-05 18:04:49 -04:00
|
|
|
void cEntity::SteerVehicle(float a_Forward, float a_Sideways)
|
|
|
|
{
|
2014-10-20 16:55:07 -04:00
|
|
|
if (m_AttachedTo == nullptr)
|
2013-09-05 18:04:49 -04:00
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
2015-03-30 19:42:32 -04:00
|
|
|
if ((a_Forward != 0.0f) || (a_Sideways != 0.0f))
|
2013-09-05 18:04:49 -04:00
|
|
|
{
|
2013-12-16 12:02:33 -05:00
|
|
|
m_AttachedTo->HandleSpeedFromAttachee(a_Forward, a_Sideways);
|
2013-09-05 18:04:49 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2016-02-07 12:07:14 -05:00
|
|
|
bool cEntity::IsTicking(void) const
|
|
|
|
{
|
|
|
|
ASSERT(!(m_IsTicking && (m_ParentChunk == nullptr))); // We shouldn't be ticking if we have no parent chunk
|
|
|
|
return m_IsTicking;
|
|
|
|
}
|
|
|
|
|
2014-07-17 16:15:34 -04:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
2012-06-14 09:06:06 -04:00
|
|
|
// Get look vector (this is NOT a rotation!)
|
2013-03-09 09:35:43 -05:00
|
|
|
Vector3d cEntity::GetLookVector(void) const
|
2012-06-14 09:06:06 -04:00
|
|
|
{
|
2013-03-09 09:35:43 -05:00
|
|
|
Matrix4d m;
|
2014-04-05 16:34:05 -04:00
|
|
|
m.Init(Vector3d(), 0, m_Rot.x, -m_Rot.y);
|
2013-03-09 09:35:43 -05:00
|
|
|
Vector3d Look = m.Transform(Vector3d(0, 0, 1));
|
2012-06-14 09:06:06 -04:00
|
|
|
return Look;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-07-17 16:15:34 -04:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
2012-06-14 09:06:06 -04:00
|
|
|
// Set position
|
2015-07-21 16:25:37 -04:00
|
|
|
void cEntity::SetPosition(const Vector3d & a_Position)
|
2012-06-14 09:06:06 -04:00
|
|
|
{
|
2020-03-20 04:31:06 -04:00
|
|
|
// Clamp the positions to exactly representable single-precision floating point values
|
|
|
|
// This is necessary to avoid rounding errors in the noise generator and overflows in the chunk loader
|
|
|
|
const double MaxFloat = std::pow(2, std::numeric_limits<float>().digits);
|
|
|
|
|
|
|
|
const double ClampedPosX = Clamp(a_Position.x, -MaxFloat, MaxFloat);
|
|
|
|
const double ClampedPosY = Clamp(a_Position.y, -MaxFloat, MaxFloat);
|
|
|
|
const double ClampedPosZ = Clamp(a_Position.z, -MaxFloat, MaxFloat);
|
|
|
|
|
2015-07-21 16:25:37 -04:00
|
|
|
m_LastPosition = m_Position;
|
2020-03-20 04:31:06 -04:00
|
|
|
m_Position = {ClampedPosX, ClampedPosY, ClampedPosZ};
|
2012-06-14 09:06:06 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2017-08-21 04:46:41 -04:00
|
|
|
|
|
|
|
void cEntity::AddLeashedMob(cMonster * a_Monster)
|
|
|
|
{
|
|
|
|
// Not there already
|
|
|
|
ASSERT(std::find(m_LeashedMobs.begin(), m_LeashedMobs.end(), a_Monster) == m_LeashedMobs.end());
|
|
|
|
|
|
|
|
m_LeashedMobs.push_back(a_Monster);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2018-07-26 17:24:36 -04:00
|
|
|
|
2017-08-21 04:46:41 -04:00
|
|
|
void cEntity::RemoveLeashedMob(cMonster * a_Monster)
|
|
|
|
{
|
|
|
|
ASSERT(a_Monster->GetLeashedTo() == this);
|
|
|
|
|
|
|
|
// Must exists
|
|
|
|
ASSERT(std::find(m_LeashedMobs.begin(), m_LeashedMobs.end(), a_Monster) != m_LeashedMobs.end());
|
|
|
|
|
|
|
|
m_LeashedMobs.remove(a_Monster);
|
|
|
|
}
|
2018-07-23 05:24:00 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-03-05 05:52:34 -05:00
|
|
|
void cEntity::RemoveAllLeashedMobs()
|
|
|
|
{
|
|
|
|
while (!m_LeashedMobs.empty())
|
|
|
|
{
|
|
|
|
m_LeashedMobs.front()->Unleash(false, true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void cEntity::BroadcastLeashedMobs()
|
|
|
|
{
|
|
|
|
// If has any mob leashed broadcast every leashed entity to this
|
|
|
|
if (HasAnyMobLeashed())
|
|
|
|
{
|
|
|
|
for (auto LeashedMob : m_LeashedMobs)
|
|
|
|
{
|
|
|
|
m_World->BroadcastLeashEntity(*LeashedMob, *this);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2018-07-23 05:24:00 -04:00
|
|
|
float cEntity::GetExplosionExposureRate(Vector3d a_ExplosionPosition, float a_ExlosionPower)
|
|
|
|
{
|
|
|
|
double EntitySize = m_Width * m_Width * m_Height;
|
|
|
|
if (EntitySize <= 0)
|
|
|
|
{
|
|
|
|
// Handle entity with invalid size
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-05-03 16:04:33 -04:00
|
|
|
auto EntityBox = GetBoundingBox();
|
2018-07-23 05:24:00 -04:00
|
|
|
cBoundingBox ExplosionBox(a_ExplosionPosition, a_ExlosionPower * 2.0);
|
|
|
|
cBoundingBox IntersectionBox(EntityBox);
|
|
|
|
|
|
|
|
bool Overlap = EntityBox.Intersect(ExplosionBox, IntersectionBox);
|
|
|
|
if (Overlap)
|
|
|
|
{
|
|
|
|
Vector3d Diff = IntersectionBox.GetMax() - IntersectionBox.GetMin();
|
|
|
|
double OverlapSize = Diff.x * Diff.y * Diff.z;
|
|
|
|
|
|
|
|
return static_cast<float>(OverlapSize / EntitySize);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|