[Core/Maps] Activate creatures and objects during opening cinematics and other flyby

cameras (sunwell etc).

Requires re-running map extractor to extract camera m2 files from data
files. These are very small.

Closes #4755
Closes #16772

4 files changed, 259 insertions, 8 deletions

diff --git a/src/server/game/DataStores/DBCStores.cpp b/src/server/game/DataStores/DBCStores.cpp
index 0e9b50d64c5..5ede70da2a3 100644
--- a/src/server/game/DataStores/DBCStores.cpp
+++ b/src/server/game/DataStores/DBCStores.cpp
@@ -27,6 +27,9 @@
 
 #include <boost/regex.hpp>
 #include <map>
+#include <fstream>
+#include <iostream>
+#include <iomanip>
 
 typedef std::map<uint16, uint32> AreaFlagByAreaID;
 typedef std::map<uint32, uint32> AreaFlagByMapID;
@@ -73,6 +76,7 @@ DBCStorage <CharTitlesEntry> sCharTitlesStore(CharTitlesEntryfmt);
 DBCStorage <ChatChannelsEntry> sChatChannelsStore(ChatChannelsEntryfmt);
 DBCStorage <ChrClassesEntry> sChrClassesStore(ChrClassesEntryfmt);
 DBCStorage <ChrRacesEntry> sChrRacesStore(ChrRacesEntryfmt);
+DBCStorage <CinematicCameraEntry> sCinematicCameraStore(CinematicCameraEntryfmt);
 DBCStorage <CinematicSequencesEntry> sCinematicSequencesStore(CinematicSequencesEntryfmt);
 DBCStorage <CreatureDisplayInfoEntry> sCreatureDisplayInfoStore(CreatureDisplayInfofmt);
 DBCStorage <CreatureDisplayInfoExtraEntry> sCreatureDisplayInfoExtraStore(CreatureDisplayInfoExtrafmt);
@@ -217,6 +221,8 @@ DBCStorage <WorldMapAreaEntry> sWorldMapAreaStore(WorldMapAreaEntryfmt);
 DBCStorage <WorldMapOverlayEntry> sWorldMapOverlayStore(WorldMapOverlayEntryfmt);
 DBCStorage <WorldSafeLocsEntry> sWorldSafeLocsStore(WorldSafeLocsEntryfmt);
 
+std::unordered_map<uint32, FlyByCameraCollection> sFlyByCameraStore;
+
 typedef std::list<std::string> StoreProblemList;
 
 uint32 DBCFileCount = 0;
@@ -311,6 +317,7 @@ void LoadDBCStores(const std::string& dataPath)
     LoadDBC(availableDbcLocales, bad_dbc_files, sChatChannelsStore,           dbcPath, "ChatChannels.dbc");
     LoadDBC(availableDbcLocales, bad_dbc_files, sChrClassesStore,             dbcPath, "ChrClasses.dbc");
     LoadDBC(availableDbcLocales, bad_dbc_files, sChrRacesStore,               dbcPath, "ChrRaces.dbc");
+    LoadDBC(availableDbcLocales, bad_dbc_files, sCinematicCameraStore,        dbcPath, "CinematicCamera.dbc");
     LoadDBC(availableDbcLocales, bad_dbc_files, sCinematicSequencesStore,     dbcPath, "CinematicSequences.dbc");
     LoadDBC(availableDbcLocales, bad_dbc_files, sCreatureDisplayInfoStore,    dbcPath, "CreatureDisplayInfo.dbc");
     LoadDBC(availableDbcLocales, bad_dbc_files, sCreatureDisplayInfoExtraStore, dbcPath, "CreatureDisplayInfoExtra.dbc");
@@ -717,10 +724,250 @@ void LoadDBCStores(const std::string& dataPath)
         exit(1);
     }
 
+    LoadM2Cameras(dataPath);
+
     TC_LOG_INFO("server.loading", ">> Initialized %d data stores in %u ms", DBCFileCount, GetMSTimeDiffToNow(oldMSTime));
 
 }
 
+// Convert the geomoetry from a spline value, to an actual WoW XYZ
+G3D::Vector3 TranslateLocation(G3D::Vector4 const* DBCPosition, G3D::Vector3 const* basePosition, G3D::Vector3 const* splineVector)
+{
+    G3D::Vector3 work;
+    float x = basePosition->x + splineVector->x;
+    float y = basePosition->y + splineVector->y;
+    float z = basePosition->z + splineVector->z;
+    float const distance = sqrt((x * x) + (y * y));
+    float angle = std::atan2(x, y) - DBCPosition->w;
+
+    if (angle < 0)
+        angle += 2 * float(M_PI);
+
+    work.x = DBCPosition->x + (distance * sin(angle));
+    work.y = DBCPosition->y + (distance * cos(angle));
+    work.z = DBCPosition->z + z;
+    return work;
+}
+
+// Number of cameras not used. Multiple cameras never used in 3.3.5
+bool readCamera(M2Camera const* cam, uint32 buffSize, M2Header const* header, CinematicCameraEntry const* dbcentry)
+{
+    char const* buffer = reinterpret_cast<char const*>(header);
+
+    FlyByCameraCollection cameras;
+    FlyByCameraCollection targetcam;
+
+    G3D::Vector4 DBCData;
+    DBCData.x = dbcentry->base_x;
+    DBCData.y = dbcentry->base_y;
+    DBCData.z = dbcentry->base_z;
+    DBCData.w = dbcentry->base_o;
+
+    // Read target locations, only so that we can calculate orientation
+    for (uint32 k = 0; k < cam->target_positions.timestamps.number; ++k)
+    {
+        // Extract Target positions
+        if (cam->target_positions.timestamps.offset_elements + sizeof(M2Array) > buffSize)
+            return false;
+        M2Array const* targTsArray = reinterpret_cast<M2Array const*>(buffer + cam->target_positions.timestamps.offset_elements);
+        if (targTsArray->offset_elements + sizeof(uint32) > buffSize || cam->target_positions.values.offset_elements + sizeof(M2Array) > buffSize)
+            return false;
+        uint32 const* targTimestamps = reinterpret_cast<uint32 const*>(buffer + targTsArray->offset_elements);
+        M2Array const* targArray = reinterpret_cast<M2Array const*>(buffer + cam->target_positions.values.offset_elements);
+
+        if (targArray->offset_elements + sizeof(M2SplineKey<G3D::Vector3>) > buffSize)
+            return false;
+        M2SplineKey<G3D::Vector3> const* targPositions = reinterpret_cast<M2SplineKey<G3D::Vector3> const*>(buffer + targArray->offset_elements);
+
+        // Read the data for this set
+        uint32 currPos = targArray->offset_elements;
+        for (uint32 i = 0; i < targTsArray->number; ++i)
+        {
+            if (currPos + sizeof(M2SplineKey<G3D::Vector3>) > buffSize)
+                return false;
+            // Translate co-ordinates
+            G3D::Vector3 newPos = TranslateLocation(&DBCData, &cam->target_position_base, &targPositions->p0);
+
+            // Add to vector
+            FlyByCamera thisCam;
+            thisCam.timeStamp = targTimestamps[i];
+            thisCam.locations.x = newPos.x;
+            thisCam.locations.y = newPos.y;
+            thisCam.locations.z = newPos.z;
+            thisCam.locations.w = 0.0f;
+            targetcam.push_back(thisCam);
+            targPositions++;
+            currPos += sizeof(M2SplineKey<G3D::Vector3>);
+        }
+    }
+
+    // Read camera positions and timestamps (translating first position of 3 only, we don't need to translate the whole spline)
+    for (uint32 k = 0; k < cam->positions.timestamps.number; ++k)
+    {
+        // Extract Camera positions for this set
+        if (cam->positions.timestamps.offset_elements + sizeof(M2Array) > buffSize)
+            return false;
+        M2Array const* posTsArray = reinterpret_cast<M2Array const*>(buffer + cam->positions.timestamps.offset_elements);
+        if (posTsArray->offset_elements + sizeof(uint32) > buffSize || cam->positions.values.offset_elements + sizeof(M2Array) > buffSize)
+            return false;
+        uint32 const* posTimestamps = reinterpret_cast<uint32 const*>(buffer + posTsArray->offset_elements);
+        M2Array const* posArray = reinterpret_cast<M2Array const*>(buffer + cam->positions.values.offset_elements);
+        if (posArray->offset_elements + sizeof(M2SplineKey<G3D::Vector3>) > buffSize)
+            return false;
+        M2SplineKey<G3D::Vector3> const* positions = reinterpret_cast<M2SplineKey<G3D::Vector3> const*>(buffer + posArray->offset_elements);
+
+        // Read the data for this set
+        uint32 currPos = posArray->offset_elements;
+        for (uint32 i = 0; i < posTsArray->number; ++i)
+        {
+            if (currPos + sizeof(M2SplineKey<G3D::Vector3>) > buffSize)
+                return false;
+            // Translate co-ordinates
+            G3D::Vector3 newPos = TranslateLocation(&DBCData, &cam->position_base, &positions->p0);
+
+            // Add to vector
+            FlyByCamera thisCam;
+            thisCam.timeStamp = posTimestamps[i];
+            thisCam.locations.x = newPos.x;
+            thisCam.locations.y = newPos.y;
+            thisCam.locations.z = newPos.z;
+
+            if (targetcam.size() > 0)
+            {
+                // Find the target camera before and after this camera
+                FlyByCamera lastTarget;
+                FlyByCamera nextTarget;
+
+                // Pre-load first item
+                lastTarget = targetcam[0];
+                nextTarget = targetcam[0];
+                for (uint32 j = 0; j < targetcam.size(); ++j)
+                {
+                    nextTarget = targetcam[j];
+                    if (targetcam[j].timeStamp > posTimestamps[i])
+                        break;
+
+                    lastTarget = targetcam[j];
+                }
+
+                float x = lastTarget.locations.x;
+                float y = lastTarget.locations.y;
+                float z = lastTarget.locations.z;
+
+                // Now, the timestamps for target cam and position can be different. So, if they differ we interpolate
+                if (lastTarget.timeStamp != posTimestamps[i])
+                {
+                    uint32 timeDiffTarget = nextTarget.timeStamp - lastTarget.timeStamp;
+                    uint32 timeDiffThis = posTimestamps[i] - lastTarget.timeStamp;
+                    float xDiff = nextTarget.locations.x - lastTarget.locations.x;
+                    float yDiff = nextTarget.locations.y - lastTarget.locations.y;
+                    float zDiff = nextTarget.locations.z - lastTarget.locations.z;
+                    x = lastTarget.locations.x + (xDiff * (float(timeDiffThis) / float(timeDiffTarget)));
+                    y = lastTarget.locations.y + (yDiff * (float(timeDiffThis) / float(timeDiffTarget)));
+                    z = lastTarget.locations.z + (zDiff * (float(timeDiffThis) / float(timeDiffTarget)));
+                }
+                float xDiff = x - thisCam.locations.x;
+                float yDiff = y - thisCam.locations.y;
+                thisCam.locations.w = std::atan2(yDiff, xDiff);
+
+                if (thisCam.locations.w < 0)
+                    thisCam.locations.w += 2 * float(M_PI);
+            }
+
+            cameras.push_back(thisCam);
+            positions++;
+            currPos += sizeof(M2SplineKey<G3D::Vector3>);
+        }
+    }
+
+    sFlyByCameraStore[dbcentry->id] = cameras;
+    return true;
+}
+
+void LoadM2Cameras(const std::string& dataPath)
+{
+    sFlyByCameraStore.clear();
+    TC_LOG_INFO("server.loading", ">> Loading Cinematic Camera files");
+
+    uint32 oldMSTime = getMSTime();
+    for (uint32 i = 0; i < sCinematicCameraStore.GetNumRows(); ++i)
+    {
+        if (CinematicCameraEntry const* dbcentry = sCinematicCameraStore.LookupEntry(i))
+        {
+            std::string filename = dataPath.c_str();
+            filename.append(dbcentry->filename);
+
+            // Replace slashes
+            size_t loc = filename.find("\\");
+            while (loc != std::string::npos)
+            {
+                filename.replace(loc, 1, "/");
+                loc = filename.find("\\");
+            }
+
+            // Replace mdx to .m2
+            loc = filename.find(".mdx");
+            if (loc != std::string::npos)
+                filename.replace(loc, 4, ".m2");
+
+            std::ifstream m2file(filename.c_str(), std::ios::in | std::ios::binary);
+            if (!m2file.is_open())
+                continue;
+
+            // Get file size
+            m2file.seekg(0, std::ios::end);
+            std::streamoff const fileSize = m2file.tellg();
+
+            // Reject if not at least the size of the header
+            if (static_cast<uint32 const>(fileSize) < sizeof(M2Header))
+            {
+                TC_LOG_ERROR("server.loading", "Camera file %s is damaged. File is smaller than header size", filename.c_str());
+                m2file.close();
+                continue;
+            }
+
+            // Read 4 bytes (signature)
+            m2file.seekg(0, std::ios::beg);
+            char fileCheck[5];
+            m2file.read(fileCheck, 4);
+            fileCheck[4] = 0;
+
+            // Check file has correct magic (MD20)
+            if (strcmp(fileCheck, "MD20"))
+            {
+                TC_LOG_ERROR("server.loading", "Camera file %s is damaged. File identifier not found", filename.c_str());
+                m2file.close();
+                continue;
+            }
+
+            // Now we have a good file, read it all into a vector of char's, then close the file.
+            std::vector<char> buffer(fileSize);
+            m2file.seekg(0, std::ios::beg);
+            if (!m2file.read(buffer.data(), fileSize))
+            {
+                m2file.close();
+                continue;
+            }
+            m2file.close();
+
+            // Read header
+            M2Header const* header = reinterpret_cast<M2Header const*>(buffer.data());
+
+            if (header->ofsCameras + sizeof(M2Camera) > static_cast<uint32 const>(fileSize))
+            {
+                TC_LOG_ERROR("server.loading", "Camera file %s is damaged. Camera references position beyond file end", filename.c_str());
+                continue;
+            }
+
+            // Get camera(s) - Main header, then dump them.
+            M2Camera const* cam = reinterpret_cast<M2Camera const*>(buffer.data() + header->ofsCameras);
+            if (!readCamera(cam, fileSize, header, dbcentry))
+                TC_LOG_ERROR("server.loading", "Camera file %s is damaged. Camera references position beyond file end", filename.c_str());
+        }
+    }
+    TC_LOG_INFO("server.loading", ">> Loaded %u cinematic waypoint sets in %u ms", (uint32)sFlyByCameraStore.size(), GetMSTimeDiffToNow(oldMSTime));
+}
+
 SimpleFactionsList const* GetFactionTeamList(uint32 faction)
 {
     FactionTeamMap::const_iterator itr = sFactionTeamMap.find(faction);
diff --git a/src/server/game/DataStores/DBCStores.h b/src/server/game/DataStores/DBCStores.h
index beb0bb514cc..6cad13fdf9a 100644
--- a/src/server/game/DataStores/DBCStores.h
+++ b/src/server/game/DataStores/DBCStores.h
@@ -27,6 +27,8 @@
 #include <list>
 
 typedef std::list<uint32> SimpleFactionsList;
+typedef std::vector<FlyByCamera> FlyByCameraCollection;
+
 TC_GAME_API SimpleFactionsList const* GetFactionTeamList(uint32 faction);
 
 TC_GAME_API char* GetPetName(uint32 petfamily, uint32 dbclang);
@@ -96,6 +98,7 @@ TC_GAME_API extern DBCStorage <CharSectionsEntry>            sCharSectionsStore;
 TC_GAME_API extern DBCStorage <CharTitlesEntry>              sCharTitlesStore;
 TC_GAME_API extern DBCStorage <ChrClassesEntry>              sChrClassesStore;
 TC_GAME_API extern DBCStorage <ChrRacesEntry>                sChrRacesStore;
+TC_GAME_API extern DBCStorage <CinematicCameraEntry>         sCinematicCameraStore;
 TC_GAME_API extern DBCStorage <CinematicSequencesEntry>      sCinematicSequencesStore;
 TC_GAME_API extern DBCStorage <CreatureDisplayInfoEntry>     sCreatureDisplayInfoStore;
 TC_GAME_API extern DBCStorage <CreatureDisplayInfoExtraEntry> sCreatureDisplayInfoExtraStore;
@@ -193,7 +196,9 @@ TC_GAME_API extern DBCStorage <WMOAreaTableEntry>            sWMOAreaTableStore;
 //TC_GAME_API extern DBCStorage <WorldMapAreaEntry>           sWorldMapAreaStore; -- use Zone2MapCoordinates and Map2ZoneCoordinates
 TC_GAME_API extern DBCStorage <WorldMapOverlayEntry>         sWorldMapOverlayStore;
 TC_GAME_API extern DBCStorage <WorldSafeLocsEntry>           sWorldSafeLocsStore;
+TC_GAME_API extern std::unordered_map<uint32, FlyByCameraCollection> sFlyByCameraStore;
 
 TC_GAME_API void LoadDBCStores(const std::string& dataPath);
+TC_GAME_API void LoadM2Cameras(const std::string& dataPath);
 
 #endif
diff --git a/src/server/game/DataStores/DBCStructure.h b/src/server/game/DataStores/DBCStructure.h
index b5dc4489148..51b3dcbd38b 100644
--- a/src/server/game/DataStores/DBCStructure.h
+++ b/src/server/game/DataStores/DBCStructure.h
@@ -725,24 +725,22 @@ struct ChrRacesEntry
     uint32      expansion;                                  // 68 (0 - original race, 1 - tbc addon, ...)
 };
 
-/* not used
 struct CinematicCameraEntry
 {
     uint32      id;                                         // 0 index
     char*       filename;                                   // 1
     uint32      soundid;                                    // 2 in SoundEntries.dbc or 0
-    float       start_x;                                    // 3
-    float       start_y;                                    // 4
-    float       start_z;                                    // 5
-    float       unk6;                                       // 6 speed?
+    float       base_x;                                     // 3
+    float       base_y;                                     // 4
+    float       base_z;                                     // 5
+    float       base_o;                                     // 6
 };
-*/
 
 struct CinematicSequencesEntry
 {
     uint32      Id;                                         // 0 index
     //uint32      unk1;                                     // 1 always 0
-    //uint32      cinematicCamera;                          // 2 id in CinematicCamera.dbc
+    uint32      cinematicCamera;                            // 2 id in CinematicCamera.dbc
                                                             // 3-9 always 0
 };
 
diff --git a/src/server/game/DataStores/DBCfmt.h b/src/server/game/DataStores/DBCfmt.h
index c61ec997bc2..1accc81714b 100644
--- a/src/server/game/DataStores/DBCfmt.h
+++ b/src/server/game/DataStores/DBCfmt.h
@@ -38,7 +38,8 @@ char const CharTitlesEntryfmt[] = "nxssssssssssssssssxssssssssssssssssxi";
 char const ChatChannelsEntryfmt[] = "nixssssssssssssssssxxxxxxxxxxxxxxxxxx";
 char const ChrClassesEntryfmt[] = "nxixssssssssssssssssxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxixii";
 char const ChrRacesEntryfmt[] = "niixiixixxxxixssssssssssssssssxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxi";
-char const CinematicSequencesEntryfmt[] = "nxxxxxxxxx";
+char const CinematicCameraEntryfmt[] = "nsiffff";
+char const CinematicSequencesEntryfmt[] = "nxixxxxxxx";
 char const CreatureDisplayInfofmt[] = "nixifxxxxxxxxxxx";
 char const CreatureDisplayInfoExtrafmt[] = "diixxxxxxxxxxxxxxxxxx";
 char const CreatureFamilyfmt[] = "nfifiiiiixssssssssssssssssxx";