Merge branch '6.x' of https://github.com/TrinityCore/TrinityCore into legion

3 files changed, 74 insertions, 234 deletions

diff --git a/src/server/game/Entities/Object/Object.cpp b/src/server/game/Entities/Object/Object.cpp
index 028f954744f..39538213461 100644
--- a/src/server/game/Entities/Object/Object.cpp
+++ b/src/server/game/Entities/Object/Object.cpp
@@ -28,7 +28,6 @@
 #include "Vehicle.h"
 #include "ObjectMgr.h"
 #include "UpdateData.h"
-#include "UpdateMask.h"
 #include "Util.h"
 #include "ObjectAccessor.h"
 #include "Transport.h"
@@ -46,6 +45,7 @@
 #include "BattlefieldMgr.h"
 #include "GameObjectPackets.h"
 #include "MiscPackets.h"
+#include <boost/dynamic_bitset.hpp>
 
 Object::Object()
 {
@@ -108,15 +108,14 @@ Object::~Object()
 void Object::_InitValues()
 {
     m_uint32Values = new uint32[m_valuesCount];
-    memset(m_uint32Values, 0, m_valuesCount*sizeof(uint32));
+    memset(m_uint32Values, 0, m_valuesCount * sizeof(uint32));
 
-    _changesMask.SetCount(m_valuesCount);
-
-    _dynamicChangesMask.SetCount(_dynamicValuesCount);
+    _changesMask.resize(m_valuesCount);
+    _dynamicChangesMask.resize(_dynamicValuesCount);
     if (_dynamicValuesCount)
     {
         _dynamicValues = new std::vector<uint32>[_dynamicValuesCount];
-        _dynamicChangesArrayMask = new UpdateMask[_dynamicValuesCount];
+        _dynamicChangesArrayMask = new std::vector<uint8>[_dynamicValuesCount];
     }
 
     m_objectUpdated = false;
@@ -765,27 +764,27 @@ void Object::BuildValuesUpdate(uint8 updateType, ByteBuffer* data, Player* targe
     if (!target)
         return;
 
-    ByteBuffer fieldBuffer;
-    UpdateMask updateMask;
-    updateMask.SetCount(m_valuesCount);
+    boost::dynamic_bitset<uint32> updateMask(m_valuesCount);
 
     uint32* flags = NULL;
     uint32 visibleFlag = GetUpdateFieldData(target, flags);
     ASSERT(flags);
 
+    *data << uint8(updateMask.num_blocks());
+    std::size_t maskPos = data->wpos();
+    data->resize(data->size() + updateMask.num_blocks() * sizeof(uint32));
+
     for (uint16 index = 0; index < m_valuesCount; ++index)
     {
         if (_fieldNotifyFlags & flags[index] ||
-            ((updateType == UPDATETYPE_VALUES ? _changesMask.GetBit(index) : m_uint32Values[index]) && (flags[index] & visibleFlag)))
+            ((updateType == UPDATETYPE_VALUES ? _changesMask[index] : m_uint32Values[index]) && (flags[index] & visibleFlag)))
         {
-            updateMask.SetBit(index);
-            fieldBuffer << m_uint32Values[index];
+            updateMask.set(index);
+            *data << m_uint32Values[index];
         }
     }
 
-    *data << uint8(updateMask.GetBlockCount());
-    updateMask.AppendToPacket(data);
-    data->append(fieldBuffer);
+    boost::to_block_range(updateMask, reinterpret_cast<uint32*>(data->contents() + maskPos));
 }
 
 void Object::BuildDynamicValuesUpdate(uint8 updateType, ByteBuffer* data, Player* target) const
@@ -793,42 +792,41 @@ void Object::BuildDynamicValuesUpdate(uint8 updateType, ByteBuffer* data, Player
     if (!target)
         return;
 
-    ByteBuffer fieldBuffer;
-    UpdateMask updateMask;
-    updateMask.SetCount(_dynamicValuesCount);
+    boost::dynamic_bitset<uint32> updateMask(_dynamicValuesCount);
 
     uint32* flags = nullptr;
     uint32 visibleFlag = GetDynamicUpdateFieldData(target, flags);
 
+    *data << uint8(updateMask.num_blocks());
+    std::size_t maskPos = data->wpos();
+    data->resize(data->size() + updateMask.num_blocks() * sizeof(uint32));
+
     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)))
+            ((updateType == UPDATETYPE_VALUES ? _dynamicChangesMask[index] : !values.empty()) && (flags[index] & visibleFlag)))
         {
-            updateMask.SetBit(index);
+            updateMask.set(index);
 
-            UpdateMask arrayMask;
-            arrayMask.SetCount(values.size());
+            boost::dynamic_bitset<uint32> arrayMask(values.size());
+            *data << uint16(arrayMask.num_blocks());
+            std::size_t fieldMaskPos = data->wpos();
+            data->resize(data->size() + arrayMask.num_blocks() * sizeof(uint32));
             for (std::size_t v = 0; v < values.size(); ++v)
             {
-                if (updateType == UPDATETYPE_VALUES ? _dynamicChangesArrayMask[index].GetBit(v) : values[v])
+                if (updateType == UPDATETYPE_VALUES ? _dynamicChangesArrayMask[index][v] : values[v])
                 {
-                    arrayMask.SetBit(v);
-                    buffer << uint32(values[v]);
+                    arrayMask.set(v);
+                    *data << uint32(values[v]);
                 }
             }
 
-            fieldBuffer << uint16(arrayMask.GetBlockCount());
-            arrayMask.AppendToPacket(&fieldBuffer);
-            fieldBuffer.append(buffer);
+            boost::to_block_range(arrayMask, reinterpret_cast<uint32*>(data->contents() + fieldMaskPos));
         }
     }
 
-    *data << uint8(updateMask.GetBlockCount());
-    updateMask.AppendToPacket(data);
-    data->append(fieldBuffer);
+    boost::to_block_range(updateMask, reinterpret_cast<uint32*>(data->contents() + maskPos));
 }
 
 void Object::AddToObjectUpdateIfNeeded()
@@ -842,10 +840,10 @@ void Object::AddToObjectUpdateIfNeeded()
 
 void Object::ClearUpdateMask(bool remove)
 {
-    _changesMask.Clear();
-    _dynamicChangesMask.Clear();
+    memset(_changesMask.data(), 0, _changesMask.size());
+    memset(_dynamicChangesMask.data(), 0, _dynamicChangesMask.size());
     for (uint32 i = 0; i < _dynamicValuesCount; ++i)
-        _dynamicChangesArrayMask[i].Clear();
+        memset(_dynamicChangesArrayMask[i].data(), 0, _dynamicChangesArrayMask[i].size());
 
     if (m_objectUpdated)
     {
@@ -990,7 +988,7 @@ void Object::_LoadIntoDataField(std::string const& data, uint32 startOffset, uin
     for (uint32 index = 0; index < count; ++index)
     {
         m_uint32Values[startOffset + index] = atoul(tokens[index]);
-        _changesMask.SetBit(startOffset + index);
+        _changesMask[startOffset + index] = 1;
     }
 }
 
@@ -1001,7 +999,7 @@ void Object::SetInt32Value(uint16 index, int32 value)
     if (m_int32Values[index] != value)
     {
         m_int32Values[index] = value;
-        _changesMask.SetBit(index);
+        _changesMask[index] = 1;
 
         AddToObjectUpdateIfNeeded();
     }
@@ -1014,7 +1012,7 @@ void Object::SetUInt32Value(uint16 index, uint32 value)
     if (m_uint32Values[index] != value)
     {
         m_uint32Values[index] = value;
-        _changesMask.SetBit(index);
+        _changesMask[index] = 1;
 
         AddToObjectUpdateIfNeeded();
     }
@@ -1025,7 +1023,7 @@ void Object::UpdateUInt32Value(uint16 index, uint32 value)
     ASSERT(index < m_valuesCount || PrintIndexError(index, true));
 
     m_uint32Values[index] = value;
-    _changesMask.SetBit(index);
+    _changesMask[index] = 1;
 }
 
 void Object::SetUInt64Value(uint16 index, uint64 value)
@@ -1035,8 +1033,8 @@ void Object::SetUInt64Value(uint16 index, uint64 value)
     {
         m_uint32Values[index] = PAIR64_LOPART(value);
         m_uint32Values[index + 1] = PAIR64_HIPART(value);
-        _changesMask.SetBit(index);
-        _changesMask.SetBit(index + 1);
+        _changesMask[index] = 1;
+        _changesMask[index + 1] = 1;
 
         AddToObjectUpdateIfNeeded();
     }
@@ -1048,10 +1046,10 @@ bool Object::AddGuidValue(uint16 index, ObjectGuid const& value)
     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);
+        _changesMask[index] = 1;
+        _changesMask[index + 1] = 1;
+        _changesMask[index + 2] = 1;
+        _changesMask[index + 3] = 1;
 
         AddToObjectUpdateIfNeeded();
         return true;
@@ -1066,10 +1064,10 @@ bool Object::RemoveGuidValue(uint16 index, ObjectGuid const& value)
     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);
+        _changesMask[index] = 1;
+        _changesMask[index + 1] = 1;
+        _changesMask[index + 2] = 1;
+        _changesMask[index + 3] = 1;
 
         AddToObjectUpdateIfNeeded();
         return true;
@@ -1085,7 +1083,7 @@ void Object::SetFloatValue(uint16 index, float value)
     if (m_floatValues[index] != value)
     {
         m_floatValues[index] = value;
-        _changesMask.SetBit(index);
+        _changesMask[index] = 1;
 
         AddToObjectUpdateIfNeeded();
     }
@@ -1105,7 +1103,7 @@ void Object::SetByteValue(uint16 index, uint8 offset, uint8 value)
     {
         m_uint32Values[index] &= ~uint32(uint32(0xFF) << (offset * 8));
         m_uint32Values[index] |= uint32(uint32(value) << (offset * 8));
-        _changesMask.SetBit(index);
+        _changesMask[index] = 1;
 
         AddToObjectUpdateIfNeeded();
     }
@@ -1125,7 +1123,7 @@ void Object::SetUInt16Value(uint16 index, uint8 offset, uint16 value)
     {
         m_uint32Values[index] &= ~uint32(uint32(0xFFFF) << (offset * 16));
         m_uint32Values[index] |= uint32(uint32(value) << (offset * 16));
-        _changesMask.SetBit(index);
+        _changesMask[index] = 1;
 
         AddToObjectUpdateIfNeeded();
     }
@@ -1137,10 +1135,10 @@ void Object::SetGuidValue(uint16 index, ObjectGuid const& value)
     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);
+        _changesMask[index] = 1;
+        _changesMask[index + 1] = 1;
+        _changesMask[index + 2] = 1;
+        _changesMask[index + 3] = 1;
 
         AddToObjectUpdateIfNeeded();
     }
@@ -1219,7 +1217,7 @@ void Object::SetFlag(uint16 index, uint32 newFlag)
     if (oldval != newval)
     {
         m_uint32Values[index] = newval;
-        _changesMask.SetBit(index);
+        _changesMask[index] = 1;
 
         AddToObjectUpdateIfNeeded();
     }
@@ -1236,7 +1234,7 @@ void Object::RemoveFlag(uint16 index, uint32 oldFlag)
     if (oldval != newval)
     {
         m_uint32Values[index] = newval;
-        _changesMask.SetBit(index);
+        _changesMask[index] = 1;
 
         AddToObjectUpdateIfNeeded();
     }
@@ -1276,7 +1274,7 @@ void Object::SetByteFlag(uint16 index, uint8 offset, uint8 newFlag)
     if (!(uint8(m_uint32Values[index] >> (offset * 8)) & newFlag))
     {
         m_uint32Values[index] |= uint32(uint32(newFlag) << (offset * 8));
-        _changesMask.SetBit(index);
+        _changesMask[index] = 1;
 
         AddToObjectUpdateIfNeeded();
     }
@@ -1295,7 +1293,7 @@ void Object::RemoveByteFlag(uint16 index, uint8 offset, uint8 oldFlag)
     if (uint8(m_uint32Values[index] >> (offset * 8)) & oldFlag)
     {
         m_uint32Values[index] &= ~uint32(uint32(oldFlag) << (offset * 8));
-        _changesMask.SetBit(index);
+        _changesMask[index] = 1;
 
         AddToObjectUpdateIfNeeded();
     }
@@ -1365,21 +1363,7 @@ uint32 Object::GetDynamicValue(uint16 index, uint16 offset) const
 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();
+    SetDynamicValue(index, _dynamicValues[index].size(), value);
 }
 
 void Object::RemoveDynamicValue(uint16 index, uint32 value)
@@ -1393,8 +1377,8 @@ void Object::RemoveDynamicValue(uint16 index, uint32 value)
         if (values[i] == value)
         {
             values[i] = 0;
-            _dynamicChangesMask.SetBit(index);
-            _dynamicChangesArrayMask[index].SetBit(i);
+            _dynamicChangesMask[index] = 1;
+            _dynamicChangesArrayMask[index][i] = 1;
 
             AddToObjectUpdateIfNeeded();
         }
@@ -1408,8 +1392,8 @@ void Object::ClearDynamicValue(uint16 index)
     if (!_dynamicValues[index].empty())
     {
         _dynamicValues[index].clear();
-        _dynamicChangesMask.SetBit(index);
-        _dynamicChangesArrayMask[index].SetCount(0);
+        _dynamicChangesMask[index] = 1;
+        _dynamicChangesArrayMask[index].clear();
 
         AddToObjectUpdateIfNeeded();
     }
@@ -1420,14 +1404,17 @@ void Object::SetDynamicValue(uint16 index, uint16 offset, uint32 value)
     ASSERT(index < _dynamicValuesCount || PrintIndexError(index, false));
 
     std::vector<uint32>& values = _dynamicValues[index];
+    if (values.size() <= offset)
+        values.resize(offset + 1);
 
-    ASSERT(offset < values.size());
+    if (_dynamicChangesArrayMask[index].size() <= offset)
+        _dynamicChangesArrayMask[index].resize((offset / 32 + 1) * 32);
 
     if (values[offset] != value)
     {
         values[offset] = value;
-        _dynamicChangesMask.SetBit(index);
-        _dynamicChangesArrayMask[index].SetBit(offset);
+        _dynamicChangesMask[index] = 1;
+        _dynamicChangesArrayMask[index][offset] = 1;
 
         AddToObjectUpdateIfNeeded();
     }
@@ -2171,7 +2158,7 @@ bool WorldObject::CanDetectStealthOf(WorldObject const* obj, bool checkAlert) co
 
 void Object::ForceValuesUpdateAtIndex(uint32 i)
 {
-    _changesMask.SetBit(i);
+    _changesMask[i] = 1;
     AddToObjectUpdateIfNeeded();
 }
 
diff --git a/src/server/game/Entities/Object/Object.h b/src/server/game/Entities/Object/Object.h
index 07e6acdfa0b..3dc53538d23 100644
--- a/src/server/game/Entities/Object/Object.h
+++ b/src/server/game/Entities/Object/Object.h
@@ -21,10 +21,10 @@
 
 #include "Common.h"
 #include "Position.h"
-#include "UpdateMask.h"
 #include "GridReference.h"
 #include "ObjectDefines.h"
 #include "Map.h"
+#include "UpdateFields.h"
 
 #include <set>
 #include <string>
@@ -239,9 +239,9 @@ class TC_GAME_API Object
 
         std::vector<uint32>* _dynamicValues;
 
-        UpdateMask _changesMask;
-        UpdateMask _dynamicChangesMask;
-        UpdateMask* _dynamicChangesArrayMask;
+        std::vector<uint8> _changesMask;
+        std::vector<uint8> _dynamicChangesMask;
+        std::vector<uint8>* _dynamicChangesArrayMask;
 
         uint16 m_valuesCount;
         uint16 _dynamicValuesCount;
diff --git a/src/server/game/Entities/Object/Updates/UpdateMask.h b/src/server/game/Entities/Object/Updates/UpdateMask.h
deleted file mode 100644
index cadc905ffe1..00000000000
--- a/src/server/game/Entities/Object/Updates/UpdateMask.h
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
- * Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
- * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation; either version 2 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef __UPDATEMASK_H
-#define __UPDATEMASK_H
-
-#include "UpdateFields.h"
-#include "Errors.h"
-#include "ByteBuffer.h"
-
-class UpdateMask
-{
-    public:
-        /// Type representing how client reads update mask
-        typedef uint32 ClientUpdateMaskType;
-
-        enum UpdateMaskCount
-        {
-            CLIENT_UPDATE_MASK_BITS = sizeof(ClientUpdateMaskType) * 8,
-        };
-
-        UpdateMask() : _fieldCount(0), _blockCount(0), _bits(NULL) { }
-
-        UpdateMask(UpdateMask const& right) : _bits(NULL)
-        {
-            SetCount(right.GetCount());
-            memcpy(_bits, right._bits, sizeof(uint8) * _blockCount * 32);
-        }
-
-        ~UpdateMask() { delete[] _bits; }
-
-        void SetBit(uint32 index) { _bits[index] = 1; }
-        void UnsetBit(uint32 index) { _bits[index] = 0; }
-        bool GetBit(uint32 index) const { return _bits[index] != 0; }
-
-        void AppendToPacket(ByteBuffer* data)
-        {
-            for (uint32 i = 0; i < GetBlockCount(); ++i)
-            {
-                ClientUpdateMaskType maskPart = 0;
-                for (uint32 j = 0; j < CLIENT_UPDATE_MASK_BITS; ++j)
-                    if (_bits[CLIENT_UPDATE_MASK_BITS * i + j])
-                        maskPart |= 1 << j;
-
-                *data << maskPart;
-            }
-        }
-
-        uint32 GetBlockCount() const { return _blockCount; }
-        uint32 GetCount() const { return _fieldCount; }
-
-        void SetCount(uint32 valuesCount)
-        {
-            delete[] _bits;
-
-            _fieldCount = valuesCount;
-            _blockCount = (valuesCount + CLIENT_UPDATE_MASK_BITS - 1) / CLIENT_UPDATE_MASK_BITS;
-
-            if (!valuesCount)
-            {
-                _bits = nullptr;
-                return;
-            }
-
-            _bits = new uint8[_blockCount * CLIENT_UPDATE_MASK_BITS];
-            memset(_bits, 0, sizeof(uint8) * _blockCount * CLIENT_UPDATE_MASK_BITS);
-        }
-
-        void AddBlock()
-        {
-            uint8* curr = _bits;
-            _fieldCount += CLIENT_UPDATE_MASK_BITS;
-            ++_blockCount;
-
-            _bits = new uint8[_blockCount * CLIENT_UPDATE_MASK_BITS];
-            memset(&_bits[(_blockCount - 1) * CLIENT_UPDATE_MASK_BITS], 0, CLIENT_UPDATE_MASK_BITS);
-            if (curr)
-            {
-                memcpy(_bits, curr, sizeof(uint8) * (_blockCount - 1) * CLIENT_UPDATE_MASK_BITS);
-                delete[] curr;
-            }
-        }
-
-        void Clear()
-        {
-            if (_bits)
-                memset(_bits, 0, sizeof(uint8) * _blockCount * CLIENT_UPDATE_MASK_BITS);
-        }
-
-        UpdateMask& operator=(UpdateMask const& right)
-        {
-            if (this == &right)
-                return *this;
-
-            SetCount(right.GetCount());
-            memcpy(_bits, right._bits, sizeof(uint8) * _blockCount * CLIENT_UPDATE_MASK_BITS);
-            return *this;
-        }
-
-        UpdateMask& operator&=(UpdateMask const& right)
-        {
-            ASSERT(right.GetCount() <= GetCount());
-            for (uint32 i = 0; i < _fieldCount; ++i)
-                _bits[i] &= right._bits[i];
-
-            return *this;
-        }
-
-        UpdateMask& operator|=(UpdateMask const& right)
-        {
-            ASSERT(right.GetCount() <= GetCount());
-            for (uint32 i = 0; i < _fieldCount; ++i)
-                _bits[i] |= right._bits[i];
-
-            return *this;
-        }
-
-        UpdateMask operator|(UpdateMask const& right)
-        {
-            UpdateMask ret(*this);
-            ret |= right;
-            return ret;
-        }
-
-    private:
-        uint32 _fieldCount;
-        uint32 _blockCount;
-        uint8* _bits;
-};
-
-#endif
-