summaryrefslogblamecommitdiffstats
path: root/src/Entities/Pickup.cpp
blob: 4f7462a1f65a55a4a46f3041d3294af35d65083e (plain) (tree)
1
2
3
4
5
6
7
8
9






                                                                                              
                   
                   
                             
                            
                     
                      
                                      
                                


                     


 
                              


                                                                           
                                             
                                       
                                  


         
                                             
         

                                                                                                                          



                                     
 
                                                            

                                                                    


                                                                                                      
                 

                                                                                                                                              


                                                                                                        





                                              
                                                                                       


                                                         
                         
                                                                                                                                      
                                                   


                                                    
                         

                            
                                                                                       
                         



















                                                     
 



                                                                                                                                       
                                             





                                              
 
                           
                          

                        
                          
 




 
                                               
 

                                           





 
                                                                    
 
                                   




                                                   
                                                                 
 
                        
 

                          



                                        
                                                                                                                                  
                 
                                                                                                                         
                                                                                   
 

                                                               

                                                    


                                                                                                            
                                 
                                                  
                                               
                                 
                         
 
                                                                                     
                                                                                                                                                               
                         


                                                                                                                                         
                                                                                                      
                                                                               
                                                                                  
                                 
                                                                                
                                 



                         
         
                                                                            
                 
                                  



                               
                                 
         
                          

                       





 



                                                  
                          


                            
                                          





 
                                           
 

                         
                                                                                                                                                 
                                                         
         
 





                                                 
                                                                                              
                                                                                                      
         
                                                                                                                                        
                                                
         
 

                                                 
         
 




























                                                                                                                                                                        

                                   
         



                                                                           
                 
                                     

                 




                                                                                                                                                
 
                                                                      
                                 
                 





















                                                                                                                                                                
                 

         
                                                                                                                                             

                     

#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules

#ifndef _WIN32
#include <cstdlib>
#endif

#include "Pickup.h"
#include "Player.h"
#include "../Mobs/Villager.h"
#include "../ClientHandle.h"
#include "../World.h"
#include "../Server.h"
#include "../Bindings/PluginManager.h"
#include "../Registries/Items.h"
#include "../Root.h"
#include "../Chunk.h"




class cPickupCombiningCallback
{
public:
	cPickupCombiningCallback(Vector3d a_Position, cPickup * a_Pickup) :
		m_FoundMatchingPickup(false),
		m_Position(a_Position),
		m_Pickup(a_Pickup)
	{
	}

	bool operator () (cEntity & a_Entity)
	{
		ASSERT(a_Entity.IsTicking());
		if (!a_Entity.IsPickup() || (a_Entity.GetUniqueID() <= m_Pickup->GetUniqueID()) || !a_Entity.IsOnGround())
		{
			return false;
		}


		Vector3d EntityPos = a_Entity.GetPosition();
		double Distance = (EntityPos - m_Position).Length();

		auto & OtherPickup = static_cast<cPickup &>(a_Entity);
		cItem & Item = OtherPickup.GetItem();
		if ((Distance < 1.2) && Item.IsEqual(m_Pickup->GetItem()) && OtherPickup.CanCombine())
		{
			short CombineCount = static_cast<short>(Item.m_ItemCount);
			if ((CombineCount + static_cast<short>(m_Pickup->GetItem().m_ItemCount)) > static_cast<short>(Item.GetMaxStackSize()))
			{
				CombineCount = Item.GetMaxStackSize() - m_Pickup->GetItem().m_ItemCount;
			}

			if (CombineCount <= 0)
			{
				return false;
			}

			m_Pickup->GetItem().AddCount(static_cast<short>(CombineCount));
			Item.m_ItemCount -= CombineCount;

			if (Item.m_ItemCount <= 0)
			{
				a_Entity.GetWorld()->BroadcastCollectEntity(a_Entity, *m_Pickup, static_cast<unsigned>(CombineCount));
				a_Entity.Destroy();

				// Reset the timer
				m_Pickup->SetAge(0);
			}
			else
			{
				a_Entity.GetWorld()->BroadcastEntityMetadata(a_Entity);
			}
			m_FoundMatchingPickup = true;
		}
		return false;
	}

	inline bool FoundMatchingPickup()
	{
		return m_FoundMatchingPickup;
	}

protected:
	bool m_FoundMatchingPickup;

	Vector3d m_Position;
	cPickup * m_Pickup;
};





////////////////////////////////////////////////////////////////////////////////
// cPickup:

cPickup::cPickup(Vector3d a_Pos, const cItem & a_Item, bool IsPlayerCreated, Vector3f a_Speed, int a_LifetimeTicks, bool a_CanCombine):
	Super(etPickup, a_Pos, 0.25f, 0.25f),
	m_Timer(0),
	m_Item(a_Item),
	m_bCollected(false),
	m_bIsPlayerCreated(IsPlayerCreated),
	m_bCanCombine(a_CanCombine),
	m_Lifetime(cTickTime(a_LifetimeTicks))
{
	SetGravity(-16.0f);
	SetAirDrag(0.02f);
	SetMaxHealth(5);
	SetHealth(5);
	SetSpeed(a_Speed);
}





void cPickup::SpawnOn(cClientHandle & a_Client)
{
	a_Client.SendSpawnEntity(*this);
	a_Client.SendEntityMetadata(*this);
}





void cPickup::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk)
{
	Super::Tick(a_Dt, a_Chunk);
	if (!IsTicking())
	{
		// The base class tick destroyed us
		return;
	}
	BroadcastMovementUpdate();  // Notify clients of position

	m_Timer += a_Dt;

	if (!m_bCollected)
	{
		int BlockY = POSY_TOINT;
		int BlockX = POSX_TOINT;
		int BlockZ = POSZ_TOINT;

		if ((BlockY >= 0) && (BlockY < cChunkDef::Height))  // Don't do anything except for falling when outside the world
		{
			// Position might have changed due to physics. So we have to make sure we have the correct chunk.
			GET_AND_VERIFY_CURRENT_CHUNK(CurrentChunk, BlockX, BlockZ);

			// Destroy the pickup if it is on fire:
			if (IsOnFire())
			{
				m_bCollected = true;
				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))
				{
					Destroy();
					return;
				}
			}

			// Try to combine the pickup with adjacent same-item pickups:
			if ((m_Item.m_ItemCount < m_Item.GetMaxStackSize()) && IsOnGround() && CanCombine())  // Don't combine if already full or not on ground
			{
				// 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.
				cPickupCombiningCallback PickupCombiningCallback(GetPosition(), this);
				a_Chunk.ForEachEntity(PickupCombiningCallback);
				if (PickupCombiningCallback.FoundMatchingPickup())
				{
					m_World->BroadcastEntityMetadata(*this);
				}
			}
		}
	}
	else
	{
		if (m_Timer > std::chrono::milliseconds(500))  // 0.5 second
		{
			Destroy();
			return;
		}
	}

	if (m_Timer > m_Lifetime)
	{
		Destroy();
		return;
	}
}





bool cPickup::DoTakeDamage(TakeDamageInfo & a_TDI)
{
	if (a_TDI.DamageType == dtCactusContact)
	{
		Destroy();
		return true;
	}

	return Super::DoTakeDamage(a_TDI);
}





bool cPickup::CollectedBy(cEntity & a_Dest)
{
	if (m_bCollected)
	{
		// LOG("Pickup %d cannot be collected by \"%s\", because it has already been collected.", m_UniqueID, a_Dest->GetName().c_str());
		return false;  // It's already collected!
	}

	// This type of entity can't pickup items
	if (!a_Dest.IsPawn())
	{
		return false;
	}

	// Two seconds if player created the pickup (vomiting), half a second if anything else
	if (m_Timer < (m_bIsPlayerCreated ? std::chrono::seconds(2) : std::chrono::milliseconds(500)))
	{
		// LOG("Pickup %d cannot be collected by \"%s\", because it is not old enough.", m_UniqueID, a_Dest->GetName().c_str());
		return false;  // Not old enough
	}

	// Checking for villagers
	if (!a_Dest.IsPlayer() && a_Dest.IsMob())
	{

		auto & Mob = static_cast<cMonster &>(a_Dest);
		if (Mob.GetMobType() == mtVillager)
		{
			// Villagers only pickup food
			if (!ItemCategory::IsVillagerFood(m_Item.m_ItemType))
			{
				return false;
			}

			auto & Villager = static_cast<cVillager &>(Mob);
			int NumAdded = Villager.GetInventory().AddItem(m_Item);
			if (NumAdded > 0)
			{
				m_Item.m_ItemCount -= NumAdded;
				m_World->BroadcastCollectEntity(*this, a_Dest, static_cast<unsigned>(NumAdded));

				// Also send the "pop" sound effect with a somewhat random pitch (fast-random using EntityID ;)
				m_World->BroadcastSoundEffect("entity.item.pickup", GetPosition(), 0.3f, (1.2f + (static_cast<float>((GetUniqueID() * 23) % 32)) / 64));
				if (m_Item.m_ItemCount <= 0)
				{
					// All of the pickup has been collected, schedule the pickup for destroying
					m_bCollected = true;
				}
				m_Timer = std::chrono::milliseconds(0);
				return true;
			}
			// Pickup cannot be collected because the entity has not enough space
			return false;
		}
	}
	else if (a_Dest.IsPlayer())
	{
		auto & Player = static_cast<cPlayer &>(a_Dest);

		// If the player is a spectator, he cannot collect anything
		if (Player.IsGameModeSpectator())
		{
			return false;
		}

		if (cRoot::Get()->GetPluginManager()->CallHookCollectingPickup(Player, *this))
		{
			// LOG("Pickup %d cannot be collected by \"%s\", because a plugin has said no.", m_UniqueID, a_Dest->GetName().c_str());
			return false;
		}

		char NumAdded = Player.GetInventory().AddItem(m_Item);
		if (NumAdded > 0)
		{
			// Check achievements
			switch (m_Item.m_ItemType)
			{
				case E_BLOCK_LOG:      Player.AwardAchievement(CustomStatistic::AchMineWood); break;
				case E_ITEM_LEATHER:   Player.AwardAchievement(CustomStatistic::AchKillCow);  break;
				case E_ITEM_DIAMOND:   Player.AwardAchievement(CustomStatistic::AchDiamonds); break;
				case E_ITEM_BLAZE_ROD: Player.AwardAchievement(CustomStatistic::AchBlazeRod); break;
				default: break;
			}

			m_Item.m_ItemCount -= NumAdded;
			m_World->BroadcastCollectEntity(*this, a_Dest, static_cast<unsigned>(NumAdded));

			// Also send the "pop" sound effect with a somewhat random pitch (fast-random using EntityID ;)
			m_World->BroadcastSoundEffect("entity.item.pickup", GetPosition(), 0.3f, (1.2f + (static_cast<float>((GetUniqueID() * 23) % 32)) / 64));
			if (m_Item.m_ItemCount <= 0)
			{
				// All of the pickup has been collected, schedule the pickup for destroying
				m_bCollected = true;
			}
			m_Timer = std::chrono::milliseconds(0);
			return true;
		}
	}

	// LOG("Pickup %d cannot be collected by \"%s\", because there's no space in the inventory.", a_Dest->GetName().c_str(), m_UniqueID);
	return false;
}