ryansnewell
/
mcserver
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

You are now able to sweep mobs to your position using fishing rods.

master
STRWarrior 2013-12-25 17:26:17 +01:00
parent 9e5e415674
commit 17a84111ce
3 changed files with 210 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

143
src/Entities/Floater.cpp
View File

@ -1,6 +1,8 @@
#include "Globals.h"
#include "../BoundingBox.h"
#include "../Chunk.h"
#include "Floater.h"
#include "Player.h"
#include "../ClientHandle.h"
@ -9,12 +11,103 @@
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
// cFloaterEntityCollisionCallback
class cFloaterEntityCollisionCallback :
public cEntityCallback
{
public:
cFloaterEntityCollisionCallback(cFloater * a_Floater, const Vector3d & a_Pos, const Vector3d & a_NextPos) :
m_Floater(a_Floater),
m_Pos(a_Pos),
m_NextPos(a_NextPos),
m_MinCoeff(1),
m_HitEntity(NULL)
{
}
virtual bool Item(cEntity * a_Entity) override
{
if (!a_Entity->IsMob()) // Floaters can only pull mobs not other entities.
{
return false;
}
cBoundingBox EntBox(a_Entity->GetPosition(), a_Entity->GetWidth() / 2, a_Entity->GetHeight());
double LineCoeff;
char Face;
EntBox.Expand(m_Floater->GetWidth() / 2, m_Floater->GetHeight() / 2, m_Floater->GetWidth() / 2);
if (!EntBox.CalcLineIntersection(m_Pos, m_NextPos, LineCoeff, Face))
{
// No intersection whatsoever
return false;
}
if (LineCoeff < m_MinCoeff)
{
// The entity is closer than anything we've stored so far, replace it as the potential victim
m_MinCoeff = LineCoeff;
m_HitEntity = a_Entity;
}
// Don't break the enumeration, we want all the entities
return false;
}
/// Returns the nearest entity that was hit, after the enumeration has been completed
cEntity * GetHitEntity(void) const { return m_HitEntity; }
/// Returns true if the callback has encountered a true hit
bool HasHit(void) const { return (m_MinCoeff < 1); }
protected:
cFloater * m_Floater;
const Vector3d & m_Pos;
const Vector3d & m_NextPos;
double m_MinCoeff; // The coefficient of the nearest hit on the Pos line
// Although it's bad(tm) to store entity ptrs from a callback, we can afford it here, because the entire callback
// is processed inside the tick thread, so the entities won't be removed in between the calls and the final processing
cEntity * m_HitEntity; // The nearest hit entity
} ;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
// cFloaterCheckEntityExist
class cFloaterCheckEntityExist :
public cEntityCallback
{
public:
cFloaterCheckEntityExist(void) :
m_EntityExists(false)
{
}
bool Item(cEntity * a_Entity) override
{
m_EntityExists = true;
return false;
}
bool DoesExist(void) const { return m_EntityExists; }
protected:
bool m_EntityExists;
} ;
cFloater::cFloater(double a_X, double a_Y, double a_Z, Vector3d a_Speed, int a_PlayerID, int a_CountDownTime) :
cEntity(etFloater, a_X, a_Y, a_Z, 0.98, 0.98),
cEntity(etFloater, a_X, a_Y, a_Z, 0.2, 0.2),
m_PickupCountDown(0),
m_PlayerID(a_PlayerID),
m_CanPickupItem(false),
m_CountDownTime(a_CountDownTime)
m_CountDownTime(a_CountDownTime),
m_AttachedMobID(-1)
{
SetSpeed(a_Speed);
}
@ -37,7 +130,7 @@ void cFloater::Tick(float a_Dt, cChunk & a_Chunk)
HandlePhysics(a_Dt, a_Chunk);
if (IsBlockWater(m_World->GetBlock((int) GetPosX(), (int) GetPosY(), (int) GetPosZ())) && m_World->GetBlockMeta((int) GetPosX(), (int) GetPosY(), (int) GetPosZ()) == 0)
{
if (!m_CanPickupItem)
if (!m_CanPickupItem && m_AttachedMobID == -1) // Check if you can't already pickup a fish and if the floater isn't attached to a mob.
{
if (m_CountDownTime <= 0)
{
@ -78,9 +171,8 @@ void cFloater::Tick(float a_Dt, cChunk & a_Chunk)
}
SetSpeedY(0.7);
}
SetSpeedX(GetSpeedX() * 0.95);
SetSpeedZ(GetSpeedZ() * 0.95);
if (CanPickup())
if (CanPickup()) // Make sure the floater "loses its fish"
{
m_PickupCountDown--;
if (m_PickupCountDown == 0)
@ -89,9 +181,38 @@ void cFloater::Tick(float a_Dt, cChunk & a_Chunk)
LOGD("The fish is gone. Floater %i can not pick an item up.", GetUniqueID());
}
}
if (GetSpeed().Length() > 4 && m_AttachedMobID == -1)
{
cFloaterEntityCollisionCallback Callback(this, GetPosition(), GetPosition() + GetSpeed() / 20);
a_Chunk.ForEachEntity(Callback);
if (Callback.HasHit())
{
AttachTo(Callback.GetHitEntity());
Callback.GetHitEntity()->TakeDamage(*this); // TODO: the player attacked the mob not the floater.
m_AttachedMobID = Callback.GetHitEntity()->GetUniqueID();
}
}
cFloaterCheckEntityExist EntityCallback;
m_World->DoWithEntityByID(m_PlayerID, EntityCallback);
if (!EntityCallback.DoesExist()) // The owner doesn't exist anymore. Destroy the floater entity.
{
Destroy(true);
}
if (m_AttachedMobID != -1)
{
m_World->DoWithEntityByID(m_AttachedMobID, EntityCallback); // The mob the floater was attached to doesn't exist anymore.
if (!EntityCallback.DoesExist())
{
m_AttachedMobID = -1;
}
}
SetSpeedX(GetSpeedX() * 0.95);
SetSpeedZ(GetSpeedZ() * 0.95);
BroadcastMovementUpdate();
}
}

19
src/Entities/Floater.h
View File

@ -19,13 +19,22 @@ public:
virtual void SpawnOn(cClientHandle & a_Client) override;
virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
bool CanPickup(void) const { return m_CanPickupItem; }
bool CanPickup(void) const { return m_CanPickupItem; }
int GetOwnerID(void) const { return m_PlayerID; }
int GetAttachedMobID(void) const { return m_AttachedMobID; }
protected:
Vector3d m_Speed;
// Position
Vector3d m_ParticlePos;
int m_PickupCountDown;
int m_PlayerID;
int m_CountDownTime;
// Bool needed to check if you can get a fish.
bool m_CanPickupItem;
// Countdown times
int m_PickupCountDown;
int m_CountDownTime;
// Entity IDs
int m_PlayerID;
int m_AttachedMobID;
} ;

90
src/Items/ItemFishingRod.h
View File

@ -15,6 +15,61 @@
/////////////////////////////////////////////////////////////////////////////////////
// cFloaterCallback
class cFloaterCallback :
public cEntityCallback
{
public:
cFloaterCallback(void) :
m_CanPickup(false),
m_AttachedMobID(-1)
{
}
virtual bool Item(cEntity * a_Entity) override
{
m_CanPickup = ((cFloater *)a_Entity)->CanPickup();
m_Pos = Vector3d(a_Entity->GetPosX(), a_Entity->GetPosY(), a_Entity->GetPosZ());
m_AttachedMobID = ((cFloater *)a_Entity)->GetAttachedMobID();
a_Entity->Destroy(true);
return true;
}
bool CanPickup(void) const { return m_CanPickup; }
bool IsAttached(void) const { return (m_AttachedMobID != -1); }
int GetAttachedMobID(void) const { return m_AttachedMobID; }
Vector3d GetPos(void) const { return m_Pos; }
protected:
bool m_CanPickup;
int m_AttachedMobID;
Vector3d m_Pos;
} ;
////////////////////////////////////////////////////////////////////////////
// cSweepEntityCallback
class cSweepEntityCallback :
public cEntityCallback
{
public:
cSweepEntityCallback(Vector3d a_PlayerPos) :
m_PlayerPos(a_PlayerPos)
{
}
virtual bool Item(cEntity * a_Entity) override
{
Vector3d Speed = m_PlayerPos - a_Entity->GetPosition();
a_Entity->AddSpeed(Speed);
return true;
}
protected:
Vector3d m_PlayerPos;
} ;
class cItemFishingRodHandler :
public cItemHandler
@ -36,33 +91,16 @@ public:
if (a_Player->IsFishing())
{
class cFloaterCallback :
public cEntityCallback
{
public:
cFloaterCallback(void) :
m_CanPickup(false)
{
}
bool CanPickup(void) const { return m_CanPickup; }
Vector3d GetPos(void) const { return m_Pos; }
virtual bool Item(cEntity * a_Entity) override
{
m_CanPickup = ((cFloater *)a_Entity)->CanPickup();
m_Pos = Vector3d(a_Entity->GetPosX(), a_Entity->GetPosY(), a_Entity->GetPosZ());
a_Entity->Destroy(true);
return true;
}
protected:
bool m_CanPickup;
Vector3d m_Pos;
} Callbacks;
a_World->DoWithEntityByID(a_Player->GetFloaterID(), Callbacks);
cFloaterCallback FloaterInfo;
a_World->DoWithEntityByID(a_Player->GetFloaterID(), FloaterInfo);
a_Player->SetIsFishing(false);
if (Callbacks.CanPickup())
if (FloaterInfo.IsAttached())
{
cSweepEntityCallback SweepEntity(a_Player->GetPosition());
a_World->DoWithEntityByID(FloaterInfo.GetAttachedMobID(), SweepEntity);
}
else if (FloaterInfo.CanPickup())
{
cItems Drops;
int ItemCategory = a_World->GetTickRandomNumber(99);
@ -173,7 +211,7 @@ public:
}
Vector3d FloaterPos = Callbacks.GetPos();
Vector3d FloaterPos = FloaterInfo.GetPos();
Vector3d FlyDirection = a_Player->GetEyePosition() - FloaterPos;
a_World->SpawnItemPickups(Drops, FloaterPos.x, FloaterPos.y, FloaterPos.z, FlyDirection.x, FlyDirection.y + 1, FlyDirection.z);
}