mangos-mirror/server
0
0
Fork 0
mirror of https://github.com/mangosfour/server.git synced 2025-12-12 10:37:03 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

[10683] Revert "[10677] Send to creature/etc Update call real diff from last update and use it."

Browse source 
This reverts commit 10784a8c7cc81c468b5411e973d36ecf31de9603.

Main reason: impossibility for me as commiter test problem and fix all corner cases problems.
This commit is contained in:
VladimirMangos 2010-11-05 19:51:28 +03:00
parent 2f144d9d29
commit 0847d4c8cd
35 changed files with 149 additions and 162 deletions
Download patch file Download diff file Expand all files Collapse all files

22
src/game/Creature.cpp
View file

@ -406,7 +406,7 @@ uint32 Creature::ChooseDisplayId(const CreatureInfo *cinfo, const CreatureData *
return display_id;
}
void Creature::Update(uint32 update_diff, uint32 tick_diff)
void Creature::Update(uint32 diff)
{
if (m_needNotify)
{
@ -467,7 +467,7 @@ void Creature::Update(uint32 update_diff, uint32 tick_diff)
if (m_isDeadByDefault)
break;
if (m_corpseDecayTimer <= update_diff)
if (m_corpseDecayTimer <= diff)
{
// since pool system can fail to roll unspawned object, this one can remain spawned, so must set respawn nevertheless
uint16 poolid = GetDBTableGUIDLow() ? sPoolMgr.IsPartOfAPool<Creature>(GetDBTableGUIDLow()) : 0;
@ -482,11 +482,11 @@ void Creature::Update(uint32 update_diff, uint32 tick_diff)
}
else
{
m_corpseDecayTimer -= update_diff;
m_corpseDecayTimer -= diff;
if (m_groupLootId)
{
if(update_diff < m_groupLootTimer)
m_groupLootTimer -= update_diff;
if(diff < m_groupLootTimer)
m_groupLootTimer -= diff;
else
StopGroupLoot();
}
@ -498,7 +498,7 @@ void Creature::Update(uint32 update_diff, uint32 tick_diff)
{
if (m_isDeadByDefault)
{
if (m_corpseDecayTimer <= update_diff)
if (m_corpseDecayTimer <= diff)
{
// since pool system can fail to roll unspawned object, this one can remain spawned, so must set respawn nevertheless
uint16 poolid = GetDBTableGUIDLow() ? sPoolMgr.IsPartOfAPool<Creature>(GetDBTableGUIDLow()) : 0;
@ -516,11 +516,11 @@ void Creature::Update(uint32 update_diff, uint32 tick_diff)
}
else
{
m_corpseDecayTimer -= update_diff;
m_corpseDecayTimer -= diff;
}
}
Unit::Update(update_diff, tick_diff);
Unit::Update( diff );
// creature can be dead after Unit::Update call
// CORPSE/DEAD state will processed at next tick (in other case death timer will be updated unexpectedly)
@ -531,7 +531,7 @@ void Creature::Update(uint32 update_diff, uint32 tick_diff)
{
// do not allow the AI to be changed during update
m_AI_locked = true;
i_AI->UpdateAI(tick_diff); // AI not react good at real update delays (while freeze in non-active part of map)
i_AI->UpdateAI(diff);
m_AI_locked = false;
}
@ -541,10 +541,10 @@ void Creature::Update(uint32 update_diff, uint32 tick_diff)
break;
if(m_regenTimer > 0)
{
if(update_diff >= m_regenTimer)
if(diff >= m_regenTimer)
m_regenTimer = 0;
else
m_regenTimer -= update_diff;
m_regenTimer -= diff;
}
if (m_regenTimer != 0)
break;

2
src/game/Creature.h
View file

@ -402,6 +402,7 @@ class MANGOS_DLL_SPEC Creature : public Unit
uint32 GetDBTableGUIDLow() const { return m_DBTableGuid; }
char const* GetSubName() const { return GetCreatureInfo()->SubName; }
void Update(uint32 time); // overwrite Unit::Update
void GetRespawnCoord(float &x, float &y, float &z, float* ori = NULL, float* dist =NULL) const;
uint32 GetEquipmentId() const { return m_equipmentId; }
@ -638,7 +639,6 @@ class MANGOS_DLL_SPEC Creature : public Unit
void SendAreaSpiritHealerQueryOpcode(Player *pl);
protected:
void Update(uint32 update_diff, uint32 tick_diff); // overwrite Unit::Update
bool CreateFromProto(uint32 guidlow,uint32 Entry,uint32 team, const CreatureData *data = NULL);
bool InitEntry(uint32 entry, uint32 team=ALLIANCE, const CreatureData* data=NULL);
void RelocationNotify();

6
src/game/DynamicObject.cpp
View file

@ -106,7 +106,7 @@ Unit* DynamicObject::GetCaster() const
return ObjectAccessor::GetUnit(*this, GetCasterGUID());
}
void DynamicObject::Update(uint32 update_diff, uint32 /*tick_diff*/)
void DynamicObject::Update(uint32 p_time)
{
// caster can be not in world at time dynamic object update, but dynamic object not yet deleted in Unit destructor
Unit* caster = GetCaster();
@ -118,8 +118,8 @@ void DynamicObject::Update(uint32 update_diff, uint32 /*tick_diff*/)
bool deleteThis = false;
if(m_aliveDuration > int32(update_diff))
m_aliveDuration -= update_diff;
if(m_aliveDuration > int32(p_time))
m_aliveDuration -= p_time;
else
deleteThis = true;

3
src/game/DynamicObject.h
View file

@ -35,6 +35,7 @@ class DynamicObject : public WorldObject
void RemoveFromWorld();
bool Create(uint32 guidlow, Unit *caster, uint32 spellId, SpellEffectIndex effIndex, float x, float y, float z, int32 duration, float radius);
void Update(uint32 p_time);
void Delete();
uint32 GetSpellId() const { return m_spellId; }
SpellEffectIndex GetEffIndex() const { return m_effIndex; }
@ -66,8 +67,6 @@ class DynamicObject : public WorldObject
GridReference<DynamicObject> &GetGridRef() { return m_gridRef; }
protected:
void Update(uint32 update_diff, uint32 tick_diff); // overwrite WorldObject::Update
uint32 m_spellId;
SpellEffectIndex m_effIndex;
int32 m_aliveDuration;

2
src/game/GameObject.cpp
View file

@ -159,7 +159,7 @@ bool GameObject::Create(uint32 guidlow, uint32 name_id, Map *map, uint32 phaseMa
return true;
}
void GameObject::Update(uint32 /*update_diff*/, uint32 /*tick_diff*/)
void GameObject::Update(uint32 /*p_time*/)
{
if (GetObjectGuid().IsMOTransport())
{

3
src/game/GameObject.h
View file

@ -588,6 +588,7 @@ class MANGOS_DLL_SPEC GameObject : public WorldObject
void RemoveFromWorld();
bool Create(uint32 guidlow, uint32 name_id, Map *map, uint32 phaseMask, float x, float y, float z, float ang, float rotation0, float rotation1, float rotation2, float rotation3, uint8 animprogress, GOState go_state);
void Update(uint32 p_time);
GameObjectInfo const* GetGOInfo() const;
bool IsTransport() const;
@ -710,8 +711,6 @@ class MANGOS_DLL_SPEC GameObject : public WorldObject
uint64 GetRotation() const { return m_rotation; }
protected:
void Update(uint32 update_diff, uint32 tick_diff); // overwrite WorldObject::Update
uint32 m_spellId;
time_t m_respawnTime; // (secs) time of next respawn (or despawn if GO have owner()),
uint32 m_respawnDelayTime; // (secs) if 0 then current GO state no dependent from timer

4
src/game/GridNotifiers.cpp
View file

@ -187,7 +187,9 @@ template<class T> void
ObjectUpdater::Visit(GridRefManager<T> &m)
{
for(typename GridRefManager<T>::iterator iter = m.begin(); iter != m.end(); ++iter)
iter->getSource()->UpdateCall(i_time, i_diff);
{
iter->getSource()->Update(i_timeDiff);
}
}
bool CannibalizeObjectCheck::operator()(Corpse* u)

10
src/game/GridNotifiers.h
View file

@ -61,14 +61,13 @@ namespace MaNGOS
struct MANGOS_DLL_DECL GridUpdater
{
GridType &i_grid;
uint32 i_time;
uint32 i_timeDiff;
GridUpdater(GridType &grid, uint32 time_, uint32 diff) : i_grid(grid), i_time(time_), i_timeDiff(diff) {}
GridUpdater(GridType &grid, uint32 diff) : i_grid(grid), i_timeDiff(diff) {}
template<class T> void updateObjects(GridRefManager<T> &m)
{
for(typename GridRefManager<T>::iterator iter = m.begin(); iter != m.end(); ++iter)
iter->getSource()->UpdateCall(i_time, i_timeDiff);
iter->getSource()->Update(i_timeDiff);
}
void Visit(PlayerMapType &m) { updateObjects<Player>(m); }
@ -137,9 +136,8 @@ namespace MaNGOS
struct MANGOS_DLL_DECL ObjectUpdater
{
uint32 i_time; // current tick time in msecs
uint32 i_diff; // current tick time diff in msecs
explicit ObjectUpdater(uint32 time_, uint32 diff) : i_time(time_), i_diff(diff) {}
uint32 i_timeDiff;
explicit ObjectUpdater(const uint32 &diff) : i_timeDiff(diff) {}
template<class T> void Visit(GridRefManager<T> &m);
void Visit(PlayerMapType &) {}
void Visit(CorpseMapType &) {}

2
src/game/GridNotifiersImpl.h
View file

@ -41,7 +41,7 @@ inline void MaNGOS::VisibleNotifier::Visit(GridRefManager<T> &m)
inline void MaNGOS::ObjectUpdater::Visit(CreatureMapType &m)
{
for(CreatureMapType::iterator iter = m.begin(); iter != m.end(); ++iter)
iter->getSource()->UpdateCall(i_time, i_diff);
iter->getSource()->Update(i_timeDiff);
}
inline void PlayerCreatureRelocationWorker(Player* pl, WorldObject const* viewPoint, Creature* c)

24
src/game/Map.cpp
View file

@ -510,18 +510,20 @@ bool Map::loaded(const GridPair &p) const
return ( getNGrid(p.x_coord, p.y_coord) && isGridObjectDataLoaded(p.x_coord, p.y_coord) );
}
void Map::Update(uint32 time_, uint32 diff)
void Map::Update(const uint32 &t_diff)
{
/// update players at tick
for(m_mapRefIter = m_mapRefManager.begin(); m_mapRefIter != m_mapRefManager.end(); ++m_mapRefIter)
if (Player* plr = m_mapRefIter->getSource())
if (plr->IsInWorld())
plr->UpdateCall(time_, diff);
{
Player* plr = m_mapRefIter->getSource();
if(plr && plr->IsInWorld())
plr->Update(t_diff);
}
/// update active cells around players and active objects
resetMarkedCells();
MaNGOS::ObjectUpdater updater(time_, diff);
MaNGOS::ObjectUpdater updater(t_diff);
// for creature
TypeContainerVisitor<MaNGOS::ObjectUpdater, GridTypeMapContainer > grid_object_update(updater);
// for pets
@ -630,7 +632,7 @@ void Map::Update(uint32 time_, uint32 diff)
GridInfo *info = i->getSource()->getGridInfoRef();
++i; // The update might delete the map and we need the next map before the iterator gets invalid
MANGOS_ASSERT(grid->GetGridState() >= 0 && grid->GetGridState() < MAX_GRID_STATE);
sMapMgr.UpdateGridState(grid->GetGridState(), *this, *grid, *info, grid->getX(), grid->getY(), diff);
sMapMgr.UpdateGridState(grid->GetGridState(), *this, *grid, *info, grid->getX(), grid->getY(), t_diff);
}
}
@ -1838,17 +1840,17 @@ bool InstanceMap::Add(Player *player)
return true;
}
void InstanceMap::Update(uint32 time_, uint32 diff)
void InstanceMap::Update(const uint32& t_diff)
{
Map::Update(time_, diff);
Map::Update(t_diff);
if(i_data)
i_data->Update(diff);
i_data->Update(t_diff);
}
void BattleGroundMap::Update(uint32 time_, uint32 diff)
void BattleGroundMap::Update(const uint32& diff)
{
Map::Update(time_, diff);
Map::Update(diff);
GetBG()->Update(diff);
}

6
src/game/Map.h
View file

@ -108,7 +108,7 @@ class MANGOS_DLL_SPEC Map : public GridRefManager<NGridType>, public MaNGOS::Obj
template<class T> void Add(T *);
template<class T> void Remove(T *, bool);
virtual void Update(uint32 time_, uint32 diff);
virtual void Update(const uint32&);
void MessageBroadcast(Player *, WorldPacket *, bool to_self);
void MessageBroadcast(WorldObject *, WorldPacket *);
@ -382,7 +382,7 @@ class MANGOS_DLL_SPEC InstanceMap : public Map
~InstanceMap();
bool Add(Player *);
void Remove(Player *, bool);
void Update(uint32 time_, uint32 diff);
void Update(const uint32&);
void CreateInstanceData(bool load);
bool Reset(uint8 method);
uint32 GetScriptId() { return i_script_id; }
@ -407,7 +407,7 @@ class MANGOS_DLL_SPEC BattleGroundMap : public Map
BattleGroundMap(uint32 id, time_t, uint32 InstanceId, Map* _parent, uint8 spawnMode);
~BattleGroundMap();
void Update(uint32 time_, uint32 diff);
void Update(const uint32&);
bool Add(Player *);
void Remove(Player *, bool);
bool CanEnter(Player* player);

8
src/game/MapInstanced.cpp
View file

@ -43,24 +43,24 @@ void MapInstanced::InitVisibilityDistance()
}
}
void MapInstanced::Update(uint32 time_, uint32 diff)
void MapInstanced::Update(const uint32& t)
{
// take care of loaded GridMaps (when unused, unload it!)
Map::Update(time_, diff);
Map::Update(t);
// update the instanced maps
InstancedMaps::iterator i = m_InstancedMaps.begin();
while (i != m_InstancedMaps.end())
{
if(i->second->CanUnload(diff))
if(i->second->CanUnload(t))
{
DestroyInstance(i); // iterator incremented
}
else
{
// update only here, because it may schedule some bad things before delete
i->second->Update(time_, diff);
i->second->Update(t);
++i;
}
}

2
src/game/MapInstanced.h
View file

@ -34,7 +34,7 @@ class MANGOS_DLL_DECL MapInstanced : public Map
~MapInstanced() {}
// functions overwrite Map versions
void Update(uint32 time_, uint32 diff);
void Update(const uint32&);
void RemoveAllObjectsInRemoveList();
void UnloadAll(bool pForce);

6
src/game/MapManager.cpp
View file

@ -239,17 +239,17 @@ void MapManager::DeleteInstance(uint32 mapid, uint32 instanceId)
}
void
MapManager::Update(const uint32 time_, const uint32 diff)
MapManager::Update(uint32 diff)
{
i_timer.Update(diff);
if( !i_timer.Passed() )
return;
for(MapMapType::iterator iter=i_maps.begin(); iter != i_maps.end(); ++iter)
iter->second->Update(time_, (uint32)i_timer.GetCurrent());
iter->second->Update((uint32)i_timer.GetCurrent());
for (TransportSet::iterator iter = m_Transports.begin(); iter != m_Transports.end(); ++iter)
(*iter)->UpdateCall(time_, (uint32)i_timer.GetCurrent());
(*iter)->Update((uint32)i_timer.GetCurrent());
i_timer.SetCurrent(0);
}

2
src/game/MapManager.h
View file

@ -67,7 +67,7 @@ class MANGOS_DLL_DECL MapManager : public MaNGOS::Singleton<MapManager, MaNGOS::
}
void Initialize(void);
void Update(const uint32 time, const uint32 diff);
void Update(uint32);
void SetGridCleanUpDelay(uint32 t)
{

12
src/game/Object.cpp
View file

@ -103,16 +103,6 @@ void Object::_Create(uint32 guidlow, uint32 entry, HighGuid guidhigh)
m_PackGUID.Set(guid);
}
void WorldObject::UpdateCall(uint32 newtime, uint32 diff)
{
// use real time diff from last object update call
// this can have big diff from tick diff time for object returning to active zone)
uint32 realDiff = getMSTimeDiff(m_lastUpdateTime, newtime);
m_lastUpdateTime = newtime;
Update(realDiff, diff);
}
void Object::SetObjectScale(float newScale)
{
SetFloatValue(OBJECT_FIELD_SCALE_X, newScale);
@ -1131,7 +1121,7 @@ void Object::BuildUpdateData( UpdateDataMapType& /*update_players */)
WorldObject::WorldObject()
: m_isActiveObject(false), m_currMap(NULL), m_mapId(0), m_InstanceId(0), m_phaseMask(PHASEMASK_NORMAL),
m_positionX(0.0f), m_positionY(0.0f), m_positionZ(0.0f), m_orientation(0.0f), m_lastUpdateTime(getMSTime())
m_positionX(0.0f), m_positionY(0.0f), m_positionZ(0.0f), m_orientation(0.0f)
{
}

7
src/game/Object.h
View file

@ -342,7 +342,7 @@ class MANGOS_DLL_SPEC WorldObject : public Object
public:
virtual ~WorldObject ( ) {}
void UpdateCall(uint32 newtime, uint32 diff); // tick time and tick diff in msecs, must be called instead direct call Update
virtual void Update ( uint32 /*time_diff*/ ) { }
void _Create( uint32 guidlow, HighGuid guidhigh, uint32 phaseMask);
@ -492,12 +492,9 @@ class MANGOS_DLL_SPEC WorldObject : public Object
bool isActiveObject() const { return m_isActiveObject || m_viewPoint.hasViewers(); }
ViewPoint& GetViewPoint() { return m_viewPoint; }
protected:
explicit WorldObject();
virtual void Update(uint32 /*update_diff*/, uint32 /*tick_diff*/) { }
//these functions are used mostly for Relocate() and Corpse/Player specific stuff...
//use them ONLY in LoadFromDB()/Create() funcs and nowhere else!
//mapId/instanceId should be set in SetMap() function!
@ -520,8 +517,6 @@ class MANGOS_DLL_SPEC WorldObject : public Object
float m_orientation;
ViewPoint m_viewPoint;
uint32 m_lastUpdateTime;
};
#endif

20
src/game/Pet.cpp
View file

@ -482,7 +482,7 @@ void Pet::SetDeathState(DeathState s) // overwrite virtual
}
}
void Pet::Update(uint32 update_diff, uint32 tick_diff)
void Pet::Update(uint32 diff)
{
if(m_removed) // pet already removed, just wait in remove queue, no updates
return;
@ -491,7 +491,7 @@ void Pet::Update(uint32 update_diff, uint32 tick_diff)
{
case CORPSE:
{
if (m_corpseDecayTimer <= update_diff)
if (m_corpseDecayTimer <= diff)
{
MANGOS_ASSERT(getPetType()!=SUMMON_PET && "Must be already removed.");
Remove(PET_SAVE_NOT_IN_SLOT); //hunters' pets never get removed because of death, NEVER!
@ -520,8 +520,8 @@ void Pet::Update(uint32 update_diff, uint32 tick_diff)
if (m_duration > 0)
{
if (m_duration > (int32)update_diff)
m_duration -= (int32)update_diff;
if(m_duration > (int32)diff)
m_duration -= (int32)diff;
else
{
Remove(getPetType() != SUMMON_PET ? PET_SAVE_AS_DELETED:PET_SAVE_NOT_IN_SLOT);
@ -530,7 +530,7 @@ void Pet::Update(uint32 update_diff, uint32 tick_diff)
}
//regenerate focus for hunter pets or energy for deathknight's ghoul
if (m_regenTimer <= update_diff)
if(m_regenTimer <= diff)
{
switch (getPowerType())
{
@ -544,25 +544,25 @@ void Pet::Update(uint32 update_diff, uint32 tick_diff)
m_regenTimer = 4000;
}
else
m_regenTimer -= update_diff;
m_regenTimer -= diff;
if (getPetType() != HUNTER_PET)
if(getPetType() != HUNTER_PET)
break;
if (m_happinessTimer <= update_diff)
if(m_happinessTimer <= diff)
{
LooseHappiness();
m_happinessTimer = 7500;
}
else
m_happinessTimer -= update_diff;
m_happinessTimer -= diff;
break;
}
default:
break;
}
Creature::Update(update_diff, tick_diff);
Creature::Update(diff);
}
void Pet::Regenerate(Powers power)

3
src/game/Pet.h
View file

@ -157,6 +157,7 @@ class Pet : public Creature
static void DeleteFromDB(uint32 guidlow);
void SetDeathState(DeathState s); // overwrite virtual Creature::SetDeathState and Unit::SetDeathState
void Update(uint32 diff); // overwrite virtual Creature::Update and Unit::Update
uint8 GetPetAutoSpellSize() const { return m_autospells.size(); }
uint32 GetPetAutoSpellOnPos(uint8 pos) const
@ -247,8 +248,6 @@ class Pet : public Creature
bool m_removed; // prevent overwrite pet state in DB at next Pet::Update if pet already removed(saved)
protected:
void Update(uint32 update_diff, uint32 tick_diff); // overwrite virtual Creature::Update and Unit::Update
uint32 m_happinessTimer;
PetType m_petType;
int32 m_duration; // time until unsummon (used mostly for summoned guardians and not used for controlled pets)

66
src/game/Player.cpp
View file

@ -1175,7 +1175,7 @@ void Player::SetDrunkValue(uint16 newDrunkenValue, uint32 itemId)
SendMessageToSet(&data, true);
}
void Player::Update(uint32 update_diff, uint32 tick_diff)
void Player::Update( uint32 p_time )
{
if(!IsInWorld())
return;
@ -1195,21 +1195,25 @@ void Player::Update(uint32 update_diff, uint32 tick_diff)
//used to implement delayed far teleports
SetCanDelayTeleport(true);
Unit::Update(update_diff, tick_diff);
Unit::Update( p_time );
SetCanDelayTeleport(false);
// update player only attacks
if (uint32 ranged_att = getAttackTimer(RANGED_ATTACK))
setAttackTimer(RANGED_ATTACK, (update_diff >= ranged_att ? 0 : ranged_att - update_diff) );
if(uint32 ranged_att = getAttackTimer(RANGED_ATTACK))
{
setAttackTimer(RANGED_ATTACK, (p_time >= ranged_att ? 0 : ranged_att - p_time) );
}
if (uint32 off_att = getAttackTimer(OFF_ATTACK))
setAttackTimer(OFF_ATTACK, (update_diff >= off_att ? 0 : off_att - update_diff) );
if(uint32 off_att = getAttackTimer(OFF_ATTACK))
{
setAttackTimer(OFF_ATTACK, (p_time >= off_att ? 0 : off_att - p_time) );
}
time_t now = time (NULL);
UpdatePvPFlag(now);
UpdateContestedPvP(update_diff);
UpdateContestedPvP(p_time);
UpdateDuelFlag(now);
@ -1227,7 +1231,7 @@ void Player::Update(uint32 update_diff, uint32 tick_diff)
while (iter != m_timedquests.end())
{
QuestStatusData& q_status = mQuestStatus[*iter];
if (q_status.m_timer <= update_diff)
if( q_status.m_timer <= p_time )
{
uint32 quest_id = *iter;
++iter; // current iter will be removed in FailQuest
@ -1235,7 +1239,7 @@ void Player::Update(uint32 update_diff, uint32 tick_diff)
}
else
{
q_status.m_timer -= update_diff;
q_status.m_timer -= p_time;
if (q_status.uState != QUEST_NEW) q_status.uState = QUEST_CHANGED;
++iter;
}
@ -1338,49 +1342,49 @@ void Player::Update(uint32 update_diff, uint32 tick_diff)
if (m_regenTimer)
{
if (update_diff >= m_regenTimer)
if(p_time >= m_regenTimer)
m_regenTimer = 0;
else
m_regenTimer -= update_diff;
m_regenTimer -= p_time;
}
if (m_weaponChangeTimer > 0)
{
if (update_diff >= m_weaponChangeTimer)
if(p_time >= m_weaponChangeTimer)
m_weaponChangeTimer = 0;
else
m_weaponChangeTimer -= update_diff;
m_weaponChangeTimer -= p_time;
}
if (m_zoneUpdateTimer > 0)
{
if (update_diff >= m_zoneUpdateTimer)
if(p_time >= m_zoneUpdateTimer)
{
uint32 newzone, newarea;
GetZoneAndAreaId(newzone,newarea);
if (m_zoneUpdateId != newzone)
if( m_zoneUpdateId != newzone )
UpdateZone(newzone,newarea); // also update area
else
{
// use area updates as well
// needed for free far all arenas for example
if (m_areaUpdateId != newarea)
if( m_areaUpdateId != newarea )
UpdateArea(newarea);
m_zoneUpdateTimer = ZONE_UPDATE_INTERVAL;
}
}
else
m_zoneUpdateTimer -= update_diff;
m_zoneUpdateTimer -= p_time;
}
if (m_timeSyncTimer > 0)
{
if (update_diff >= m_timeSyncTimer)
if(p_time >= m_timeSyncTimer)
SendTimeSync();
else
m_timeSyncTimer -= update_diff;
m_timeSyncTimer -= p_time;
}
if (isAlive())
@ -1396,31 +1400,31 @@ void Player::Update(uint32 update_diff, uint32 tick_diff)
if (m_deathState == JUST_DIED)
KillPlayer();
if (m_nextSave > 0)
if(m_nextSave > 0)
{
if (update_diff >= m_nextSave)
if(p_time >= m_nextSave)
{
// m_nextSave reseted in SaveToDB call
SaveToDB();
DETAIL_LOG("Player '%s' (GUID: %u) saved", GetName(), GetGUIDLow());
}
else
m_nextSave -= update_diff;
m_nextSave -= p_time;
}
//Handle Water/drowning
HandleDrowning(update_diff);
HandleDrowning(p_time);
//Handle detect stealth players
if (m_DetectInvTimer > 0)
{
if (update_diff >= m_DetectInvTimer)
if (p_time >= m_DetectInvTimer)
{
HandleStealthedUnitsDetection();
m_DetectInvTimer = 3000;
}
else
m_DetectInvTimer -= update_diff;
m_DetectInvTimer -= p_time;
}
// Played time
@ -1434,27 +1438,27 @@ void Player::Update(uint32 update_diff, uint32 tick_diff)
if (m_drunk)
{
m_drunkTimer += update_diff;
m_drunkTimer += p_time;
if (m_drunkTimer > 10*IN_MILLISECONDS)
HandleSobering();
}
// not auto-free ghost from body in instances
if (m_deathTimer > 0 && !GetBaseMap()->Instanceable())
if(m_deathTimer > 0 && !GetBaseMap()->Instanceable())
{
if(update_diff >= m_deathTimer)
if(p_time >= m_deathTimer)
{
m_deathTimer = 0;
BuildPlayerRepop();
RepopAtGraveyard();
}
else
m_deathTimer -= update_diff;
m_deathTimer -= p_time;
}
UpdateEnchantTime(update_diff);
UpdateHomebindTime(update_diff);
UpdateEnchantTime(p_time);
UpdateHomebindTime(p_time);
// group update
SendUpdateToOutOfRangeGroupMembers();

3
src/game/Player.h
View file

@ -1123,6 +1123,8 @@ class MANGOS_DLL_SPEC Player : public Unit
bool Create( uint32 guidlow, const std::string& name, uint8 race, uint8 class_, uint8 gender, uint8 skin, uint8 face, uint8 hairStyle, uint8 hairColor, uint8 facialHair, uint8 outfitId );
void Update( uint32 time );
static bool BuildEnumData( QueryResult * result, WorldPacket * p_data );
void SetInWater(bool apply);
@ -2401,7 +2403,6 @@ class MANGOS_DLL_SPEC Player : public Unit
bool canSeeSpellClickOn(Creature const* creature) const;
protected:
void Update(uint32 update_diff, uint32 tick_diff); // overwrite Unit::Update
uint32 m_contestedPvPTimer;

32
src/game/TemporarySummon.cpp
View file

@ -26,7 +26,7 @@ Creature(CREATURE_SUBTYPE_TEMPORARY_SUMMON), m_type(TEMPSUMMON_TIMED_OR_CORPSE_D
{
}
void TemporarySummon::Update(uint32 update_diff, uint32 tick_diff)
void TemporarySummon::Update( uint32 diff )
{
switch(m_type)
{
@ -34,26 +34,26 @@ void TemporarySummon::Update(uint32 update_diff, uint32 tick_diff)
break;
case TEMPSUMMON_TIMED_DESPAWN:
{
if (m_timer <= update_diff)
if (m_timer <= diff)
{
UnSummon();
return;
}
m_timer -= update_diff;
m_timer -= diff;
break;
}
case TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT:
{
if (!isInCombat())
{
if (m_timer <= update_diff)
if (m_timer <= diff)
{
UnSummon();
return;
}
m_timer -= update_diff;
m_timer -= diff;
}
else if (m_timer != m_lifetime)
m_timer = m_lifetime;
@ -63,22 +63,22 @@ void TemporarySummon::Update(uint32 update_diff, uint32 tick_diff)
case TEMPSUMMON_CORPSE_TIMED_DESPAWN:
{
if (m_deathState == CORPSE)
if ( m_deathState == CORPSE)
{
if (m_timer <= update_diff)
if (m_timer <= diff)
{
UnSummon();
return;
}
m_timer -= update_diff;
m_timer -= diff;
}
break;
}
case TEMPSUMMON_CORPSE_DESPAWN:
{
// if m_deathState is DEAD, CORPSE was skipped
if (m_deathState == CORPSE || m_deathState == DEAD)
if ( m_deathState == CORPSE || m_deathState == DEAD)
{
UnSummon();
return;
@ -88,7 +88,7 @@ void TemporarySummon::Update(uint32 update_diff, uint32 tick_diff)
}
case TEMPSUMMON_DEAD_DESPAWN:
{
if (m_deathState == DEAD)
if ( m_deathState == DEAD )
{
UnSummon();
return;
@ -98,7 +98,7 @@ void TemporarySummon::Update(uint32 update_diff, uint32 tick_diff)
case TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN:
{
// if m_deathState is DEAD, CORPSE was skipped
if (m_deathState == CORPSE || m_deathState == DEAD)
if ( m_deathState == CORPSE || m_deathState == DEAD)
{
UnSummon();
return;
@ -106,13 +106,13 @@ void TemporarySummon::Update(uint32 update_diff, uint32 tick_diff)
if (!isInCombat())
{
if (m_timer <= update_diff)
if (m_timer <= diff)
{
UnSummon();
return;
}
else
m_timer -= update_diff;
m_timer -= diff;
}
else if (m_timer != m_lifetime)
m_timer = m_lifetime;
@ -129,13 +129,13 @@ void TemporarySummon::Update(uint32 update_diff, uint32 tick_diff)
if (!isInCombat() && isAlive() )
{
if (m_timer <= update_diff)
if (m_timer <= diff)
{
UnSummon();
return;
}
else
m_timer -= update_diff;
m_timer -= diff;
}
else if (m_timer != m_lifetime)
m_timer = m_lifetime;
@ -147,7 +147,7 @@ void TemporarySummon::Update(uint32 update_diff, uint32 tick_diff)
break;
}
Creature::Update(update_diff, tick_diff);
Creature::Update( diff );
}
void TemporarySummon::Summon(TempSummonType type, uint32 lifetime)

3
src/game/TemporarySummon.h
View file

@ -27,13 +27,12 @@ class TemporarySummon : public Creature
public:
explicit TemporarySummon(ObjectGuid summoner = ObjectGuid());
virtual ~TemporarySummon(){};
void Update(uint32 time);
void Summon(TempSummonType type, uint32 lifetime);
void MANGOS_DLL_SPEC UnSummon();
void SaveToDB();
ObjectGuid const& GetSummonerGuid() const { return m_summoner ; }
Unit* GetSummoner() const { return ObjectAccessor::GetUnit(*this, m_summoner); }
protected:
void Update(uint32 update_diff, uint32 tick_diff); // overwrite Creature::Update
private:
TempSummonType m_type;
uint32 m_timer;

8
src/game/Totem.cpp
View file

@ -31,7 +31,7 @@ Totem::Totem() : Creature(CREATURE_SUBTYPE_TOTEM)
m_type = TOTEM_PASSIVE;
}
void Totem::Update(uint32 update_diff, uint32 tick_diff)
void Totem::Update( uint32 time )
{
Unit *owner = GetOwner();
if (!owner || !owner->isAlive() || !isAlive())
@ -40,15 +40,15 @@ void Totem::Update(uint32 update_diff, uint32 tick_diff)
return;
}
if (m_duration <= update_diff)
if (m_duration <= time)
{
UnSummon(); // remove self
return;
}
else
m_duration -= update_diff;
m_duration -= time;
Creature::Update(update_diff, tick_diff);
Creature::Update( time );
}
void Totem::Summon(Unit* owner)

3
src/game/Totem.h
View file

@ -33,6 +33,7 @@ class Totem : public Creature
public:
explicit Totem();
virtual ~Totem(){};
void Update( uint32 time );
void Summon(Unit* owner);
void UnSummon();
uint32 GetSpell() const { return m_spells[0]; }
@ -55,8 +56,6 @@ class Totem : public Creature
bool IsImmuneToSpellEffect(SpellEntry const* spellInfo, SpellEffectIndex index) const;
protected:
void Update(uint32 update_diff, uint32 tick_diff); // overwrite Creature::Update
TotemType m_type;
uint32 m_duration;
};

2
src/game/Transports.cpp
View file

@ -487,7 +487,7 @@ bool Transport::RemovePassenger(Player* passenger)
return true;
}
void Transport::Update(uint32 /*update_diff*/, uint32 /*tick_diff*/)
void Transport::Update(uint32 /*p_time*/)
{
if (m_WayPoints.size() <= 1)
return;

4
src/game/Transports.h
View file

@ -32,15 +32,13 @@ class Transport : public GameObject
bool Create(uint32 guidlow, uint32 mapid, float x, float y, float z, float ang, uint8 animprogress, uint16 dynamicHighValue);
bool GenerateWaypoints(uint32 pathid, std::set<uint32> &mapids);
void Update(uint32 p_time);
bool AddPassenger(Player* passenger);
bool RemovePassenger(Player* passenger);
typedef std::set<Player*> PlayerSet;
PlayerSet const& GetPassengers() const { return m_passengers; }
protected:
void Update(uint32 update_diff, uint32 tick_diff);
private:
struct WayPoint
{

24
src/game/Unit.cpp
View file

@ -291,7 +291,7 @@ Unit::~Unit()
MANGOS_ASSERT(m_deletedHolders.size() == 0);
}
void Unit::Update(uint32 update_diff, uint32 tick_diff)
void Unit::Update( uint32 p_time )
{
if(!IsInWorld())
return;
@ -306,21 +306,21 @@ void Unit::Update(uint32 update_diff, uint32 tick_diff)
// WARNING! Order of execution here is important, do not change.
// Spells must be processed with event system BEFORE they go to _UpdateSpells.
// Or else we may have some SPELL_STATE_FINISHED spells stalled in pointers, that is bad.
m_Events.Update(update_diff);
_UpdateSpells(update_diff);
m_Events.Update( p_time );
_UpdateSpells( p_time );
CleanupDeletedAuras();
if (m_lastManaUseTimer)
{
if (update_diff >= m_lastManaUseTimer)
if (p_time >= m_lastManaUseTimer)
m_lastManaUseTimer = 0;
else
m_lastManaUseTimer -= update_diff;
m_lastManaUseTimer -= p_time;
}
if (CanHaveThreatList())
getThreatManager().UpdateForClient(update_diff);
getThreatManager().UpdateForClient(p_time);
// update combat timer only for players and pets
if (isInCombat() && (GetTypeId() == TYPEID_PLAYER || ((Creature*)this)->IsPet() || ((Creature*)this)->isCharmed()))
@ -331,24 +331,26 @@ void Unit::Update(uint32 update_diff, uint32 tick_diff)
if (m_HostileRefManager.isEmpty())
{
// m_CombatTimer set at aura start and it will be freeze until aura removing
if (m_CombatTimer <= update_diff)
if (m_CombatTimer <= p_time)
CombatStop();
else
m_CombatTimer -= update_diff;
m_CombatTimer -= p_time;
}
}
if (uint32 base_att = getAttackTimer(BASE_ATTACK))
setAttackTimer(BASE_ATTACK, (update_diff >= base_att ? 0 : base_att - update_diff) );
{
setAttackTimer(BASE_ATTACK, (p_time >= base_att ? 0 : base_att - p_time) );
}
// update abilities available only for fraction of time
UpdateReactives(update_diff);
UpdateReactives( p_time );
ModifyAuraState(AURA_STATE_HEALTHLESS_20_PERCENT, GetHealth() < GetMaxHealth()*0.20f);
ModifyAuraState(AURA_STATE_HEALTHLESS_35_PERCENT, GetHealth() < GetMaxHealth()*0.35f);
ModifyAuraState(AURA_STATE_HEALTH_ABOVE_75_PERCENT, GetHealth() > GetMaxHealth()*0.75f);
i_motionMaster.UpdateMotion(tick_diff); // movegens expected non freeze time diff
i_motionMaster.UpdateMotion(p_time);
}
bool Unit::haveOffhandWeapon() const

3
src/game/Unit.h
View file

@ -1168,6 +1168,8 @@ class MANGOS_DLL_SPEC Unit : public WorldObject
void ApplyDiminishingAura(DiminishingGroup group, bool apply);
void ClearDiminishings() { m_Diminishing.clear(); }
virtual void Update( uint32 time );
void setAttackTimer(WeaponAttackType type, uint32 time) { m_attackTimer[type] = time; }
void resetAttackTimer(WeaponAttackType type = BASE_ATTACK);
uint32 getAttackTimer(WeaponAttackType type) const { return m_attackTimer[type]; }
@ -1927,7 +1929,6 @@ class MANGOS_DLL_SPEC Unit : public WorldObject
protected:
explicit Unit ();
void Update(uint32 update_diff, uint32 tick_diff); // overwrite WorldObject::Update
void _UpdateSpells(uint32 time);
void _UpdateAutoRepeatSpell();

4
src/game/Vehicle.cpp
View file

@ -56,9 +56,9 @@ void Vehicle::SetDeathState(DeathState s) // overwrite vir
Creature::SetDeathState(s);
}
void Vehicle::Update(uint32 update_diff, uint32 tick_diff)
void Vehicle::Update(uint32 diff)
{
Creature::Update(update_diff, tick_diff);
Creature::Update(diff);
}
bool Vehicle::Create(uint32 guidlow, Map *map, uint32 Entry, uint32 vehicleId, uint32 team)

3
src/game/Vehicle.h
View file

@ -36,6 +36,7 @@ class Vehicle : public Creature
bool Create (uint32 guidlow, Map *map, uint32 Entry, uint32 vehicleId, uint32 team);
void SetDeathState(DeathState s); // overwrite virtual Creature::SetDeathState and Unit::SetDeathState
void Update(uint32 diff); // overwrite virtual Creature::Update and Unit::Update
uint32 GetVehicleId() { return m_vehicleId; }
void SetVehicleId(uint32 vehicleid) { m_vehicleId = vehicleid; }
@ -43,8 +44,6 @@ class Vehicle : public Creature
void Dismiss();
protected:
void Update(uint32 update_diff, uint32 tick_diff); // overwrite virtual Creature::Update and Unit::Update
uint32 m_vehicleId;
private:

4
src/game/World.cpp
View file

@ -1380,7 +1380,7 @@ void World::DetectDBCLang()
}
/// Update the World !
void World::Update(uint32 time_, uint32 diff)
void World::Update(uint32 diff)
{
///- Update the different timers
for(int i = 0; i < WUPDATE_COUNT; ++i)
@ -1467,7 +1467,7 @@ void World::Update(uint32 time_, uint32 diff)
{
m_timers[WUPDATE_OBJECTS].Reset();
///- Update objects when the timer has passed (maps, transport, creatures,...)
sMapMgr.Update(time_, diff); // As interval = 0
sMapMgr.Update(diff); // As interval = 0
sBattleGroundMgr.Update(diff);
}

2
src/game/World.h
View file

@ -509,7 +509,7 @@ class World
static void StopNow(uint8 exitcode) { m_stopEvent = true; m_ExitCode = exitcode; }
static bool IsStopped() { return m_stopEvent; }
void Update(uint32 time_, uint32 diff);
void Update(uint32 diff);
void UpdateSessions( uint32 diff );

2
src/mangosd/WorldRunnable.cpp
View file

@ -57,7 +57,7 @@ void WorldRunnable::run()
uint32 diff = getMSTimeDiff(realPrevTime,realCurrTime);
sWorld.Update(realCurrTime, diff);
sWorld.Update( diff );
realPrevTime = realCurrTime;
// diff (D0) include time of previous sleep (d0) + tick time (t0)

2
src/shared/revision_nr.h
View file

@ -1,4 +1,4 @@
#ifndef __REVISION_NR_H__
#define __REVISION_NR_H__
#define REVISION_NR "10682"
#define REVISION_NR "10683"
#endif // __REVISION_NR_H__