[10688] New version of patch for send real diff from last update.

In new version last update time stopred for specific Cell that store all world objects
placed in it. All objects of Cell updated (or not updated) in same time.

Original version provided by ciphercom.

src/framework/GameSystem/Grid.h

@@ -117,12 +117,20 @@ class MANGOS_DLL_DECL Grid
             return i_container.template remove<SPECIFIC_OBJECT>(obj);
         }
 
+        uint32 SetLastUpdateTimeAndReturnDiff(uint32 newtime)
+        {
+            uint32 realdiff = getMSTimeDiff(m_LastUpdateTime,newtime);
+            m_LastUpdateTime = newtime;
+            return realdiff;
+        }
+
     private:
 
         TypeMapContainer<GRID_OBJECT_TYPES> i_container;
         TypeMapContainer<WORLD_OBJECT_TYPES> i_objects;
         typedef std::set<void*> ActiveGridObjects;
         ActiveGridObjects m_activeGridObjects;
+        uint32 m_LastUpdateTime;                            // last time when Update call has been or current started, used and set Map::Update
 };
 
 #endif

src/game/Creature.cpp

@@ -406,7 +406,7 @@ uint32 Creature::ChooseDisplayId(const CreatureInfo *cinfo, const CreatureData *
     return display_id;
 }
 
-void Creature::Update(uint32 diff)
+void Creature::Update(uint32 update_diff, uint32 tick_diff)
 {
     if (m_needNotify)
     {
@@ -467,7 +467,7 @@ void Creature::Update(uint32 diff)
             if (m_isDeadByDefault)
                 break;
 
-            if (m_corpseDecayTimer <= diff)
+            if (m_corpseDecayTimer <= update_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 diff)
             }
             else
             {
-                m_corpseDecayTimer -= diff;
+                m_corpseDecayTimer -= update_diff;
                 if (m_groupLootId)
                 {
-                    if(diff < m_groupLootTimer)
+                    if(update_diff < m_groupLootTimer)
-                        m_groupLootTimer -= diff;
+                        m_groupLootTimer -= update_diff;
                     else
                         StopGroupLoot();
                 }
@@ -498,7 +498,7 @@ void Creature::Update(uint32 diff)
         {
             if (m_isDeadByDefault)
             {
-                if (m_corpseDecayTimer <= diff)
+                if (m_corpseDecayTimer <= update_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 diff)
                 }
                 else
                 {
-                    m_corpseDecayTimer -= diff;
+                    m_corpseDecayTimer -= update_diff;
                 }
             }
 
-            Unit::Update( diff );
+            Unit::Update(update_diff, tick_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 diff)
             {
                 // do not allow the AI to be changed during update
                 m_AI_locked = true;
-                i_AI->UpdateAI(diff);
+                i_AI->UpdateAI(tick_diff);                  // AI not react good at real update delays (while freeze in non-active part of map)
                 m_AI_locked = false;
             }
 
@@ -541,10 +541,10 @@ void Creature::Update(uint32 diff)
                 break;
             if(m_regenTimer > 0)
             {
-                if(diff >= m_regenTimer)
+                if(update_diff >= m_regenTimer)
                     m_regenTimer = 0;
                 else
-                    m_regenTimer -= diff;
+                    m_regenTimer -= update_diff;
             }
             if (m_regenTimer != 0)
                 break;

src/game/Creature.h

@@ -402,7 +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 Update(uint32 update_diff, uint32 tick_diff);  // overwrite WorldObject::Update 
         void GetRespawnCoord(float &x, float &y, float &z, float* ori = NULL, float* dist =NULL) const;
         uint32 GetEquipmentId() const { return m_equipmentId; }
 

src/game/DynamicObject.cpp

@@ -106,7 +106,7 @@ Unit* DynamicObject::GetCaster() const
     return ObjectAccessor::GetUnit(*this, GetCasterGUID());
 }
 
-void DynamicObject::Update(uint32 p_time)
+void DynamicObject::Update(uint32 update_diff, uint32 /*tick_diff*/)
 {
     // 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 p_time)
 
     bool deleteThis = false;
 
-    if(m_aliveDuration > int32(p_time))
+    if(m_aliveDuration > int32(update_diff))
-        m_aliveDuration -= p_time;
+        m_aliveDuration -= update_diff;
     else
         deleteThis = true;
 

src/game/DynamicObject.h

@@ -35,7 +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 Update(uint32 update_diff, uint32 tick_diff);  // overwrite WorldObject::Update 
         void Delete();
         uint32 GetSpellId() const { return m_spellId; }
         SpellEffectIndex GetEffIndex() const { return m_effIndex; }

src/game/GameObject.cpp

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

src/game/GameObject.h

@@ -588,7 +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);
+        void Update(uint32 update_diff, uint32 tick_diff);  // overwrite WorldObject::Update 
         GameObjectInfo const* GetGOInfo() const;
 
         bool IsTransport() const;

src/game/GridNotifiers.cpp

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

src/game/GridNotifiers.h

@@ -61,13 +61,14 @@ namespace MaNGOS
     struct MANGOS_DLL_DECL GridUpdater
     {
         GridType &i_grid;
+        uint32 i_realdiff;
         uint32 i_timeDiff;
-        GridUpdater(GridType &grid, uint32 diff) : i_grid(grid), i_timeDiff(diff) {}
+        GridUpdater(GridType &grid, uint32 realdiff, uint32 diff) : i_grid(grid), i_realdiff(realdiff), 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()->Update(i_timeDiff);
+                iter->getSource()->Update(i_realdiff, i_timeDiff);
         }
 
         void Visit(PlayerMapType &m) { updateObjects<Player>(m); }
@@ -136,8 +137,9 @@ namespace MaNGOS
 
     struct MANGOS_DLL_DECL ObjectUpdater
     {
-        uint32 i_timeDiff;
+        uint32 i_realdiff;                                  // time from last update in msecs 
-        explicit ObjectUpdater(const uint32 &diff) : i_timeDiff(diff) {}
+        uint32 i_diff;                                      // current tick time diff in msecs 
+        explicit ObjectUpdater(uint32 realdiff, uint32 diff) : i_realdiff(realdiff), i_diff(diff) {}
         template<class T> void Visit(GridRefManager<T> &m);
         void Visit(PlayerMapType &) {}
         void Visit(CorpseMapType &) {}

src/game/GridNotifiersImpl.h

@@ -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()->Update(i_timeDiff);
+        iter->getSource()->Update(i_realdiff, i_diff);
 }
 
 inline void PlayerCreatureRelocationWorker(Player* pl, WorldObject const* viewPoint, Creature* c)

src/game/Map.cpp

@@ -131,7 +131,8 @@ Map::Map(uint32 id, time_t expiry, uint32 InstanceId, uint8 SpawnMode, Map* _par
   i_id(id), i_InstanceId(InstanceId), m_unloadTimer(0),
   m_VisibleDistance(DEFAULT_VISIBILITY_DISTANCE), m_instanceSave(NULL),
   m_activeNonPlayersIter(m_activeNonPlayers.end()),
-  i_gridExpiry(expiry), m_parentMap(_parent ? _parent : this)
+  i_gridExpiry(expiry), m_parentMap(_parent ? _parent : this),
+  m_lastUpdateTime(getMSTime())                             // expected that next update call will not long after map creating
 {
     for(unsigned int idx=0; idx < MAX_NUMBER_OF_GRIDS; ++idx)
     {
@@ -510,25 +511,19 @@ 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(const uint32 &t_diff)
+void Map::Update(uint32 time_, uint32 diff)
 {
+    m_lastUpdateTime = time_;
+
     /// update players at tick
     for(m_mapRefIter = m_mapRefManager.begin(); m_mapRefIter != m_mapRefManager.end(); ++m_mapRefIter)
-    {
+        if (Player* plr = m_mapRefIter->getSource())
-        Player* plr = m_mapRefIter->getSource();
+            if (plr->IsInWorld())
-        if(plr && plr->IsInWorld())
+                plr->Update(diff, diff);
-            plr->Update(t_diff);
-    }
 
     /// update active cells around players and active objects
     resetMarkedCells();
 
-    MaNGOS::ObjectUpdater updater(t_diff);
-    // for creature
-    TypeContainerVisitor<MaNGOS::ObjectUpdater, GridTypeMapContainer  > grid_object_update(updater);
-    // for pets
-    TypeContainerVisitor<MaNGOS::ObjectUpdater, WorldTypeMapContainer > world_object_update(updater);
-
     // the player iterator is stored in the map object
     // to make sure calls to Map::Remove don't invalidate it
     for(m_mapRefIter = m_mapRefManager.begin(); m_mapRefIter != m_mapRefManager.end(); ++m_mapRefIter)
@@ -561,9 +556,21 @@ void Map::Update(const uint32 &t_diff)
                 if(!isCellMarked(cell_id))
                 {
                     markCell(cell_id);
+
                     CellPair pair(x,y);
                     Cell cell(pair);
                     cell.SetNoCreate();
+
+                    uint32 realdiff = diff;
+                    if (loaded(cell.gridPair()) )
+                        realdiff = (*getNGrid(cell.GridX(),cell.GridY()))(cell.CellX(),cell.CellY()).SetLastUpdateTimeAndReturnDiff(time_);
+
+                    MaNGOS::ObjectUpdater updater(realdiff, diff);
+                    // for creature
+                    TypeContainerVisitor<MaNGOS::ObjectUpdater, GridTypeMapContainer  > grid_object_update(updater);
+                    // for pets
+                    TypeContainerVisitor<MaNGOS::ObjectUpdater, WorldTypeMapContainer > world_object_update(updater);
+
                     Visit(cell, grid_object_update);
                     Visit(cell, world_object_update);
                 }
@@ -608,9 +615,21 @@ void Map::Update(const uint32 &t_diff)
                     if(!isCellMarked(cell_id))
                     {
                         markCell(cell_id);
+
                         CellPair pair(x,y);
                         Cell cell(pair);
                         cell.SetNoCreate();
+
+                        uint32 realdiff = diff;
+                        if (loaded(cell.gridPair()) )
+                            realdiff = (*getNGrid(cell.GridX(),cell.GridY()))(cell.CellX(),cell.CellY()).SetLastUpdateTimeAndReturnDiff(time_);
+
+                        MaNGOS::ObjectUpdater updater(realdiff, diff);
+                        // for creature
+                        TypeContainerVisitor<MaNGOS::ObjectUpdater, GridTypeMapContainer  > grid_object_update(updater);
+                        // for pets
+                        TypeContainerVisitor<MaNGOS::ObjectUpdater, WorldTypeMapContainer > world_object_update(updater);
+
                         Visit(cell, grid_object_update);
                         Visit(cell, world_object_update);
                     }
@@ -632,7 +651,7 @@ void Map::Update(const uint32 &t_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(), t_diff);
+            sMapMgr.UpdateGridState(grid->GetGridState(), *this, *grid, *info, grid->getX(), grid->getY(), diff);
         }
     }
 
@@ -1840,17 +1859,17 @@ bool InstanceMap::Add(Player *player)
     return true;
 }
 
-void InstanceMap::Update(const uint32& t_diff)
+void InstanceMap::Update(uint32 time_, uint32 diff)
 {
-    Map::Update(t_diff);
+    Map::Update(time_, diff);
 
     if(i_data)
-        i_data->Update(t_diff);
+        i_data->Update(diff);
 }
 
-void BattleGroundMap::Update(const uint32& diff)
+void BattleGroundMap::Update(uint32 time_, uint32 diff)
 {
-    Map::Update(diff);
+    Map::Update(time_, diff);
 
     GetBG()->Update(diff);
 }

src/game/Map.h

@@ -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(const uint32&);
+        virtual void Update(uint32 time_, uint32 diff);
 
         void MessageBroadcast(Player *, WorldPacket *, bool to_self);
         void MessageBroadcast(WorldObject *, WorldPacket *);
@@ -270,6 +270,8 @@ class MANGOS_DLL_SPEC Map : public GridRefManager<NGridType>, public MaNGOS::Obj
         uint32 GenerateLocalLowGuid(HighGuid guidhigh);
         bool GetAreaInfo(float x, float y, float z, uint32 &mogpflags, int32 &adtId, int32 &rootId, int32 &groupId) const;
         bool IsOutdoors(float x, float y, float z) const;
+
+        uint32 GetLastUpdateTime() const { return m_lastUpdateTime; }
     private:
         void LoadMapAndVMap(int gx, int gy);
         void LoadVMap(int gx, int gy);
@@ -346,6 +348,8 @@ class MANGOS_DLL_SPEC Map : public GridRefManager<NGridType>, public MaNGOS::Obj
         std::set<WorldObject *> i_objectsToRemove;
         std::multimap<time_t, ScriptAction> m_scriptSchedule;
 
+        uint32 m_lastUpdateTime;                            // time in past when called Update last time, set to object at adding to Map
+
         // Map local low guid counters
         ObjectGuidGenerator<HIGHGUID_DYNAMICOBJECT> m_DynObjectGuids;
         ObjectGuidGenerator<HIGHGUID_PET> m_PetGuids;
@@ -382,7 +386,7 @@ class MANGOS_DLL_SPEC InstanceMap : public Map
         ~InstanceMap();
         bool Add(Player *);
         void Remove(Player *, bool);
-        void Update(const uint32&);
+        void Update(uint32 time_, uint32 diff);
         void CreateInstanceData(bool load);
         bool Reset(uint8 method);
         uint32 GetScriptId() { return i_script_id; }
@@ -407,7 +411,7 @@ class MANGOS_DLL_SPEC BattleGroundMap : public Map
         BattleGroundMap(uint32 id, time_t, uint32 InstanceId, Map* _parent, uint8 spawnMode);
         ~BattleGroundMap();
 
-        void Update(const uint32&);
+        void Update(uint32 time_, uint32 diff);
         bool Add(Player *);
         void Remove(Player *, bool);
         bool CanEnter(Player* player);

src/game/MapInstanced.cpp

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

src/game/MapInstanced.h

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

src/game/MapManager.cpp

@@ -239,17 +239,17 @@ void MapManager::DeleteInstance(uint32 mapid, uint32 instanceId)
 }
 
 void
-MapManager::Update(uint32 diff)
+MapManager::Update(const uint32 time_, const 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(i_timer.GetCurrent());
+        iter->second->Update(time_, i_timer.GetCurrent());
 
     for (TransportSet::iterator iter = m_Transports.begin(); iter != m_Transports.end(); ++iter)
-        (*iter)->Update(i_timer.GetCurrent());
+        (*iter)->Update(i_timer.GetCurrent(), i_timer.GetCurrent());
 
     i_timer.SetCurrent(0);
 }

src/game/MapManager.h

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

src/game/Object.h

@@ -342,7 +342,7 @@ class MANGOS_DLL_SPEC WorldObject : public Object
     public:
         virtual ~WorldObject ( ) {}
 
-        virtual void Update ( uint32 /*time_diff*/ ) { }
+        virtual void Update(uint32 /*update_diff*/, uint32 /*tick_diff*/) { }
 
         void _Create( uint32 guidlow, HighGuid guidhigh, uint32 phaseMask);
 
@@ -492,6 +492,7 @@ class MANGOS_DLL_SPEC WorldObject : public Object
         bool isActiveObject() const { return m_isActiveObject || m_viewPoint.hasViewers(); }
 
         ViewPoint& GetViewPoint() { return m_viewPoint; }
+
     protected:
         explicit WorldObject();
 

src/game/ObjectGridLoader.cpp

@@ -227,6 +227,8 @@ ObjectGridLoader::Load(GridType &grid)
 
 void ObjectGridLoader::LoadN(void)
 {
+    uint32 updatetime = i_map->GetLastUpdateTime();
+
     i_gameObjects = 0; i_creatures = 0; i_corpses = 0;
     i_cell.data.Part.cell_y = 0;
     for(unsigned int x=0; x < MAX_NUMBER_OF_CELLS; ++x)
@@ -237,6 +239,9 @@ void ObjectGridLoader::LoadN(void)
             i_cell.data.Part.cell_y = y;
             GridLoader<Player, AllWorldObjectTypes, AllGridObjectTypes> loader;
             loader.Load(i_grid(x, y), *this);
+
+            // setup last update time for loaded cell
+            i_grid(x, y).SetLastUpdateTimeAndReturnDiff(updatetime);
         }
     }
     DEBUG_LOG("%u GameObjects, %u Creatures, and %u Corpses/Bones loaded for grid %u on map %u", i_gameObjects, i_creatures, i_corpses,i_grid.GetGridId(), i_map->GetId());

src/game/Pet.cpp

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

src/game/Pet.h

@@ -157,7 +157,8 @@ 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
+        void Update(uint32 update_diff, uint32 tick_diff);  // overwrite WorldObject::Update 
+
 
         uint8 GetPetAutoSpellSize() const { return m_autospells.size(); }
         uint32 GetPetAutoSpellOnPos(uint8 pos) const

src/game/Player.cpp

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

src/game/Player.h

@@ -1123,7 +1123,7 @@ 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 );
+        void Update(uint32 update_diff, uint32 tick_diff);  // overwrite WorldObject::Update 
 
         static bool BuildEnumData( QueryResult * result,  WorldPacket * p_data );
 

src/game/TemporarySummon.cpp

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

src/game/TemporarySummon.h

@@ -27,7 +27,7 @@ class TemporarySummon : public Creature
     public:
         explicit TemporarySummon(ObjectGuid summoner = ObjectGuid());
         virtual ~TemporarySummon(){};
-        void Update(uint32 time);
+        void Update(uint32 update_diff, uint32 tick_diff);  // overwrite WorldObject::Update 
         void Summon(TempSummonType type, uint32 lifetime);
         void MANGOS_DLL_SPEC UnSummon();
         void SaveToDB();

src/game/Totem.cpp

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

src/game/Totem.h

@@ -33,7 +33,7 @@ class Totem : public Creature
     public:
         explicit Totem();
         virtual ~Totem(){};
-        void Update( uint32 time );
+        void Update(uint32 update_diff, uint32 tick_diff);  // overwrite WorldObject::Update 
         void Summon(Unit* owner);
         void UnSummon();
         uint32 GetSpell() const { return m_spells[0]; }

src/game/Transports.cpp

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

src/game/Transports.h

@@ -32,7 +32,7 @@ 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);
+        void Update(uint32 update_diff, uint32 tick_diff);  // overwrite WorldObject::Update 
         bool AddPassenger(Player* passenger);
         bool RemovePassenger(Player* passenger);
 

src/game/Unit.cpp

@@ -291,7 +291,7 @@ Unit::~Unit()
     MANGOS_ASSERT(m_deletedHolders.size() == 0);
 }
 
-void Unit::Update( uint32 p_time )
+void Unit::Update(uint32 update_diff, uint32 tick_diff)
 {
     if(!IsInWorld())
         return;
@@ -306,21 +306,21 @@ void Unit::Update( uint32 p_time )
     // 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( p_time );
+    m_Events.Update(update_diff);
-    _UpdateSpells( p_time );
+    _UpdateSpells(update_diff);
 
     CleanupDeletedAuras();
 
     if (m_lastManaUseTimer)
     {
-        if (p_time >= m_lastManaUseTimer)
+        if (update_diff >= m_lastManaUseTimer)
             m_lastManaUseTimer = 0;
         else
-            m_lastManaUseTimer -= p_time;
+            m_lastManaUseTimer -= update_diff;
     }
 
     if (CanHaveThreatList())
-        getThreatManager().UpdateForClient(p_time);
+        getThreatManager().UpdateForClient(update_diff);
 
     // update combat timer only for players and pets
     if (isInCombat() && (GetTypeId() == TYPEID_PLAYER || ((Creature*)this)->IsPet() || ((Creature*)this)->isCharmed()))
@@ -331,26 +331,24 @@ void Unit::Update( uint32 p_time )
         if (m_HostileRefManager.isEmpty())
         {
             // m_CombatTimer set at aura start and it will be freeze until aura removing
-            if (m_CombatTimer <= p_time)
+            if (m_CombatTimer <= update_diff)
                 CombatStop();
             else
-                m_CombatTimer -= p_time;
+                m_CombatTimer -= update_diff;
         }
     }
 
     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( p_time );
+    UpdateReactives(update_diff);
 
     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(p_time);
+    i_motionMaster.UpdateMotion(tick_diff);                 // movegens expected non freeze time diff
 }
 
 bool Unit::haveOffhandWeapon() const

src/game/Unit.h

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

src/game/Vehicle.cpp

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

src/game/Vehicle.h

@@ -36,7 +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
+        void Update(uint32 update_diff, uint32 tick_diff);  // overwrite WorldObject::Update 
 
         uint32 GetVehicleId() { return m_vehicleId; }
         void SetVehicleId(uint32 vehicleid) { m_vehicleId = vehicleid; }

src/game/World.cpp

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

src/game/World.h

@@ -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 diff);
+        void Update(uint32 time_, uint32 diff);
 
         void UpdateSessions( uint32 diff );
 

src/mangosd/WorldRunnable.cpp

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

src/shared/revision_nr.h

@@ -1,4 +1,4 @@
 #ifndef __REVISION_NR_H__
 #define __REVISION_NR_H__
- #define REVISION_NR "10687"
+ #define REVISION_NR "10688"
 #endif // __REVISION_NR_H__