Object Class Reference

#include <Object.h>

Public Member Functions
virtual	~Object ()
bool	IsInWorld () const
virtual void	AddToWorld ()
virtual void	RemoveFromWorld ()
ObjectGuid const &	GetGUID () const
PackedGuid const &	GetPackGUID () const
uint32	GetEntry () const
void	SetEntry (uint32 entry)
float	GetObjectScale () const
virtual void	SetObjectScale (float scale)
TypeID	GetTypeId () const
bool	isType (uint16 mask) const
virtual void	BuildCreateUpdateBlockForPlayer (UpdateData *data, Player *target) const
void	SendUpdateToPlayer (Player *player)
void	BuildValuesUpdateBlockForPlayer (UpdateData *data, Player *target) const
void	BuildOutOfRangeUpdateBlock (UpdateData *data) const
virtual void	DestroyForPlayer (Player *target) const
int32	GetInt32Value (uint16 index) const
uint32	GetUInt32Value (uint16 index) const
uint64	GetUInt64Value (uint16 index) const
float	GetFloatValue (uint16 index) const
uint8	GetByteValue (uint16 index, uint8 offset) const
uint16	GetUInt16Value (uint16 index, uint8 offset) const
ObjectGuid const &	GetGuidValue (uint16 index) const
void	SetInt32Value (uint16 index, int32 value)
void	SetUInt32Value (uint16 index, uint32 value)
void	UpdateUInt32Value (uint16 index, uint32 value)
void	SetUInt64Value (uint16 index, uint64 value)
void	SetFloatValue (uint16 index, float value)
void	SetByteValue (uint16 index, uint8 offset, uint8 value)
void	SetUInt16Value (uint16 index, uint8 offset, uint16 value)
void	SetGuidValue (uint16 index, ObjectGuid const &value)
void	SetStatFloatValue (uint16 index, float value)
void	SetStatInt32Value (uint16 index, int32 value)
bool	AddGuidValue (uint16 index, ObjectGuid const &value)
bool	RemoveGuidValue (uint16 index, ObjectGuid const &value)
void	ApplyModUInt32Value (uint16 index, int32 val, bool apply)
void	ApplyModInt32Value (uint16 index, int32 val, bool apply)
void	ApplyModUInt16Value (uint16 index, uint8 offset, int16 val, bool apply)
void	ApplyModPositiveFloatValue (uint16 index, float val, bool apply)
void	ApplyModSignedFloatValue (uint16 index, float val, bool apply)
void	ApplyPercentModFloatValue (uint16 index, float val, bool apply)
void	SetFlag (uint16 index, uint32 newFlag)
void	RemoveFlag (uint16 index, uint32 oldFlag)
void	ToggleFlag (uint16 index, uint32 flag)
bool	HasFlag (uint16 index, uint32 flag) const
void	ApplyModFlag (uint16 index, uint32 flag, bool apply)
void	SetByteFlag (uint16 index, uint8 offset, uint8 newFlag)
void	RemoveByteFlag (uint16 index, uint8 offset, uint8 newFlag)
void	ToggleByteFlag (uint16 index, uint8 offset, uint8 flag)
bool	HasByteFlag (uint16 index, uint8 offset, uint8 flag) const
void	SetFlag64 (uint16 index, uint64 newFlag)
void	RemoveFlag64 (uint16 index, uint64 oldFlag)
void	ToggleFlag64 (uint16 index, uint64 flag)
bool	HasFlag64 (uint16 index, uint64 flag) const
void	ApplyModFlag64 (uint16 index, uint64 flag, bool apply)
std::vector< uint32 > const &	GetDynamicValues (uint16 index) const
void	AddDynamicValue (uint16 index, uint32 value)
void	RemoveDynamicValue (uint16 index, uint32 value)
void	ClearDynamicValue (uint16 index)
void	SetDynamicValue (uint16 index, uint8 offset, uint32 value)
void	ClearUpdateMask (bool remove)
uint16	GetValuesCount () const
virtual bool	hasQuest (uint32) const
virtual bool	hasInvolvedQuest (uint32) const
virtual void	BuildUpdate (UpdateDataMapType &)
void	BuildFieldsUpdate (Player *, UpdateDataMapType &) const
void	SetFieldNotifyFlag (uint16 flag)
void	RemoveFieldNotifyFlag (uint16 flag)
void	ForceValuesUpdateAtIndex (uint32)
Player *	ToPlayer ()
Player const *	ToPlayer () const
Creature *	ToCreature ()
Creature const *	ToCreature () const
Unit *	ToUnit ()
Unit const *	ToUnit () const
GameObject *	ToGameObject ()
GameObject const *	ToGameObject () const
Corpse *	ToCorpse ()
Corpse const *	ToCorpse () const
DynamicObject *	ToDynObject ()
DynamicObject const *	ToDynObject () const
AreaTrigger *	ToAreaTrigger ()
AreaTrigger const *	ToAreaTrigger () const

Protected Member Functions
	Object ()
void	_InitValues ()
void	_Create (ObjectGuid const &guid)
std::string	_ConcatFields (uint16 startIndex, uint16 size) const
void	_LoadIntoDataField (std::string const &data, uint32 startOffset, uint32 count)
uint32	GetUpdateFieldData (Player const *target, uint32 *&flags) const
uint32	GetDynamicUpdateFieldData (Player const *target, uint32 *&flags) const
void	BuildMovementUpdate (ByteBuffer *data, uint32 flags) const
virtual void	BuildValuesUpdate (uint8 updatetype, ByteBuffer *data, Player *target) const
virtual void	BuildDynamicValuesUpdate (uint8 updatetype, ByteBuffer *data, Player *target) const
virtual void	AddToObjectUpdate ()=0
virtual void	RemoveFromObjectUpdate ()=0
void	AddToObjectUpdateIfNeeded ()

Protected Attributes
uint16	m_objectType
TypeID	m_objectTypeId
uint32	m_updateFlag
union {
int32 *   m_int32Values
uint32 *   m_uint32Values
float *   m_floatValues
};
std::vector< uint32 > *	_dynamicValues
UpdateMask	_changesMask
UpdateMask	_dynamicChangesMask
UpdateMask *	_dynamicChangesArrayMask
uint16	m_valuesCount
uint16	_dynamicValuesCount
uint16	_fieldNotifyFlags
bool	m_objectUpdated

Private Member Functions
bool	PrintIndexError (uint32 index, bool set) const
	Object (Object const &right)=delete
Object &	operator= (Object const &right)=delete

Private Attributes
bool	m_inWorld
PackedGuid	m_PackGUID

Constructor & Destructor Documentation

Object::~Object ( )

virtual

{
 if (IsInWorld())
 {
 TC_LOG_FATAL("misc", "Object::~Object %s deleted but still in world!!", GetGUID().ToString().c_str());
 if (isType(TYPEMASK_ITEM))
 TC_LOG_FATAL("misc", "Item slot %u", ((Item*)this)->GetSlot());
 ABORT();
 }

 if (m_objectUpdated)
 {
 TC_LOG_FATAL("misc", "Object::~Object %s deleted but still in update list!!", GetGUID().ToString().c_str());
 ABORT();
 }

 delete[] m_uint32Values;
 m_uint32Values = nullptr;

 delete[] _dynamicValues;
 _dynamicValues = nullptr;

 delete[] _dynamicChangesArrayMask;
 _dynamicChangesArrayMask = nullptr;
}

Here is the call graph for this function:

Object::Object ( )

protected

{
 m_objectTypeId = TYPEID_OBJECT;
 m_objectType = TYPEMASK_OBJECT;
 m_updateFlag = UPDATEFLAG_NONE;

 m_uint32Values = nullptr;
 _dynamicValues = nullptr;
 _dynamicChangesArrayMask = nullptr;
 m_valuesCount = 0;
 _dynamicValuesCount = 0;
 _fieldNotifyFlags = UF_FLAG_DYNAMIC;

 m_inWorld = false;
 m_objectUpdated = false;
}

Object::Object ( Object const &  right )

privatedelete

Member Function Documentation

std::string Object::_ConcatFields ( uint16  startIndex, uint16  size  ) const

protected

{
 std::ostringstream ss;
 for (uint16 index = 0; index < size; ++index)
 ss << GetUInt32Value(index + startIndex) << ' ';
 return ss.str();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::_Create ( ObjectGuid const &  guid )

protected

{
 if (!m_uint32Values) _InitValues();

 SetGuidValue(OBJECT_FIELD_GUID, guid);
 SetUInt16Value(OBJECT_FIELD_TYPE, 0, m_objectType);
 m_PackGUID.Set(guid);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::_InitValues ( )

protected

{
 m_uint32Values = new uint32[m_valuesCount];
 memset(m_uint32Values, 0, m_valuesCount*sizeof(uint32));

 _changesMask.SetCount(m_valuesCount);

 _dynamicChangesMask.SetCount(_dynamicValuesCount);
 if (_dynamicValuesCount)
 {
 _dynamicValues = new std::vector<uint32>[_dynamicValuesCount];
 _dynamicChangesArrayMask = new UpdateMask[_dynamicValuesCount];
 }

 m_objectUpdated = false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::_LoadIntoDataField ( std::string const &  data, uint32  startOffset, uint32  count  )

protected

{
 if (data.empty())
 return;

 Tokenizer tokens(data, ' ', count);

 if (tokens.size() != count)
 return;

 for (uint32 index = 0; index < count; ++index)
 {
 m_uint32Values[startOffset + index] = atoul(tokens[index]);
 _changesMask.SetBit(startOffset + index);
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::AddDynamicValue	(	uint16	index,
		uint32	value
	)

{
 ASSERT(index < _dynamicValuesCount || PrintIndexError(index, false));

 std::vector<uint32>& values = _dynamicValues[index];
 UpdateMask& mask = _dynamicChangesArrayMask[index];

 _dynamicChangesMask.SetBit(index);
 if (values.size() >= values.capacity())
 values.reserve(values.capacity() + 32);

 values.push_back(value);
 if (mask.GetCount() < values.size())
 mask.AddBlock();

 mask.SetBit(values.size() - 1);

 AddToObjectUpdateIfNeeded();
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Object::AddGuidValue	(	uint16	index,
		ObjectGuid const &	value
	)

{
 ASSERT(index + 3 < m_valuesCount || PrintIndexError(index, true));
 if (!value.IsEmpty() && ((ObjectGuid*)&(m_uint32Values[index]))->IsEmpty())
 {
 *((ObjectGuid*)&(m_uint32Values[index])) = value;
 _changesMask.SetBit(index);
 _changesMask.SetBit(index + 1);
 _changesMask.SetBit(index + 2);
 _changesMask.SetBit(index + 3);

 AddToObjectUpdateIfNeeded();
 return true;
 }

 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void Object::AddToObjectUpdate ( )

protectedpure virtual

Implemented in WorldObject, and Item.

Here is the caller graph for this function:

void Object::AddToObjectUpdateIfNeeded ( )

protected

{
 if (m_inWorld && !m_objectUpdated)
 {
 AddToObjectUpdate();
 m_objectUpdated = true;
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::AddToWorld ( )

virtual

Reimplemented in Unit, GameObject, Creature, Corpse, Pet, DynamicObject, Bag, and AreaTrigger.

{
 if (m_inWorld)
 return;

 ASSERT(m_uint32Values);

 m_inWorld = true;

 // synchronize values mirror with values array (changes will send in updatecreate opcode any way
 ASSERT(!m_objectUpdated);
 ClearUpdateMask(false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::ApplyModFlag	(	uint16	index,
		uint32	flag,
		bool	apply
	)

{
 if (apply) SetFlag(index, flag); else RemoveFlag(index, flag);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::ApplyModFlag64	(	uint16	index,
		uint64	flag,
		bool	apply
	)

{
 if (apply) SetFlag64(index, flag); else RemoveFlag64(index, flag);
}

Here is the call graph for this function:

void Object::ApplyModInt32Value	(	uint16	index,
		int32	val,
		bool	apply
	)

{
 int32 cur = GetInt32Value(index);
 cur += (apply ? val : -val);
 SetInt32Value(index, cur);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::ApplyModPositiveFloatValue	(	uint16	index,
		float	val,
		bool	apply
	)

{
 float cur = GetFloatValue(index);
 cur += (apply ? val : -val);
 if (cur < 0)
 cur = 0;
 SetFloatValue(index, cur);
}

Here is the call graph for this function:

void Object::ApplyModSignedFloatValue	(	uint16	index,
		float	val,
		bool	apply
	)

{
 float cur = GetFloatValue(index);
 cur += (apply ? val : -val);
 SetFloatValue(index, cur);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::ApplyModUInt16Value	(	uint16	index,
		uint8	offset,
		int16	val,
		bool	apply
	)

{
 int16 cur = GetUInt16Value(index, offset);
 cur += (apply ? val : -val);
 if (cur < 0)
 cur = 0;
 SetUInt16Value(index, offset, cur);
}

Here is the call graph for this function:

void Object::ApplyModUInt32Value	(	uint16	index,
		int32	val,
		bool	apply
	)

{
 int32 cur = GetUInt32Value(index);
 cur += (apply ? val : -val);
 if (cur < 0)
 cur = 0;
 SetUInt32Value(index, cur);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::ApplyPercentModFloatValue	(	uint16	index,
		float	val,
		bool	apply
	)

{
 float value = GetFloatValue(index);
 ApplyPercentModFloatVar(value, val, apply);
 SetFloatValue(index, value);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::BuildCreateUpdateBlockForPlayer ( UpdateData *  data, Player *  target  ) const

virtual

lower flag1

Reimplemented in Bag.

{
 if (!target)
 return;

 uint8 updateType = UPDATETYPE_CREATE_OBJECT;
 uint32 flags = m_updateFlag;

 if (target == this) // building packet for yourself
 flags |= UPDATEFLAG_SELF;

 switch (GetGUID().GetHigh())
 {
 case HighGuid::Player:
 case HighGuid::Pet:
 case HighGuid::Corpse:
 case HighGuid::DynamicObject:
 case HighGuid::AreaTrigger:
 updateType = UPDATETYPE_CREATE_OBJECT2;
 break;
 case HighGuid::Creature:
 case HighGuid::Vehicle:
 {
 if (TempSummon const* summon = ToUnit()->ToTempSummon())
 if (summon->GetSummonerGUID().IsPlayer())
 updateType = UPDATETYPE_CREATE_OBJECT2;

 break;
 }
 case HighGuid::GameObject:
 {
 if (ToGameObject()->GetOwnerGUID().IsPlayer())
 updateType = UPDATETYPE_CREATE_OBJECT2;
 break;
 }
 default:
 break;
 }

 if (WorldObject const* worldObject = dynamic_cast<WorldObject const*>(this))
 {
 if (!(flags & UPDATEFLAG_LIVING))
 if (!worldObject->m_movementInfo.transport.guid.IsEmpty())
 flags |= UPDATEFLAG_TRANSPORT_POSITION;

 if (worldObject->GetAIAnimKitId() || worldObject->GetMovementAnimKitId() || worldObject->GetMeleeAnimKitId())
 flags |= UPDATEFLAG_ANIMKITS;
 }

 if (flags & UPDATEFLAG_STATIONARY_POSITION)
 {
 // UPDATETYPE_CREATE_OBJECT2 for some gameobject types...
 if (isType(TYPEMASK_GAMEOBJECT))
 {
 switch (ToGameObject()->GetGoType())
 {
 case GAMEOBJECT_TYPE_TRAP:
 case GAMEOBJECT_TYPE_DUEL_ARBITER:
 case GAMEOBJECT_TYPE_FLAGSTAND:
 case GAMEOBJECT_TYPE_FLAGDROP:
 updateType = UPDATETYPE_CREATE_OBJECT2;
 break;
 default:
 break;
 }
 }
 }

 if (Unit const* unit = ToUnit())
 if (unit->GetVictim())
 flags |= UPDATEFLAG_HAS_TARGET;

 ByteBuffer buf(0x400);
 buf << uint8(updateType);
 buf << GetPackGUID();
 buf << uint8(m_objectTypeId);

 BuildMovementUpdate(&buf, flags);
 BuildValuesUpdate(updateType, &buf, target);
 BuildDynamicValuesUpdate(updateType, &buf, target);
 data->AddUpdateBlock(buf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::BuildDynamicValuesUpdate ( uint8  updatetype, ByteBuffer *  data, Player *  target  ) const

protectedvirtual

Reimplemented in Item.

{
 if (!target)
 return;

 ByteBuffer fieldBuffer;
 UpdateMask updateMask;
 updateMask.SetCount(_dynamicValuesCount);

 uint32* flags = nullptr;
 uint32 visibleFlag = GetDynamicUpdateFieldData(target, flags);

 for (uint16 index = 0; index < _dynamicValuesCount; ++index)
 {
 ByteBuffer buffer;
 std::vector<uint32> const& values = _dynamicValues[index];
 if (_fieldNotifyFlags & flags[index] ||
 ((updateType == UPDATETYPE_VALUES ? _dynamicChangesMask.GetBit(index) : !values.empty()) && (flags[index] & visibleFlag)))
 {
 updateMask.SetBit(index);

 UpdateMask arrayMask;
 arrayMask.SetCount(values.size());
 for (std::size_t v = 0; v < values.size(); ++v)
 {
 if (updateType != UPDATETYPE_VALUES || _dynamicChangesArrayMask[index].GetBit(v))
 {
 arrayMask.SetBit(v);
 buffer << uint32(values[v]);
 }
 }

 fieldBuffer << uint8(arrayMask.GetBlockCount());
 arrayMask.AppendToPacket(&fieldBuffer);
 fieldBuffer.append(buffer);
 }
 }

 *data << uint8(updateMask.GetBlockCount());
 updateMask.AppendToPacket(data);
 data->append(fieldBuffer);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::BuildFieldsUpdate	(	Player *	player,
		UpdateDataMapType &	data_map
	)		const

{
 UpdateDataMapType::iterator iter = data_map.find(player);

 if (iter == data_map.end())
 {
 std::pair<UpdateDataMapType::iterator, bool> p = data_map.emplace(player, UpdateData(player->GetMapId()));
 ASSERT(p.second);
 iter = p.first;
 }

 BuildValuesUpdateBlockForPlayer(&iter->second, iter->first);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::BuildMovementUpdate ( ByteBuffer *  data, uint32  flags  ) const

protected

Use IsTransport() to also handle type 11 (TRANSPORT) Currently grid objects are not updated if there are no nearby players, this causes clients to receive different PathProgress resulting in players seeing the object in a different position

{
 bool NoBirthAnim = false;
 bool EnablePortals = false;
 bool PlayHoverAnim = false;
 bool IsSuppressingGreetings = false;
 bool HasMovementUpdate = (flags & UPDATEFLAG_LIVING) != 0;
 bool HasMovementTransport = (flags & UPDATEFLAG_TRANSPORT_POSITION) != 0;
 bool Stationary = (flags & UPDATEFLAG_STATIONARY_POSITION) != 0;
 bool CombatVictim = (flags & UPDATEFLAG_HAS_TARGET) != 0;
 bool ServerTime = (flags & UPDATEFLAG_TRANSPORT) != 0;
 bool VehicleCreate = (flags & UPDATEFLAG_VEHICLE) != 0;
 bool AnimKitCreate = (flags & UPDATEFLAG_ANIMKITS) != 0;
 bool Rotation = (flags & UPDATEFLAG_ROTATION) != 0;
 bool HasAreaTrigger = false;
 bool HasGameObject = false;
 bool ThisIsYou = (flags & UPDATEFLAG_SELF) != 0;
 bool ReplaceActive = false;
 bool SceneObjCreate = false;
 bool ScenePendingInstances = false;
 uint32 PauseTimesCount = 0;
 if (GameObject const* go = ToGameObject())
 if (go->GetGoType() == GAMEOBJECT_TYPE_TRANSPORT)
 PauseTimesCount = go->GetGOValue()->Transport.StopFrames->size();

 data->WriteBit(NoBirthAnim);
 data->WriteBit(EnablePortals);
 data->WriteBit(PlayHoverAnim);
 data->WriteBit(IsSuppressingGreetings);
 data->WriteBit(HasMovementUpdate);
 data->WriteBit(HasMovementTransport);
 data->WriteBit(Stationary);
 data->WriteBit(CombatVictim);
    data->WriteBit(ServerTime);
    data->WriteBit(VehicleCreate);
    data->WriteBit(AnimKitCreate);
    data->WriteBit(Rotation);
    data->WriteBit(HasAreaTrigger);
    data->WriteBit(HasGameObject);
    data->WriteBit(ThisIsYou);
    data->WriteBit(ReplaceActive);
    data->WriteBit(SceneObjCreate);
    data->WriteBit(ScenePendingInstances);
    *data << uint32(PauseTimesCount);

    if (HasMovementUpdate)
    {
        Unit const* unit = ToUnit();
        bool HasFallDirection = unit->HasUnitMovementFlag(MOVEMENTFLAG_FALLING);
        bool HasFall = HasFallDirection || unit->m_movementInfo.jump.fallTime != 0;
        bool HasSpline = unit->IsSplineEnabled();

        *data << GetPackGUID();                                         // MoverGUID

        *data << uint32(unit->m_movementInfo.time);                     // MoveIndex
        *data << float(unit->GetPositionX());
        *data << float(unit->GetPositionY());
        *data << float(unit->GetPositionZ());
        *data << float(unit->GetOrientation());

        *data << float(unit->m_movementInfo.pitch);                     // Pitch
        *data << float(unit->m_movementInfo.splineElevation);           // StepUpStartElevation

        uint32 removeMovementForcesCount = 0;
        *data << uint32(removeMovementForcesCount);                     // Count of RemoveForcesIDs
        *data << uint32(0);                                             // Unknown

        //for (uint32 i = 0; i < removeMovementForcesCount; ++i)
        //    *data << ObjectGuid(RemoveForcesIDs);

        data->WriteBits(unit->GetUnitMovementFlags(), 30);
        data->WriteBits(unit->GetExtraUnitMovementFlags(), 16);
        data->WriteBit(!unit->m_movementInfo.transport.guid.IsEmpty()); // HasTransport
        data->WriteBit(HasFall);                                        // HasFall
        data->WriteBit(HasSpline);                                      // HasSpline - marks that the unit uses spline movement
        data->WriteBit(0);                                              // HeightChangeFailed
        data->WriteBit(0);                                              // RemoteTimeValid

        if (!unit->m_movementInfo.transport.guid.IsEmpty())
            *data << unit->m_movementInfo.transport;

        if (HasFall)
        {
            *data << uint32(unit->m_movementInfo.jump.fallTime);              // Time
            *data << float(unit->m_movementInfo.jump.zspeed);                 // JumpVelocity

            if (data->WriteBit(HasFallDirection))
            {
                *data << float(unit->m_movementInfo.jump.sinAngle);           // Direction
                *data << float(unit->m_movementInfo.jump.cosAngle);
                *data << float(unit->m_movementInfo.jump.xyspeed);            // Speed
            }
        }

        *data << float(unit->GetSpeed(MOVE_WALK));
        *data << float(unit->GetSpeed(MOVE_RUN));
        *data << float(unit->GetSpeed(MOVE_RUN_BACK));
        *data << float(unit->GetSpeed(MOVE_SWIM));
        *data << float(unit->GetSpeed(MOVE_SWIM_BACK));
        *data << float(unit->GetSpeed(MOVE_FLIGHT));
        *data << float(unit->GetSpeed(MOVE_FLIGHT_BACK));
        *data << float(unit->GetSpeed(MOVE_TURN_RATE));
        *data << float(unit->GetSpeed(MOVE_PITCH_RATE));

        uint32 MovementForceCount = 0;
        *data << uint32(MovementForceCount);

        //for (uint32 i = 0; i < MovementForceCount; ++i)
        //{
        //    *data << ObjectGuid(ID);
        //    *data << Vector3(Direction);
        //    *data << Vector3(force.TransportPosition);
        //    *data << int32(TransportID);
        //    *data << float(Magnitude);
        //    *data << uint8(Type);
        //}

        // HasMovementSpline - marks that spline data is present in packet
        if (data->WriteBit(HasSpline))
            WorldPackets::Movement::CommonMovement::WriteCreateObjectSplineDataBlock(*unit->movespline, *data);
    }

    if (HasMovementTransport)
    {
        WorldObject const* self = static_cast<WorldObject const*>(this);
        *data << self->m_movementInfo.transport;
    }

    if (Stationary)
    {
        WorldObject const* self = static_cast<WorldObject const*>(this);
        *data << float(self->GetStationaryX());
        *data << float(self->GetStationaryY());
        *data << float(self->GetStationaryZ());
        *data << float(self->GetStationaryO());
    }

    if (CombatVictim)
        *data << ToUnit()->GetVictim()->GetGUID();                      // CombatVictim

    if (ServerTime)
    {
        GameObject const* go = ToGameObject();
        if (go && go->ToTransport())                                    // ServerTime
            *data << uint32(go->GetGOValue()->Transport.PathProgress);
        else
            *data << uint32(getMSTime());
    }

    if (VehicleCreate)
    {
        Unit const* unit = ToUnit();
        *data << uint32(unit->GetVehicleKit()->GetVehicleInfo()->ID); // RecID
        *data << float(unit->GetOrientation());                         // InitialRawFacing
    }

    if (AnimKitCreate)
    {
        WorldObject const* self = static_cast<WorldObject const*>(this);
        *data << uint16(self->GetAIAnimKitId());                        // AiID
        *data << uint16(self->GetMovementAnimKitId());                  // MovementID
        *data << uint16(self->GetMeleeAnimKitId());                     // MeleeID
    }

    if (Rotation)
        *data << uint64(ToGameObject()->GetRotation());                 // Rotation

    //if (AreaTrigger)
    //{
    //    packet.ReadInt32("ElapsedMs", index);

    //    packet.ReadVector3("RollPitchYaw1", index);

    //    packet.ResetBitReader();

    //    var HasAbsoluteOrientation = packet.ReadBit("HasAbsoluteOrientation", index);
    //    var HasDynamicShape = packet.ReadBit("HasDynamicShape", index);
    //    var HasAttached = packet.ReadBit("HasAttached", index);
    //    var HasFaceMovementDir = packet.ReadBit("HasFaceMovementDir", index);
    //    var HasFollowsTerrain = packet.ReadBit("HasFollowsTerrain", index);
    //    var HasTargetRollPitchYaw = packet.ReadBit("HasTargetRollPitchYaw", index);
    //    var HasScaleCurveID = packet.ReadBit("HasScaleCurveID", index);
    //    var HasMorphCurveID = packet.ReadBit("HasMorphCurveID", index);
    //    var HasFacingCurveID = packet.ReadBit("HasFacingCurveID", index);
    //    var HasMoveCurveID = packet.ReadBit("HasMoveCurveID", index);
    //    var HasAreaTriggerSphere = packet.ReadBit("HasAreaTriggerSphere", index);
    //    var HasAreaTriggerBox = packet.ReadBit("HasAreaTriggerBox", index);
    //    var HasAreaTriggerPolygon = packet.ReadBit("HasAreaTriggerPolygon", index);
    //    var HasAreaTriggerCylinder = packet.ReadBit("HasAreaTriggerCylinder", index);
    //    var HasAreaTriggerSpline = packet.ReadBit("HasAreaTriggerSpline", index);

    //    if (HasTargetRollPitchYaw)
    //        packet.ReadVector3("TargetRollPitchYaw", index);

    //    if (HasScaleCurveID)
    //        packet.ReadInt32("ScaleCurveID, index");

    //    if (HasMorphCurveID)
    //        packet.ReadInt32("MorphCurveID", index);

    //    if (HasFacingCurveID)
    //        packet.ReadInt32("FacingCurveID", index);

    //    if (HasMoveCurveID)
    //        packet.ReadInt32("MoveCurveID", index);

    //    if (HasAreaTriggerSphere)
    //    {
    //        packet.ReadSingle("Radius", index);
    //        packet.ReadSingle("RadiusTarget", index);
    //    }

    //    if (HasAreaTriggerBox)
    //    {
    //        packet.ReadVector3("Extents", index);
    //        packet.ReadVector3("ExtentsTarget", index);
    //    }

    //    if (HasAreaTriggerPolygon)
    //    {
    //        var VerticesCount = packet.ReadInt32("VerticesCount", index);
    //        var VerticesTargetCount = packet.ReadInt32("VerticesTargetCount", index);
    //        packet.ReadSingle("Height", index);
    //        packet.ReadSingle("HeightTarget", index);

    //        for (var i = 0; i < VerticesCount; ++i)
    //            packet.ReadVector2("Vertices", index, i);

    //        for (var i = 0; i < VerticesTargetCount; ++i)
    //            packet.ReadVector2("VerticesTarget", index, i);
    //    }

    //    if (HasAreaTriggerCylinder)
    //    {
    //        packet.ReadSingle("Radius", index);
    //        packet.ReadSingle("RadiusTarget", index);
    //        packet.ReadSingle("Height", index);
    //        packet.ReadSingle("HeightTarget", index);
    //        packet.ReadSingle("Float4", index);
    //        packet.ReadSingle("Float5", index);
    //    }

    //    if (HasAreaTriggerSpline)
    //    {
    //        packet.ReadInt32("TimeToTarget", index);
    //        packet.ReadInt32("ElapsedTimeForMovement", index);
    //        var int8 = packet.ReadInt32("VerticesCount", index);

    //        for (var i = 0; i < int8; ++i)
    //            packet.ReadVector3("Points", index, i);
    //    }
    //}

    //if (GameObject)
    //{
    //    packet.ReadInt32("WorldEffectID", index);

    //    packet.ResetBitReader();

    //    var bit8 = packet.ReadBit("bit8", index);
    //    if (bit8)
    //        packet.ReadInt32("Int1", index);
    //}

    //if (SceneObjCreate)
    //{
    //    packet.ResetBitReader();

    //    var CliSceneLocalScriptData = packet.ReadBit("CliSceneLocalScriptData", index);
    //    var PetBattleFullUpdate = packet.ReadBit("PetBattleFullUpdate", index);

    //    if (CliSceneLocalScriptData)
    //    {
    //        packet.ResetBitReader();
    //        var DataLength = packet.ReadBits(7);
    //        packet.ReadWoWString("Data", DataLength, index);
    //    }

    //    if (PetBattleFullUpdate)
    //    {
    //        for (var i = 0; i < 2; ++i)
    //        {
    //            packet.ReadPackedGuid128("CharacterID", index, i);

    //            packet.ReadInt32("TrapAbilityID", index, i);
    //            packet.ReadInt32("TrapStatus", index, i);

    //            packet.ReadInt16("RoundTimeSecs", index, i);

    //            packet.ReadByte("FrontPet", index, i);
    //            packet.ReadByte("InputFlags", index, i);

    //            packet.ResetBitReader();

    //            var PetBattlePetUpdateCount = packet.ReadBits("PetBattlePetUpdateCount", 2, index, i);

    //            for (var j = 0; j < PetBattlePetUpdateCount; ++j)
    //            {
    //                packet.ReadPackedGuid128("BattlePetGUID", index, i, j);

    //                packet.ReadInt32("SpeciesID", index, i, j);
    //                packet.ReadInt32("DisplayID", index, i, j);
    //                packet.ReadInt32("CollarID", index, i, j);

    //                packet.ReadInt16("Level", index, i, j);
    //                packet.ReadInt16("Xp", index, i, j);


    //                packet.ReadInt32("CurHealth", index, i, j);
    //                packet.ReadInt32("MaxHealth", index, i, j);
    //                packet.ReadInt32("Power", index, i, j);
    //                packet.ReadInt32("Speed", index, i, j);
    //                packet.ReadInt32("NpcTeamMemberID", index, i, j);

    //                packet.ReadInt16("BreedQuality", index, i, j);
    //                packet.ReadInt16("StatusFlags", index, i, j);

    //                packet.ReadByte("Slot", index, i, j);

    //                var PetBattleActiveAbility = packet.ReadInt32("PetBattleActiveAbility", index, i, j);
    //                var PetBattleActiveAura = packet.ReadInt32("PetBattleActiveAura", index, i, j);
    //                var PetBattleActiveState = packet.ReadInt32("PetBattleActiveState", index, i, j);

    //                for (var k = 0; k < PetBattleActiveAbility; ++k)
    //                {
    //                    packet.ReadInt32("AbilityID", index, i, j, k);
    //                    packet.ReadInt16("CooldownRemaining", index, i, j, k);
    //                    packet.ReadInt16("LockdownRemaining", index, i, j, k);
    //                    packet.ReadByte("AbilityIndex", index, i, j, k);
    //                    packet.ReadByte("Pboid", index, i, j, k);
    //                }

    //                for (var k = 0; k < PetBattleActiveAura; ++k)
    //                {
    //                    packet.ReadInt32("AbilityID", index, i, j, k);
    //                    packet.ReadInt32("InstanceID", index, i, j, k);
    //                    packet.ReadInt32("RoundsRemaining", index, i, j, k);
    //                    packet.ReadInt32("CurrentRound", index, i, j, k);
    //                    packet.ReadByte("CasterPBOID", index, i, j, k);
    //                }

    //                for (var k = 0; k < PetBattleActiveState; ++k)
    //                {
    //                    packet.ReadInt32("StateID", index, i, j, k);
    //                    packet.ReadInt32("StateValue", index, i, j, k);
    //                }

    //                packet.ResetBitReader();
    //                var bits57 = packet.ReadBits(7);
    //                packet.ReadWoWString("CustomName", bits57, index, i, j);
    //            }
    //        }

    //        for (var i = 0; i < 3; ++i)
    //        {
    //            var PetBattleActiveAura = packet.ReadInt32("PetBattleActiveAura", index, i);
    //            var PetBattleActiveState = packet.ReadInt32("PetBattleActiveState", index, i);

    //            for (var j = 0; j < PetBattleActiveAura; ++j)
    //            {
    //                packet.ReadInt32("AbilityID", index, i, j);
    //                packet.ReadInt32("InstanceID", index, i, j);
    //                packet.ReadInt32("RoundsRemaining", index, i, j);
    //                packet.ReadInt32("CurrentRound", index, i, j);
    //                packet.ReadByte("CasterPBOID", index, i, j);
    //            }

    //            for (var j = 0; j < PetBattleActiveState; ++j)
    //            {
    //                packet.ReadInt32("StateID", index, i, j);
    //                packet.ReadInt32("StateValue", index, i, j);
    //            }
    //        }

    //        packet.ReadInt16("WaitingForFrontPetsMaxSecs", index);
    //        packet.ReadInt16("PvpMaxRoundTime", index);

    //        packet.ReadInt32("CurRound", index);
    //        packet.ReadInt32("NpcCreatureID", index);
    //        packet.ReadInt32("NpcDisplayID", index);

    //        packet.ReadByte("CurPetBattleState");
    //        packet.ReadByte("ForfeitPenalty");

    //        packet.ReadPackedGuid128("InitialWildPetGUID");

    //        packet.ReadBit("IsPVP");
    //        packet.ReadBit("CanAwardXP");
    //    }
    //}

    //if (ScenePendingInstances)
    //{
    //    var SceneInstanceIDs = packet.ReadInt32("SceneInstanceIDsCount");

    //    for (var i = 0; i < SceneInstanceIDs; ++i)
    //        packet.ReadInt32("SceneInstanceIDs", index, i);
    //}

    if (GameObject const* go = ToGameObject())
        for (uint32 i = 0; i < PauseTimesCount; ++i)
            *data << uint32(go->GetGOValue()->Transport.StopFrames->at(i));

    data->FlushBits();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::BuildOutOfRangeUpdateBlock

(

UpdateData *

data

)

const

{
    data->AddOutOfRangeGUID(GetGUID());
}

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void Object::BuildUpdate ( UpdateDataMapType &  )

inlinevirtual

Reimplemented in WorldObject, Item, and Transport.

{ }

Here is the caller graph for this function:

void Object::BuildValuesUpdate ( uint8  updatetype, ByteBuffer *  data, Player *  target  ) const

protectedvirtual

Reimplemented in Unit, and GameObject.

{
    if (!target)
        return;

    ByteBuffer fieldBuffer;
    UpdateMask updateMask;
    updateMask.SetCount(m_valuesCount);

    uint32* flags = NULL;
    uint32 visibleFlag = GetUpdateFieldData(target, flags);
    ASSERT(flags);

    for (uint16 index = 0; index < m_valuesCount; ++index)
    {
        if (_fieldNotifyFlags & flags[index] ||
            ((updateType == UPDATETYPE_VALUES ? _changesMask.GetBit(index) : m_uint32Values[index]) && (flags[index] & visibleFlag)))
        {
            updateMask.SetBit(index);
            fieldBuffer << m_uint32Values[index];
        }
    }

    *data << uint8(updateMask.GetBlockCount());
    updateMask.AppendToPacket(data);
    data->append(fieldBuffer);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::BuildValuesUpdateBlockForPlayer	(	UpdateData *	data,
		Player *	target
	)		const

{
    ByteBuffer buf(500);

    buf << uint8(UPDATETYPE_VALUES);
    buf << GetPackGUID();

    BuildValuesUpdate(UPDATETYPE_VALUES, &buf, target);
    BuildDynamicValuesUpdate(UPDATETYPE_VALUES, &buf, target);

    data->AddUpdateBlock(buf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::ClearDynamicValue

(

uint16

index

)

{
    ASSERT(index < _dynamicValuesCount || PrintIndexError(index, false));

    if (!_dynamicValues[index].empty())
    {
        _dynamicValues[index].clear();
        _dynamicChangesMask.SetBit(index);
        _dynamicChangesArrayMask[index].SetCount(0);

        AddToObjectUpdateIfNeeded();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::ClearUpdateMask

(

bool

remove

)

{
    _changesMask.Clear();
    _dynamicChangesMask.Clear();
    for (uint32 i = 0; i < _dynamicValuesCount; ++i)
        _dynamicChangesArrayMask[i].Clear();

    if (m_objectUpdated)
    {
        if (remove)
            RemoveFromObjectUpdate();
        m_objectUpdated = false;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::DestroyForPlayer ( Player *  target ) const

virtual

Reimplemented in Unit.

{
    ASSERT(target);

    UpdateData updateData(target->GetMapId());
    BuildOutOfRangeUpdateBlock(&updateData);
    WorldPacket packet;
    updateData.BuildPacket(&packet);
    target->SendDirectMessage(&packet);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::ForceValuesUpdateAtIndex

(

uint32

i

)

{
    _changesMask.SetBit(i);
    AddToObjectUpdateIfNeeded();
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8 Object::GetByteValue	(	uint16	index,
		uint8	offset
	)		const

{
    ASSERT(index < m_valuesCount || PrintIndexError(index, false));
    ASSERT(offset < 4);
    return *(((uint8*)&m_uint32Values[index])+offset);
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Object::GetDynamicUpdateFieldData ( Player const *  target, uint32 *&  flags  ) const

protected

{
    uint32 visibleFlag = UF_FLAG_PUBLIC;

    if (target == this)
        visibleFlag |= UF_FLAG_PRIVATE;

    switch (GetTypeId())
    {
        case TYPEID_ITEM:
        case TYPEID_CONTAINER:
            flags = ItemDynamicUpdateFieldFlags;
            if (((Item const*)this)->GetOwnerGUID() == target->GetGUID())
                visibleFlag |= UF_FLAG_OWNER | UF_FLAG_ITEM_OWNER;
            break;
        case TYPEID_UNIT:
        case TYPEID_PLAYER:
        {
            Player* plr = ToUnit()->GetCharmerOrOwnerPlayerOrPlayerItself();
            flags = UnitDynamicUpdateFieldFlags;
            if (ToUnit()->GetOwnerGUID() == target->GetGUID())
                visibleFlag |= UF_FLAG_OWNER;

            if (HasFlag(OBJECT_DYNAMIC_FLAGS, UNIT_DYNFLAG_SPECIALINFO))
                if (ToUnit()->HasAuraTypeWithCaster(SPELL_AURA_EMPATHY, target->GetGUID()))
                    visibleFlag |= UF_FLAG_SPECIAL_INFO;

            if (plr && plr->IsInSameRaidWith(target))
                visibleFlag |= UF_FLAG_PARTY_MEMBER;
            break;
        }
        case TYPEID_GAMEOBJECT:
            flags = GameObjectDynamicUpdateFieldFlags;
            break;
        case TYPEID_CONVERSATION:
            flags = ConversationDynamicUpdateFieldFlags;
            break;
        default:
            flags = nullptr;
            break;
    }

    return visibleFlag;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< uint32 > const & Object::GetDynamicValues

(

uint16

index

)

const

{
    ASSERT(index < _dynamicValuesCount || PrintIndexError(index, false));
    return _dynamicValues[index];
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Object::GetEntry ( ) const

inline

{ return GetUInt32Value(OBJECT_FIELD_ENTRY); }

float Object::GetFloatValue

(

uint16

index

)

const

{
    ASSERT(index < m_valuesCount || PrintIndexError(index, false));
    return m_floatValues[index];
}

Here is the call graph for this function:

Here is the caller graph for this function:

ObjectGuid const& Object::GetGUID ( ) const

inline

{ return GetGuidValue(OBJECT_FIELD_GUID); }

ObjectGuid const & Object::GetGuidValue

(

uint16

index

)

const

{
    ASSERT(index + 1 < m_valuesCount || PrintIndexError(index, false));
    return *((ObjectGuid*)&(m_uint32Values[index]));
}

Here is the call graph for this function:

Here is the caller graph for this function:

int32 Object::GetInt32Value

(

uint16

index

)

const

{
    ASSERT(index < m_valuesCount || PrintIndexError(index, false));
    return m_int32Values[index];
}

Here is the call graph for this function:

Here is the caller graph for this function:

float Object::GetObjectScale ( ) const

inline

{ return GetFloatValue(OBJECT_FIELD_SCALE_X); }

Here is the caller graph for this function:

PackedGuid const& Object::GetPackGUID ( ) const

inline

{ return m_PackGUID; }

Here is the caller graph for this function:

TypeID Object::GetTypeId ( ) const

inline

{ return m_objectTypeId; }

uint16 Object::GetUInt16Value	(	uint16	index,
		uint8	offset
	)		const

{
    ASSERT(index < m_valuesCount || PrintIndexError(index, false));
    ASSERT(offset < 2);
    return *(((uint16*)&m_uint32Values[index])+offset);
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Object::GetUInt32Value

(

uint16

index

)

const

{
    ASSERT(index < m_valuesCount || PrintIndexError(index, false));
    return m_uint32Values[index];
}

Here is the call graph for this function:

uint64 Object::GetUInt64Value

(

uint16

index

)

const

{
    ASSERT(index + 1 < m_valuesCount || PrintIndexError(index, false));
    return *((uint64*)&(m_uint32Values[index]));
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Object::GetUpdateFieldData ( Player const *  target, uint32 *&  flags  ) const

protected

{
    uint32 visibleFlag = UF_FLAG_PUBLIC;

    if (target == this)
        visibleFlag |= UF_FLAG_PRIVATE;

    switch (GetTypeId())
    {
        case TYPEID_ITEM:
        case TYPEID_CONTAINER:
            flags = ItemUpdateFieldFlags;
            if (((Item const*)this)->GetOwnerGUID() == target->GetGUID())
                visibleFlag |= UF_FLAG_OWNER | UF_FLAG_ITEM_OWNER;
            break;
        case TYPEID_UNIT:
        case TYPEID_PLAYER:
        {
            Player* plr = ToUnit()->GetCharmerOrOwnerPlayerOrPlayerItself();
            flags = UnitUpdateFieldFlags;
            if (ToUnit()->GetOwnerGUID() == target->GetGUID())
                visibleFlag |= UF_FLAG_OWNER;

            if (HasFlag(OBJECT_DYNAMIC_FLAGS, UNIT_DYNFLAG_SPECIALINFO))
                if (ToUnit()->HasAuraTypeWithCaster(SPELL_AURA_EMPATHY, target->GetGUID()))
                    visibleFlag |= UF_FLAG_SPECIAL_INFO;

            if (plr && plr->IsInSameRaidWith(target))
                visibleFlag |= UF_FLAG_PARTY_MEMBER;
            break;
        }
        case TYPEID_GAMEOBJECT:
            flags = GameObjectUpdateFieldFlags;
            if (ToGameObject()->GetOwnerGUID() == target->GetGUID())
                visibleFlag |= UF_FLAG_OWNER;
            break;
        case TYPEID_DYNAMICOBJECT:
            flags = DynamicObjectUpdateFieldFlags;
            if (ToDynObject()->GetCasterGUID() == target->GetGUID())
                visibleFlag |= UF_FLAG_OWNER;
            break;
        case TYPEID_CORPSE:
            flags = CorpseUpdateFieldFlags;
            if (ToCorpse()->GetOwnerGUID() == target->GetGUID())
                visibleFlag |= UF_FLAG_OWNER;
            break;
        case TYPEID_AREATRIGGER:
            flags = AreaTriggerUpdateFieldFlags;
            break;
        case TYPEID_SCENEOBJECT:
            flags = SceneObjectUpdateFieldFlags;
            break;
        case TYPEID_CONVERSATION:
            flags = ConversationUpdateFieldFlags;
            break;
        case TYPEID_OBJECT:
            ABORT();
            break;
    }

    return visibleFlag;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint16 Object::GetValuesCount ( ) const

inline

{ return m_valuesCount; }

Here is the caller graph for this function:

bool Object::HasByteFlag	(	uint16	index,
		uint8	offset,
		uint8	flag
	)		const

{
    ASSERT(index < m_valuesCount || PrintIndexError(index, false));
    ASSERT(offset < 4);
    return (((uint8*)&m_uint32Values[index])[offset] & flag) != 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Object::HasFlag	(	uint16	index,
		uint32	flag
	)		const

{
    if (index >= m_valuesCount && !PrintIndexError(index, false))
        return false;

    return (m_uint32Values[index] & flag) != 0;
}

Here is the call graph for this function:

bool Object::HasFlag64	(	uint16	index,
		uint64	flag
	)		const

{
    ASSERT(index < m_valuesCount || PrintIndexError(index, false));
    return (GetUInt64Value(index) & flag) != 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

virtual bool Object::hasInvolvedQuest ( uint32  ) const

inlinevirtual

Reimplemented in GameObject, Creature, and Item.

{ return false; }

Here is the caller graph for this function:

virtual bool Object::hasQuest ( uint32  ) const

inlinevirtual

Reimplemented in GameObject, Creature, and Item.

{ return false; }

bool Object::IsInWorld ( ) const

inline

{ return m_inWorld; }

bool Object::isType ( uint16  mask ) const

inline

{ return (mask & m_objectType) != 0; }

Here is the caller graph for this function:

Object& Object::operator= ( Object const &  right )

privatedelete

bool Object::PrintIndexError ( uint32  index, bool  set  ) const

private

{
    TC_LOG_ERROR("misc", "Attempt %s non-existed value field: %u (count: %u) for object typeid: %u type mask: %u", (set ? "set value to" : "get value from"), index, m_valuesCount, GetTypeId(), m_objectType);

    // ASSERT must fail after function call
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::RemoveByteFlag	(	uint16	index,
		uint8	offset,
		uint8	newFlag
	)

{
    ASSERT(index < m_valuesCount || PrintIndexError(index, true));

    if (offset > 3)
    {
        TC_LOG_ERROR("misc", "Object::RemoveByteFlag: wrong offset %u", offset);
        return;
    }

    if (uint8(m_uint32Values[index] >> (offset * 8)) & oldFlag)
    {
        m_uint32Values[index] &= ~uint32(uint32(oldFlag) << (offset * 8));
        _changesMask.SetBit(index);

        AddToObjectUpdateIfNeeded();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::RemoveDynamicValue	(	uint16	index,
		uint32	value
	)

TODO: Research if this is actually needed

{
    ASSERT(index < _dynamicValuesCount || PrintIndexError(index, false));
}

Here is the call graph for this function:

void Object::RemoveFieldNotifyFlag ( uint16  flag )

inline

{ _fieldNotifyFlags &= uint16(~flag); }

Here is the caller graph for this function:

void Object::RemoveFlag	(	uint16	index,
		uint32	oldFlag
	)

{
    ASSERT(index < m_valuesCount || PrintIndexError(index, true));
    ASSERT(m_uint32Values);

    uint32 oldval = m_uint32Values[index];
    uint32 newval = oldval & ~oldFlag;

    if (oldval != newval)
    {
        m_uint32Values[index] = newval;
        _changesMask.SetBit(index);

        AddToObjectUpdateIfNeeded();
    }
}

Here is the call graph for this function:

void Object::RemoveFlag64	(	uint16	index,
		uint64	oldFlag
	)

{
    uint64 oldval = GetUInt64Value(index);
    uint64 newval = oldval & ~oldFlag;
    SetUInt64Value(index, newval);
}

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void Object::RemoveFromObjectUpdate ( )

protectedpure virtual

Implemented in WorldObject, and Item.

Here is the caller graph for this function:

void Object::RemoveFromWorld ( )

virtual

Reimplemented in Unit, GameObject, Creature, WorldObject, Puppet, Minion, Corpse, Pet, TempSummon, DynamicObject, Bag, and AreaTrigger.

{
    if (!m_inWorld)
        return;

    m_inWorld = false;

    // if we remove from world then sending changes not required
    ClearUpdateMask(true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Object::RemoveGuidValue	(	uint16	index,
		ObjectGuid const &	value
	)

{
    ASSERT(index + 3 < m_valuesCount || PrintIndexError(index, true));
    if (!value.IsEmpty() && *((ObjectGuid*)&(m_uint32Values[index])) == value)
    {
        ((ObjectGuid*)&(m_uint32Values[index]))->Clear();
        _changesMask.SetBit(index);
        _changesMask.SetBit(index + 1);
        _changesMask.SetBit(index + 2);
        _changesMask.SetBit(index + 3);

        AddToObjectUpdateIfNeeded();
        return true;
    }

    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::SendUpdateToPlayer

(

Player *

player

)

{
    // send create update to player
    UpdateData upd(player->GetMapId());
    WorldPacket packet;

    if (player->HaveAtClient(this))
        BuildValuesUpdateBlockForPlayer(&upd, player);
    else
        BuildCreateUpdateBlockForPlayer(&upd, player);
    upd.BuildPacket(&packet);
    player->GetSession()->SendPacket(&packet);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::SetByteFlag	(	uint16	index,
		uint8	offset,
		uint8	newFlag
	)

{
    ASSERT(index < m_valuesCount || PrintIndexError(index, true));

    if (offset > 3)
    {
        TC_LOG_ERROR("misc", "Object::SetByteFlag: wrong offset %u", offset);
        return;
    }

    if (!(uint8(m_uint32Values[index] >> (offset * 8)) & newFlag))
    {
        m_uint32Values[index] |= uint32(uint32(newFlag) << (offset * 8));
        _changesMask.SetBit(index);

        AddToObjectUpdateIfNeeded();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::SetByteValue	(	uint16	index,
		uint8	offset,
		uint8	value
	)

{
    ASSERT(index < m_valuesCount || PrintIndexError(index, true));

    if (offset > 3)
    {
        TC_LOG_ERROR("misc", "Object::SetByteValue: wrong offset %u", offset);
        return;
    }

    if (uint8(m_uint32Values[index] >> (offset * 8)) != value)
    {
        m_uint32Values[index] &= ~uint32(uint32(0xFF) << (offset * 8));
        m_uint32Values[index] |= uint32(uint32(value) << (offset * 8));
        _changesMask.SetBit(index);

        AddToObjectUpdateIfNeeded();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::SetDynamicValue	(	uint16	index,
		uint8	offset,
		uint32	value
	)

{
    ASSERT(index < _dynamicValuesCount || PrintIndexError(index, false));

    std::vector<uint32>& values = _dynamicValues[index];

    ASSERT(offset < values.size());

    if (values[offset] != value)
    {
        values[offset] = value;
        _dynamicChangesMask.SetBit(index);
        _dynamicChangesArrayMask[index].SetBit(offset);

        AddToObjectUpdateIfNeeded();
    }
}

Here is the call graph for this function:

void Object::SetEntry ( uint32  entry )

inline

{ SetUInt32Value(OBJECT_FIELD_ENTRY, entry); }

Here is the caller graph for this function:

void Object::SetFieldNotifyFlag ( uint16  flag )

inline

{ _fieldNotifyFlags |= flag; }

Here is the caller graph for this function:

void Object::SetFlag	(	uint16	index,
		uint32	newFlag
	)

{
    ASSERT(index < m_valuesCount || PrintIndexError(index, true));
    uint32 oldval = m_uint32Values[index];
    uint32 newval = oldval | newFlag;

    if (oldval != newval)
    {
        m_uint32Values[index] = newval;
        _changesMask.SetBit(index);

        AddToObjectUpdateIfNeeded();
    }
}

Here is the call graph for this function:

void Object::SetFlag64	(	uint16	index,
		uint64	newFlag
	)

{
    uint64 oldval = GetUInt64Value(index);
    uint64 newval = oldval | newFlag;
    SetUInt64Value(index, newval);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::SetFloatValue	(	uint16	index,
		float	value
	)

{
    ASSERT(index < m_valuesCount || PrintIndexError(index, true));

    if (m_floatValues[index] != value)
    {
        m_floatValues[index] = value;
        _changesMask.SetBit(index);

        AddToObjectUpdateIfNeeded();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::SetGuidValue	(	uint16	index,
		ObjectGuid const &	value
	)

{
    ASSERT(index + 3 < m_valuesCount || PrintIndexError(index, true));
    if (*((ObjectGuid*)&(m_uint32Values[index])) != value)
    {
        *((ObjectGuid*)&(m_uint32Values[index])) = value;
        _changesMask.SetBit(index);
        _changesMask.SetBit(index + 1);
        _changesMask.SetBit(index + 2);
        _changesMask.SetBit(index + 3);

        AddToObjectUpdateIfNeeded();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::SetInt32Value	(	uint16	index,
		int32	value
	)

{
    ASSERT(index < m_valuesCount || PrintIndexError(index, true));

    if (m_int32Values[index] != value)
    {
        m_int32Values[index] = value;
        _changesMask.SetBit(index);

        AddToObjectUpdateIfNeeded();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void Object::SetObjectScale ( float  scale )

inlinevirtual

Reimplemented in Creature.

{ SetFloatValue(OBJECT_FIELD_SCALE_X, scale); }

Here is the caller graph for this function:

void Object::SetStatFloatValue	(	uint16	index,
		float	value
	)

{
    if (value < 0)
        value = 0.0f;

    SetFloatValue(index, value);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::SetStatInt32Value	(	uint16	index,
		int32	value
	)

{
    if (value < 0)
        value = 0;

    SetUInt32Value(index, uint32(value));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::SetUInt16Value	(	uint16	index,
		uint8	offset,
		uint16	value
	)

{
    ASSERT(index < m_valuesCount || PrintIndexError(index, true));

    if (offset > 1)
    {
        TC_LOG_ERROR("misc", "Object::SetUInt16Value: wrong offset %u", offset);
        return;
    }

    if (uint16(m_uint32Values[index] >> (offset * 16)) != value)
    {
        m_uint32Values[index] &= ~uint32(uint32(0xFFFF) << (offset * 16));
        m_uint32Values[index] |= uint32(uint32(value) << (offset * 16));
        _changesMask.SetBit(index);

        AddToObjectUpdateIfNeeded();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Object::SetUInt32Value	(	uint16	index,
		uint32	value
	)

{
    ASSERT(index < m_valuesCount || PrintIndexError(index, true));

    if (m_uint32Values[index] != value)
    {
        m_uint32Values[index] = value;
        _changesMask.SetBit(index);

        AddToObjectUpdateIfNeeded();
    }
}

Here is the call graph for this function:

void Object::SetUInt64Value	(	uint16	index,
		uint64	value
	)

{
    ASSERT(index + 1 < m_valuesCount || PrintIndexError(index, true));
    if (*((uint64*)&(m_uint32Values[index])) != value)
    {
        m_uint32Values[index] = PAIR64_LOPART(value);
        m_uint32Values[index + 1] = PAIR64_HIPART(value);
        _changesMask.SetBit(index);
        _changesMask.SetBit(index + 1);

        AddToObjectUpdateIfNeeded();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

AreaTrigger* Object::ToAreaTrigger ( )

inline

{ if (GetTypeId() == TYPEID_AREATRIGGER) return reinterpret_cast<AreaTrigger*>(this); else return NULL; }

AreaTrigger const* Object::ToAreaTrigger ( ) const

inline

{ if (GetTypeId() == TYPEID_AREATRIGGER) return reinterpret_cast<AreaTrigger const*>(this); else return NULL; }

Corpse* Object::ToCorpse ( )

inline

{ if (GetTypeId() == TYPEID_CORPSE) return reinterpret_cast<Corpse*>(this); else return NULL; }

Here is the caller graph for this function:

Corpse const* Object::ToCorpse ( ) const

inline

{ if (GetTypeId() == TYPEID_CORPSE) return reinterpret_cast<Corpse const*>(this); else return NULL; }

Creature* Object::ToCreature ( )

inline

{ if (GetTypeId() == TYPEID_UNIT) return reinterpret_cast<Creature*>(this); else return NULL; }

Creature const* Object::ToCreature ( ) const

inline

{ if (GetTypeId() == TYPEID_UNIT) return reinterpret_cast<Creature const*>(this); else return NULL; }

DynamicObject* Object::ToDynObject ( )

inline

{ if (GetTypeId() == TYPEID_DYNAMICOBJECT) return reinterpret_cast<DynamicObject*>(this); else return NULL; }

Here is the caller graph for this function:

DynamicObject const* Object::ToDynObject ( ) const

inline

{ if (GetTypeId() == TYPEID_DYNAMICOBJECT) return reinterpret_cast<DynamicObject const*>(this); else return NULL; }

GameObject* Object::ToGameObject ( )

inline

{ if (GetTypeId() == TYPEID_GAMEOBJECT) return reinterpret_cast<GameObject*>(this); else return NULL; }

Here is the caller graph for this function:

GameObject const* Object::ToGameObject ( ) const

inline

{ if (GetTypeId() == TYPEID_GAMEOBJECT) return reinterpret_cast<GameObject const*>(this); else return NULL; }

void Object::ToggleByteFlag	(	uint16	index,
		uint8	offset,
		uint8	flag
	)

{
    if (HasByteFlag(index, offset, flag))
        RemoveByteFlag(index, offset, flag);
    else
        SetByteFlag(index, offset, flag);
}

Here is the call graph for this function:

void Object::ToggleFlag	(	uint16	index,
		uint32	flag
	)

{
    if (HasFlag(index, flag))
        RemoveFlag(index, flag);
    else
        SetFlag(index, flag);
}

Here is the call graph for this function:

void Object::ToggleFlag64	(	uint16	index,
		uint64	flag
	)

{
    if (HasFlag64(index, flag))
        RemoveFlag64(index, flag);
    else
        SetFlag64(index, flag);
}

Here is the call graph for this function:

Player* Object::ToPlayer ( )

inline

{ if (GetTypeId() == TYPEID_PLAYER) return reinterpret_cast<Player*>(this); else return NULL; }

Player const* Object::ToPlayer ( ) const

inline

{ if (GetTypeId() == TYPEID_PLAYER) return reinterpret_cast<Player const*>(this); else return NULL; }

Unit* Object::ToUnit ( )

inline

{ if (isType(TYPEMASK_UNIT)) return reinterpret_cast<Unit*>(this); else return NULL; }

Unit const* Object::ToUnit ( ) const

inline

{ if (isType(TYPEMASK_UNIT)) return reinterpret_cast<Unit const*>(this); else return NULL; }

void Object::UpdateUInt32Value	(	uint16	index,
		uint32	value
	)

{
    ASSERT(index < m_valuesCount || PrintIndexError(index, true));

    m_uint32Values[index] = value;
    _changesMask.SetBit(index);
}

Here is the call graph for this function:

Member Data Documentation

union { ... }

UpdateMask Object::_changesMask

protected

UpdateMask* Object::_dynamicChangesArrayMask

protected

UpdateMask Object::_dynamicChangesMask

protected

std::vector<uint32>* Object::_dynamicValues

protected

uint16 Object::_dynamicValuesCount

protected

uint16 Object::_fieldNotifyFlags

protected

float* Object::m_floatValues

int32* Object::m_int32Values

bool Object::m_inWorld

private

uint16 Object::m_objectType

protected

TypeID Object::m_objectTypeId

protected

bool Object::m_objectUpdated

protected

PackedGuid Object::m_PackGUID

private

uint32* Object::m_uint32Values

uint32 Object::m_updateFlag

protected

uint16 Object::m_valuesCount

protected

---

The documentation for this class was generated from the following files:

• src/server/game/Entities/Object/Object.h
• src/server/game/Entities/Object/Object.cpp