2012-06-14 13:06:06 +00:00
|
|
|
|
|
|
|
#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules
|
|
|
|
|
|
|
|
#ifndef _WIN32
|
|
|
|
#include <cstdlib>
|
|
|
|
#endif
|
|
|
|
|
2012-09-23 22:09:57 +00:00
|
|
|
#include "Pickup.h"
|
2014-01-24 21:55:04 +00:00
|
|
|
#include "Player.h"
|
2013-08-19 09:39:13 +00:00
|
|
|
#include "../ClientHandle.h"
|
|
|
|
#include "../World.h"
|
|
|
|
#include "../Server.h"
|
2013-12-08 11:17:54 +00:00
|
|
|
#include "../Bindings/PluginManager.h"
|
2013-08-19 09:39:13 +00:00
|
|
|
#include "../Root.h"
|
|
|
|
#include "../Chunk.h"
|
|
|
|
|
2012-06-14 13:06:06 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
2017-09-11 21:20:49 +00:00
|
|
|
class cPickupCombiningCallback
|
2014-01-25 15:19:56 +00:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
cPickupCombiningCallback(Vector3d a_Position, cPickup * a_Pickup) :
|
2014-02-05 17:43:49 +00:00
|
|
|
m_FoundMatchingPickup(false),
|
2014-01-25 15:19:56 +00:00
|
|
|
m_Position(a_Position),
|
2014-02-05 17:43:49 +00:00
|
|
|
m_Pickup(a_Pickup)
|
2014-01-25 15:19:56 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2017-09-11 21:20:49 +00:00
|
|
|
bool operator () (cEntity & a_Entity)
|
2014-01-25 15:19:56 +00:00
|
|
|
{
|
2017-09-11 21:20:49 +00:00
|
|
|
ASSERT(a_Entity.IsTicking());
|
|
|
|
if (!a_Entity.IsPickup() || (a_Entity.GetUniqueID() <= m_Pickup->GetUniqueID()) || !a_Entity.IsOnGround())
|
2014-01-25 15:19:56 +00:00
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-02-07 17:07:14 +00:00
|
|
|
|
2017-09-11 21:20:49 +00:00
|
|
|
Vector3d EntityPos = a_Entity.GetPosition();
|
2014-01-25 15:19:56 +00:00
|
|
|
double Distance = (EntityPos - m_Position).Length();
|
|
|
|
|
2017-09-11 21:20:49 +00:00
|
|
|
auto & OtherPickup = static_cast<cPickup &>(a_Entity);
|
|
|
|
cItem & Item = OtherPickup.GetItem();
|
|
|
|
if ((Distance < 1.2) && Item.IsEqual(m_Pickup->GetItem()) && OtherPickup.CanCombine())
|
2014-01-25 15:19:56 +00:00
|
|
|
{
|
2014-06-26 15:20:48 +00:00
|
|
|
short CombineCount = Item.m_ItemCount;
|
2014-06-24 14:19:22 +00:00
|
|
|
if ((CombineCount + m_Pickup->GetItem().m_ItemCount) > Item.GetMaxStackSize())
|
|
|
|
{
|
|
|
|
CombineCount = Item.GetMaxStackSize() - m_Pickup->GetItem().m_ItemCount;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (CombineCount <= 0)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-05-24 11:56:56 +00:00
|
|
|
m_Pickup->GetItem().AddCount(static_cast<char>(CombineCount));
|
2014-06-24 14:19:22 +00:00
|
|
|
Item.m_ItemCount -= CombineCount;
|
|
|
|
|
|
|
|
if (Item.m_ItemCount <= 0)
|
2014-06-24 13:27:19 +00:00
|
|
|
{
|
2020-05-04 08:10:47 +00:00
|
|
|
a_Entity.GetWorld()->BroadcastCollectEntity(a_Entity, *m_Pickup, static_cast<unsigned>(CombineCount));
|
2017-09-11 21:20:49 +00:00
|
|
|
a_Entity.Destroy();
|
2017-07-12 10:13:27 +00:00
|
|
|
|
|
|
|
// Reset the timer
|
|
|
|
m_Pickup->SetAge(0);
|
2014-06-24 13:27:19 +00:00
|
|
|
}
|
2014-06-24 14:19:22 +00:00
|
|
|
else
|
|
|
|
{
|
2017-09-11 21:20:49 +00:00
|
|
|
a_Entity.GetWorld()->BroadcastEntityMetadata(a_Entity);
|
2014-06-24 14:19:22 +00:00
|
|
|
}
|
2014-01-25 15:19:56 +00:00
|
|
|
m_FoundMatchingPickup = true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool FoundMatchingPickup()
|
|
|
|
{
|
|
|
|
return m_FoundMatchingPickup;
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
bool m_FoundMatchingPickup;
|
|
|
|
|
|
|
|
Vector3d m_Position;
|
|
|
|
cPickup * m_Pickup;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2012-06-14 13:06:06 +00:00
|
|
|
|
2019-09-29 12:59:24 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// cPickup:
|
|
|
|
|
|
|
|
cPickup::cPickup(Vector3d a_Pos, const cItem & a_Item, bool IsPlayerCreated, Vector3f a_Speed, int a_LifetimeTicks, bool a_CanCombine):
|
2021-04-06 15:09:16 +00:00
|
|
|
Super(etPickup, a_Pos, 0.25f, 0.25f),
|
2019-09-29 12:59:24 +00:00
|
|
|
m_Timer(0),
|
|
|
|
m_Item(a_Item),
|
|
|
|
m_bCollected(false),
|
|
|
|
m_bIsPlayerCreated(IsPlayerCreated),
|
|
|
|
m_bCanCombine(a_CanCombine),
|
|
|
|
m_Lifetime(cTickTime(a_LifetimeTicks))
|
2012-06-14 13:06:06 +00:00
|
|
|
{
|
2015-03-30 23:42:32 +00:00
|
|
|
SetGravity(-16.0f);
|
2015-03-31 15:40:31 +00:00
|
|
|
SetAirDrag(0.02f);
|
2013-11-10 22:20:25 +00:00
|
|
|
SetMaxHealth(5);
|
|
|
|
SetHealth(5);
|
2019-09-29 12:59:24 +00:00
|
|
|
SetSpeed(a_Speed);
|
2012-06-14 13:06:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2012-08-24 07:58:26 +00:00
|
|
|
void cPickup::SpawnOn(cClientHandle & a_Client)
|
2012-06-14 13:06:06 +00:00
|
|
|
{
|
2020-04-20 19:46:04 +00:00
|
|
|
a_Client.SendSpawnEntity(*this);
|
|
|
|
a_Client.SendEntityMetadata(*this);
|
2012-06-14 13:06:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2015-01-11 21:12:26 +00:00
|
|
|
void cPickup::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk)
|
2012-06-14 13:06:06 +00:00
|
|
|
{
|
2020-04-13 16:38:06 +00:00
|
|
|
Super::Tick(a_Dt, a_Chunk);
|
2016-09-03 11:31:27 +00:00
|
|
|
if (!IsTicking())
|
|
|
|
{
|
|
|
|
// The base class tick destroyed us
|
|
|
|
return;
|
|
|
|
}
|
2014-07-17 20:15:34 +00:00
|
|
|
BroadcastMovementUpdate(); // Notify clients of position
|
2013-04-22 07:18:03 +00:00
|
|
|
|
2015-01-16 13:49:22 +00:00
|
|
|
m_Timer += a_Dt;
|
2016-02-05 21:45:45 +00:00
|
|
|
|
2013-04-22 07:18:03 +00:00
|
|
|
if (!m_bCollected)
|
|
|
|
{
|
2014-04-12 12:16:48 +00:00
|
|
|
int BlockY = POSY_TOINT;
|
|
|
|
int BlockX = POSX_TOINT;
|
|
|
|
int BlockZ = POSZ_TOINT;
|
|
|
|
|
2013-08-24 19:34:42 +00:00
|
|
|
if ((BlockY >= 0) && (BlockY < cChunkDef::Height)) // Don't do anything except for falling when outside the world
|
2013-04-22 07:18:03 +00:00
|
|
|
{
|
2013-08-24 19:34:42 +00:00
|
|
|
// Position might have changed due to physics. So we have to make sure we have the correct chunk.
|
2019-08-11 09:39:43 +00:00
|
|
|
GET_AND_VERIFY_CURRENT_CHUNK(CurrentChunk, BlockX, BlockZ);
|
2016-02-05 21:45:45 +00:00
|
|
|
|
2018-01-14 18:44:45 +00:00
|
|
|
// Destroy the pickup if it is on fire:
|
|
|
|
if (IsOnFire())
|
2014-04-12 12:16:48 +00:00
|
|
|
{
|
|
|
|
m_bCollected = true;
|
2015-01-16 13:49:22 +00:00
|
|
|
m_Timer = std::chrono::milliseconds(0); // We have to reset the timer.
|
|
|
|
m_Timer += a_Dt; // In case we have to destroy the pickup in the same tick.
|
|
|
|
if (m_Timer > std::chrono::milliseconds(500))
|
2013-04-28 15:30:06 +00:00
|
|
|
{
|
2020-03-05 10:52:34 +00:00
|
|
|
Destroy();
|
2014-04-12 12:16:48 +00:00
|
|
|
return;
|
2013-04-28 15:30:06 +00:00
|
|
|
}
|
2014-04-12 12:16:48 +00:00
|
|
|
}
|
2014-01-25 15:19:56 +00:00
|
|
|
|
2014-09-01 19:43:03 +00:00
|
|
|
// Try to combine the pickup with adjacent same-item pickups:
|
2017-07-12 10:13:27 +00:00
|
|
|
if ((m_Item.m_ItemCount < m_Item.GetMaxStackSize()) && IsOnGround() && CanCombine()) // Don't combine if already full or not on ground
|
2014-04-12 12:16:48 +00:00
|
|
|
{
|
2014-09-01 19:43:03 +00:00
|
|
|
// By using a_Chunk's ForEachEntity() instead of cWorld's, pickups don't combine across chunk boundaries.
|
|
|
|
// That is a small price to pay for not having to traverse the entire world for each entity.
|
|
|
|
// The speedup in the tick thread is quite considerable.
|
2014-04-12 12:16:48 +00:00
|
|
|
cPickupCombiningCallback PickupCombiningCallback(GetPosition(), this);
|
2014-09-01 19:43:03 +00:00
|
|
|
a_Chunk.ForEachEntity(PickupCombiningCallback);
|
2014-04-12 12:16:48 +00:00
|
|
|
if (PickupCombiningCallback.FoundMatchingPickup())
|
2014-01-25 15:19:56 +00:00
|
|
|
{
|
2014-04-12 12:16:48 +00:00
|
|
|
m_World->BroadcastEntityMetadata(*this);
|
2014-01-25 15:19:56 +00:00
|
|
|
}
|
2013-04-22 07:18:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
2012-06-14 13:06:06 +00:00
|
|
|
{
|
2015-01-16 13:49:22 +00:00
|
|
|
if (m_Timer > std::chrono::milliseconds(500)) // 0.5 second
|
2012-06-14 13:06:06 +00:00
|
|
|
{
|
2020-03-05 10:52:34 +00:00
|
|
|
Destroy();
|
2012-06-14 13:06:06 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-12 10:13:27 +00:00
|
|
|
if (m_Timer > m_Lifetime)
|
2012-06-14 13:06:06 +00:00
|
|
|
{
|
2020-03-05 10:52:34 +00:00
|
|
|
Destroy();
|
2012-06-14 13:06:06 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2018-01-16 19:13:17 +00:00
|
|
|
bool cPickup::DoTakeDamage(TakeDamageInfo & a_TDI)
|
|
|
|
{
|
|
|
|
if (a_TDI.DamageType == dtCactusContact)
|
|
|
|
{
|
2020-03-05 10:52:34 +00:00
|
|
|
Destroy();
|
2018-01-16 19:13:17 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2020-04-13 16:38:06 +00:00
|
|
|
return Super::DoTakeDamage(a_TDI);
|
2018-01-16 19:13:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-10-15 17:01:55 +00:00
|
|
|
bool cPickup::CollectedBy(cPlayer & a_Dest)
|
2012-06-14 13:06:06 +00:00
|
|
|
{
|
2012-08-24 09:49:00 +00:00
|
|
|
if (m_bCollected)
|
|
|
|
{
|
2013-05-17 14:30:18 +00:00
|
|
|
// LOG("Pickup %d cannot be collected by \"%s\", because it has already been collected.", m_UniqueID, a_Dest->GetName().c_str());
|
2014-07-17 20:15:34 +00:00
|
|
|
return false; // It's already collected!
|
2012-08-24 09:49:00 +00:00
|
|
|
}
|
2016-02-05 21:45:45 +00:00
|
|
|
|
2013-10-23 23:30:20 +00:00
|
|
|
// Two seconds if player created the pickup (vomiting), half a second if anything else
|
2015-01-16 13:49:22 +00:00
|
|
|
if (m_Timer < (m_bIsPlayerCreated ? std::chrono::seconds(2) : std::chrono::milliseconds(500)))
|
2012-08-24 09:49:00 +00:00
|
|
|
{
|
2013-05-17 14:30:18 +00:00
|
|
|
// LOG("Pickup %d cannot be collected by \"%s\", because it is not old enough.", m_UniqueID, a_Dest->GetName().c_str());
|
2014-07-17 20:15:34 +00:00
|
|
|
return false; // Not old enough
|
2012-08-24 09:49:00 +00:00
|
|
|
}
|
2012-06-14 13:06:06 +00:00
|
|
|
|
2016-10-12 12:38:45 +00:00
|
|
|
// If the player is a spectator, he cannot collect anything
|
|
|
|
if (a_Dest.IsGameModeSpectator())
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-01-28 16:17:26 +00:00
|
|
|
if (cRoot::Get()->GetPluginManager()->CallHookCollectingPickup(a_Dest, *this))
|
2012-08-24 09:49:00 +00:00
|
|
|
{
|
2013-05-17 14:30:18 +00:00
|
|
|
// LOG("Pickup %d cannot be collected by \"%s\", because a plugin has said no.", m_UniqueID, a_Dest->GetName().c_str());
|
2012-08-24 09:49:00 +00:00
|
|
|
return false;
|
|
|
|
}
|
2012-06-14 13:06:06 +00:00
|
|
|
|
2014-10-15 17:01:55 +00:00
|
|
|
int NumAdded = a_Dest.GetInventory().AddItem(m_Item);
|
2013-05-24 07:30:39 +00:00
|
|
|
if (NumAdded > 0)
|
2012-06-14 13:06:06 +00:00
|
|
|
{
|
2014-05-12 14:05:09 +00:00
|
|
|
// Check achievements
|
|
|
|
switch (m_Item.m_ItemType)
|
|
|
|
{
|
2021-05-03 20:07:09 +00:00
|
|
|
case E_BLOCK_LOG: a_Dest.AwardAchievement(CustomStatistic::AchMineWood); break;
|
|
|
|
case E_ITEM_LEATHER: a_Dest.AwardAchievement(CustomStatistic::AchKillCow); break;
|
|
|
|
case E_ITEM_DIAMOND: a_Dest.AwardAchievement(CustomStatistic::AchDiamonds); break;
|
|
|
|
case E_ITEM_BLAZE_ROD: a_Dest.AwardAchievement(CustomStatistic::AchBlazeRod); break;
|
2014-05-12 14:05:09 +00:00
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
|
2013-05-24 07:30:39 +00:00
|
|
|
m_Item.m_ItemCount -= NumAdded;
|
2020-05-04 08:10:47 +00:00
|
|
|
m_World->BroadcastCollectEntity(*this, a_Dest, static_cast<unsigned>(NumAdded));
|
2015-05-18 13:30:16 +00:00
|
|
|
|
2013-11-10 20:48:12 +00:00
|
|
|
// Also send the "pop" sound effect with a somewhat random pitch (fast-random using EntityID ;)
|
2020-04-03 15:49:12 +00:00
|
|
|
m_World->BroadcastSoundEffect("entity.item.pickup", GetPosition(), 0.3f, (1.2f + (static_cast<float>((GetUniqueID() * 23) % 32)) / 64));
|
2014-06-24 15:50:38 +00:00
|
|
|
if (m_Item.m_ItemCount <= 0)
|
2012-12-22 10:15:53 +00:00
|
|
|
{
|
2013-05-24 07:30:39 +00:00
|
|
|
// All of the pickup has been collected, schedule the pickup for destroying
|
|
|
|
m_bCollected = true;
|
2012-10-24 12:48:25 +00:00
|
|
|
}
|
2015-01-16 13:49:22 +00:00
|
|
|
m_Timer = std::chrono::milliseconds(0);
|
2012-06-14 13:06:06 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-05-17 14:30:18 +00:00
|
|
|
// LOG("Pickup %d cannot be collected by \"%s\", because there's no space in the inventory.", a_Dest->GetName().c_str(), m_UniqueID);
|
2012-06-14 13:06:06 +00:00
|
|
|
return false;
|
|
|
|
}
|