Tools/map_extractor: Minor cleanup

* Make temporary tile variables local to ConvertADT
* std::string -> std::string_view for adt chunk lookup
* Replace the only std::ofstream with FILE*
* Remove _CRT_SECURE_NO_DEPRECATE from source files (should only be set on command line)

4 files changed, 110 insertions, 137 deletions

diff --git a/src/tools/map_extractor/System.cpp b/src/tools/map_extractor/System.cpp
index e50eb89bf86..64016200fad 100644
--- a/src/tools/map_extractor/System.cpp
+++ b/src/tools/map_extractor/System.cpp
@@ -26,17 +26,17 @@
 #include "Locales.h"
 #include "MapDefines.h"
 #include "MapUtils.h"
+#include "Memory.h"
 #include "StringFormat.h"
 #include "Util.h"
 #include "adt.h"
 #include "wdt.h"
+#include "advstd.h"
 #include <CascLib.h>
 #include <boost/filesystem/directory.hpp>
 #include <boost/filesystem/operations.hpp>
 #include <boost/filesystem/path.hpp>
 #include <bitset>
-#include <deque>
-#include <fstream>
 #include <set>
 #include <unordered_map>
 #include <cstdio>
@@ -426,24 +426,6 @@ float selectUInt16StepStore(float maxDiff)
 {
     return 65535 / maxDiff;
 }
-// Temporary grid data store
-uint16 area_ids[ADT_CELLS_PER_GRID][ADT_CELLS_PER_GRID];
-
-float V8[ADT_GRID_SIZE][ADT_GRID_SIZE];
-float V9[ADT_GRID_SIZE+1][ADT_GRID_SIZE+1];
-uint16 uint16_V8[ADT_GRID_SIZE][ADT_GRID_SIZE];
-uint16 uint16_V9[ADT_GRID_SIZE+1][ADT_GRID_SIZE+1];
-uint8  uint8_V8[ADT_GRID_SIZE][ADT_GRID_SIZE];
-uint8  uint8_V9[ADT_GRID_SIZE+1][ADT_GRID_SIZE+1];
-
-uint16 liquid_entry[ADT_CELLS_PER_GRID][ADT_CELLS_PER_GRID];
-map_liquidHeaderTypeFlags liquid_flags[ADT_CELLS_PER_GRID][ADT_CELLS_PER_GRID];
-bool  liquid_show[ADT_GRID_SIZE][ADT_GRID_SIZE];
-float liquid_height[ADT_GRID_SIZE+1][ADT_GRID_SIZE+1];
-uint8 holes[ADT_CELLS_PER_GRID][ADT_CELLS_PER_GRID][8];
-
-int16 flight_box_max[3][3];
-int16 flight_box_min[3][3];
 
 LiquidVertexFormatType adt_MH2O::GetLiquidVertexFormat(adt_liquid_instance const* liquidInstance) const
 {
@@ -464,11 +446,11 @@ LiquidVertexFormatType adt_MH2O::GetLiquidVertexFormat(adt_liquid_instance const
     return static_cast<LiquidVertexFormatType>(-1);
 }
 
-bool TransformToHighRes(uint16 lowResHoles, uint8 hiResHoles[8])
+bool TransformToHighRes(uint16 lowResHoles, uint8(& hiResHoles)[8])
 {
-    for (uint8 i = 0; i < 8; i++)
+    for (int32 i = 0; i < 8; i++)
     {
-        for (uint8 j = 0; j < 8; j++)
+        for (int32 j = 0; j < 8; j++)
         {
             int32 holeIdxL = (i / 2) * 4 + (j / 2);
             if (((lowResHoles >> holeIdxL) & 1) == 1)
@@ -476,7 +458,16 @@ bool TransformToHighRes(uint16 lowResHoles, uint8 hiResHoles[8])
         }
     }
 
-    return *((uint64*)hiResHoles) != 0;
+    return advstd::bit_cast<uint64>(hiResHoles) != 0;
+}
+
+template <typename T, std::size_t N>
+using Array2D = T[N][N];
+
+template <typename T, std::size_t N>
+inline static void WriteArray2D(Array2D<T, N> const& data, FILE* f)
+{
+    (void)::fwrite(&data[0][0], sizeof(T), N * N, f);
 }
 
 bool ConvertADT(ChunkedFile& adt, std::string const& mapName, std::string const& outputPath, int gx, int gy, uint32 build, bool ignoreDeepWater)
@@ -488,22 +479,31 @@ bool ConvertADT(ChunkedFile& adt, std::string const& mapName, std::string const&
     map.buildMagic = build;
 
     // Get area flags data
-    memset(area_ids, 0, sizeof(area_ids));
-    memset(V9, 0, sizeof(V9));
-    memset(V8, 0, sizeof(V8));
+    Array2D<uint16, ADT_CELLS_PER_GRID> area_ids = { };
 
-    memset(liquid_show, 0, sizeof(liquid_show));
-    memset(liquid_flags, 0, sizeof(liquid_flags));
-    memset(liquid_entry, 0, sizeof(liquid_entry));
+    Array2D<float, ADT_GRID_SIZE + 1> V9 = { };
+    Array2D<float, ADT_GRID_SIZE> V8 = { };
+    Array2D<uint16, ADT_GRID_SIZE + 1> uint16_V9 = { };
+    Array2D<uint16, ADT_GRID_SIZE> uint16_V8 = { };
+    Array2D<uint8, ADT_GRID_SIZE + 1> uint8_V9 = { };
+    Array2D<uint8, ADT_GRID_SIZE> uint8_V8 = { };
 
-    memset(holes, 0, sizeof(holes));
+    Array2D<bool, ADT_GRID_SIZE> liquid_show = { };
+    Array2D<map_liquidHeaderTypeFlags, ADT_CELLS_PER_GRID> liquid_flags = { };
+    Array2D<uint16, ADT_CELLS_PER_GRID> liquid_entry = { };
+    Array2D<float, ADT_GRID_SIZE + 1> liquid_height = { };
+
+    Array2D<uint8[8], ADT_CELLS_PER_GRID> holes = { };
+
+    Array2D<int16, 3> flight_box_max = { };
+    Array2D<int16, 3> flight_box_min = { };
 
     bool hasHoles = false;
     bool hasFlightBox = false;
 
     for (auto const& [_, rawChunk] : Trinity::Containers::MapEqualRange(adt.chunks, "MCNK"))
     {
-        adt_MCNK* mcnk = rawChunk->As<adt_MCNK>();
+        adt_MCNK* mcnk = rawChunk.As<adt_MCNK>();
 
         // Area data
         area_ids[mcnk->iy][mcnk->ix] = mcnk->areaid;
@@ -548,7 +548,7 @@ bool ConvertADT(ChunkedFile& adt, std::string const& mapName, std::string const&
         }
 
         // Get custom height
-        if (FileChunk* chunk = rawChunk->GetSubChunk("MCVT"))
+        if (FileChunk const* chunk = rawChunk.GetSubChunk("MCVT"))
         {
             adt_MCVT* mcvt = chunk->As<adt_MCVT>();
             // get V9 height map
@@ -577,7 +577,7 @@ bool ConvertADT(ChunkedFile& adt, std::string const& mapName, std::string const&
         // Liquid data
         if (mcnk->sizeMCLQ > 8)
         {
-            if (FileChunk* chunk = rawChunk->GetSubChunk("MCLQ"))
+            if (FileChunk const* chunk = rawChunk.GetSubChunk("MCLQ"))
             {
                 adt_MCLQ* liquid = chunk->As<adt_MCLQ>();
                 int count = 0;
@@ -639,13 +639,13 @@ bool ConvertADT(ChunkedFile& adt, std::string const& mapName, std::string const&
         else
         {
             memcpy(holes[mcnk->iy][mcnk->ix], mcnk->union_5_3_0.HighResHoles, sizeof(uint64));
-            if (*((uint64*)holes[mcnk->iy][mcnk->ix]) != 0)
+            if (advstd::bit_cast<uint64>(holes[mcnk->iy][mcnk->ix]) != 0)
                 hasHoles = true;
         }
     }
 
     // Get liquid map for grid (in WOTLK used MH2O chunk)
-    if (FileChunk* chunk = adt.GetChunk("MH2O"))
+    if (FileChunk const* chunk = adt.GetChunk("MH2O"))
     {
         adt_MH2O* h2o = chunk->As<adt_MH2O>();
         for (int32 i = 0; i < ADT_CELLS_PER_GRID; i++)
@@ -657,9 +657,11 @@ bool ConvertADT(ChunkedFile& adt, std::string const& mapName, std::string const&
                     continue;
 
                 liquid_entry[i][j] = h2o->GetLiquidType(h);
-                LiquidTypeEntry const& liquidTypeEntry = LiquidTypes.at(liquid_entry[i][j]);
+                auto liquidTypeEntry = LiquidTypes.find(liquid_entry[i][j]);
+                if (liquidTypeEntry == LiquidTypes.end())
+                    continue;
 
-                if (LiquidMaterialEntry const* liquidMaterial = Trinity::Containers::MapGetValuePtr(LiquidMaterials, liquidTypeEntry.MaterialID))
+                if (LiquidMaterialEntry const* liquidMaterial = Trinity::Containers::MapGetValuePtr(LiquidMaterials, liquidTypeEntry->second.MaterialID))
                     if (liquidMaterial->Flags.HasFlag(LiquidMaterialFlags::VisualOnly))
                         continue;
 
@@ -682,7 +684,7 @@ bool ConvertADT(ChunkedFile& adt, std::string const& mapName, std::string const&
                     }
                 }
 
-                switch (liquidTypeEntry.SoundBank)
+                switch (liquidTypeEntry->second.SoundBank)
                 {
                     case LIQUID_TYPE_WATER: liquid_flags[i][j] |= map_liquidHeaderTypeFlags::Water; break;
                     case LIQUID_TYPE_OCEAN: liquid_flags[i][j] |= map_liquidHeaderTypeFlags::Ocean; if (!ignoreDeepWater && attrs.Deep) liquid_flags[i][j] |= map_liquidHeaderTypeFlags::DarkWater; break;
@@ -711,7 +713,7 @@ bool ConvertADT(ChunkedFile& adt, std::string const& mapName, std::string const&
         }
     }
 
-    if (FileChunk* chunk = adt.GetChunk("MFBO"))
+    if (FileChunk const* chunk = adt.GetChunk("MFBO"))
     {
         adt_MFBO* mfbo = chunk->As<adt_MFBO>();
         memcpy(flight_box_max, &mfbo->max, sizeof(flight_box_max));
@@ -722,8 +724,8 @@ bool ConvertADT(ChunkedFile& adt, std::string const& mapName, std::string const&
     //============================================
     // Try pack area data
     //============================================
+    uint16 areaId = area_ids[0][0];
     bool fullAreaData = false;
-    uint32 areaId = area_ids[0][0];
     for (int y = 0; y < ADT_CELLS_PER_GRID; ++y)
     {
         for (int x = 0; x < ADT_CELLS_PER_GRID; ++x)
@@ -731,6 +733,7 @@ bool ConvertADT(ChunkedFile& adt, std::string const& mapName, std::string const&
             if (area_ids[y][x] != areaId)
             {
                 fullAreaData = true;
+                y = ADT_CELLS_PER_GRID;
                 break;
             }
         }
@@ -750,7 +753,7 @@ bool ConvertADT(ChunkedFile& adt, std::string const& mapName, std::string const&
     else
     {
         areaHeader.flags |= map_areaHeaderFlags::NoArea;
-        areaHeader.gridArea = static_cast<uint16>(areaId);
+        areaHeader.gridArea = areaId;
     }
 
     //============================================
@@ -968,68 +971,64 @@ bool ConvertADT(ChunkedFile& adt, std::string const& mapName, std::string const&
     }
 
     // Ok all data prepared - store it
-    std::ofstream outFile(outputPath, std::ofstream::out | std::ofstream::binary);
+    auto outFile = Trinity::make_unique_ptr_with_deleter<&::fclose>(fopen(outputPath.c_str(), "wb"));
     if (!outFile)
     {
         printf("Can't create the output file '%s'\n", outputPath.c_str());
         return false;
     }
 
-    outFile.write(reinterpret_cast<char const*>(&map), sizeof(map));
+    fwrite(&map, sizeof(map), 1, outFile.get());
     // Store area data
-    outFile.write(reinterpret_cast<char const*>(&areaHeader), sizeof(areaHeader));
+    fwrite(&areaHeader, sizeof(areaHeader), 1, outFile.get());
     if (!areaHeader.flags.HasFlag(map_areaHeaderFlags::NoArea))
-        outFile.write(reinterpret_cast<char const*>(area_ids), sizeof(area_ids));
+        WriteArray2D(area_ids, outFile.get());
 
     // Store height data
-    outFile.write(reinterpret_cast<char const*>(&heightHeader), sizeof(heightHeader));
+    fwrite(&heightHeader, sizeof(heightHeader), 1, outFile.get());
     if (!heightHeader.flags.HasFlag(map_heightHeaderFlags::NoHeight))
     {
         if (heightHeader.flags.HasFlag(map_heightHeaderFlags::HeightAsInt16))
         {
-            outFile.write(reinterpret_cast<char const*>(uint16_V9), sizeof(uint16_V9));
-            outFile.write(reinterpret_cast<char const*>(uint16_V8), sizeof(uint16_V8));
+            WriteArray2D(uint16_V9, outFile.get());
+            WriteArray2D(uint16_V8, outFile.get());
         }
         else if (heightHeader.flags.HasFlag(map_heightHeaderFlags::HeightAsInt8))
         {
-            outFile.write(reinterpret_cast<char const*>(uint8_V9), sizeof(uint8_V9));
-            outFile.write(reinterpret_cast<char const*>(uint8_V8), sizeof(uint8_V8));
+            WriteArray2D(uint8_V9, outFile.get());
+            WriteArray2D(uint8_V8, outFile.get());
         }
         else
         {
-            outFile.write(reinterpret_cast<char const*>(V9), sizeof(V9));
-            outFile.write(reinterpret_cast<char const*>(V8), sizeof(V8));
+            WriteArray2D(V9, outFile.get());
+            WriteArray2D(V8, outFile.get());
         }
     }
 
     if (heightHeader.flags.HasFlag(map_heightHeaderFlags::HasFlightBounds))
     {
-        outFile.write(reinterpret_cast<char*>(flight_box_max), sizeof(flight_box_max));
-        outFile.write(reinterpret_cast<char*>(flight_box_min), sizeof(flight_box_min));
+        WriteArray2D(flight_box_max, outFile.get());
+        WriteArray2D(flight_box_min, outFile.get());
     }
 
     // Store liquid data if need
     if (map.liquidMapOffset)
     {
-        outFile.write(reinterpret_cast<char const*>(&liquidHeader), sizeof(liquidHeader));
+        fwrite(&liquidHeader, sizeof(liquidHeader), 1, outFile.get());
         if (!liquidHeader.flags.HasFlag(map_liquidHeaderFlags::NoType))
         {
-            outFile.write(reinterpret_cast<char const*>(liquid_entry), sizeof(liquid_entry));
-            outFile.write(reinterpret_cast<char const*>(liquid_flags), sizeof(liquid_flags));
+            WriteArray2D(liquid_entry, outFile.get());
+            WriteArray2D(liquid_flags, outFile.get());
         }
 
         if (!liquidHeader.flags.HasFlag(map_liquidHeaderFlags::NoHeight))
-        {
             for (int y = 0; y < liquidHeader.height; y++)
-                outFile.write(reinterpret_cast<char const*>(&liquid_height[y + liquidHeader.offsetY][liquidHeader.offsetX]), sizeof(float) * liquidHeader.width);
-        }
+                fwrite(&liquid_height[y + liquidHeader.offsetY][liquidHeader.offsetX], sizeof(float), liquidHeader.width, outFile.get());
     }
 
     // store hole data
     if (hasHoles)
-        outFile.write(reinterpret_cast<char const*>(holes), map.holesSize);
-
-    outFile.close();
+        WriteArray2D(holes, outFile.get());
 
     return true;
 }
@@ -1104,9 +1103,9 @@ void ExtractMaps(uint32 build)
         std::bitset<(WDT_MAP_SIZE) * (WDT_MAP_SIZE)> existingTiles;
         if (wdt.loadFile(CascStorage, map_ids[z].WdtFileDataId, Trinity::StringFormat("WDT for map {}", map_ids[z].Id), false))
         {
-            FileChunk* mphd = wdt.GetChunk("MPHD");
-            FileChunk* main = wdt.GetChunk("MAIN");
-            FileChunk* maid = wdt.GetChunk("MAID");
+            FileChunk const* mphd = wdt.GetChunk("MPHD");
+            FileChunk const* main = wdt.GetChunk("MAIN");
+            FileChunk const* maid = wdt.GetChunk("MAID");
             for (uint32 y = 0; y < WDT_MAP_SIZE; ++y)
             {
                 for (uint32 x = 0; x < WDT_MAP_SIZE; ++x)
@@ -1133,13 +1132,12 @@ void ExtractMaps(uint32 build)
             }
         }
 
-        if (FILE* tileList = fopen(Trinity::StringFormat("{}/maps/{:04}.tilelist", output_path.string(), map_ids[z].Id).c_str(), "wb"))
+        if (auto tileList = Trinity::make_unique_ptr_with_deleter<&::fclose>(fopen(Trinity::StringFormat("{}/maps/{:04}.tilelist", output_path.string(), map_ids[z].Id).c_str(), "wb")))
         {
-            fwrite(MapMagic.data(), 1, MapMagic.size(), tileList);
-            fwrite(&MapVersionMagic, 1, sizeof(MapVersionMagic), tileList);
-            fwrite(&build, sizeof(build), 1, tileList);
-            fwrite(existingTiles.to_string().c_str(), 1, existingTiles.size(), tileList);
-            fclose(tileList);
+            fwrite(MapMagic.data(), 1, MapMagic.size(), tileList.get());
+            fwrite(&MapVersionMagic, 1, sizeof(MapVersionMagic), tileList.get());
+            fwrite(&build, sizeof(build), 1, tileList.get());
+            fwrite(existingTiles.to_string().c_str(), 1, existingTiles.size(), tileList.get());
         }
     }
 
@@ -1155,7 +1153,7 @@ bool ExtractFile(CASC::File* fileInArchive, std::string const& filename)
         return false;
     }
 
-    FILE* output = fopen(filename.c_str(), "wb");
+    auto output = Trinity::make_unique_ptr_with_deleter<&::fclose>(fopen(filename.c_str(), "wb"));
     if (!output)
     {
         printf("Can't create the output file '%s'\n", filename.c_str());
@@ -1171,7 +1169,7 @@ bool ExtractFile(CASC::File* fileInArchive, std::string const& filename)
         if (!fileInArchive->ReadFile(buffer, std::min<uint32>(fileSize, sizeof(buffer)), &readBytes))
         {
             printf("Can't read file '%s'\n", filename.c_str());
-            fclose(output);
+            output = nullptr;
             boost::filesystem::remove(filename);
             return false;
         }
@@ -1179,14 +1177,13 @@ bool ExtractFile(CASC::File* fileInArchive, std::string const& filename)
         if (!readBytes)
             break;
 
-        fwrite(buffer, 1, readBytes, output);
+        fwrite(buffer, 1, readBytes, output.get());
         fileSize -= readBytes;
         if (!fileSize) // now we have read entire file
             break;
 
     } while (true);
 
-    fclose(output);
     return true;
 }
 
@@ -1218,7 +1215,7 @@ bool ExtractDB2File(uint32 fileDataId, char const* cascFileName, int locale, boo
     }
 
     std::string outputFileName = outputPath.string();
-    FILE* output = fopen(outputFileName.c_str(), "wb");
+    auto output = Trinity::make_unique_ptr_with_deleter<&::fclose>(fopen(outputFileName.c_str(), "wb"));
     if (!output)
     {
         printf("Can't create the output file '%s'\n", outputFileName.c_str());
@@ -1228,7 +1225,7 @@ bool ExtractDB2File(uint32 fileDataId, char const* cascFileName, int locale, boo
     DB2Header header = db2.GetHeader();
 
     int64 posAfterHeaders = 0;
-    posAfterHeaders += fwrite(&header, 1, sizeof(header), output);
+    posAfterHeaders += fwrite(&header, 1, sizeof(header), output.get());
 
     // erase TactId from header if key is known
     for (uint32 i = 0; i < header.SectionCount; ++i)
@@ -1237,7 +1234,7 @@ bool ExtractDB2File(uint32 fileDataId, char const* cascFileName, int locale, boo
         if (sectionHeader.TactId && CascStorage->HasTactKey(sectionHeader.TactId))
             sectionHeader.TactId = DUMMY_KNOWN_TACT_ID;
 
-        posAfterHeaders += fwrite(&sectionHeader, 1, sizeof(sectionHeader), output);
+        posAfterHeaders += fwrite(&sectionHeader, 1, sizeof(sectionHeader), output.get());
     }
 
     char buffer[0x10000];
@@ -1251,7 +1248,7 @@ bool ExtractDB2File(uint32 fileDataId, char const* cascFileName, int locale, boo
         if (!source.GetNativeHandle()->ReadFile(buffer, std::min<uint32>(fileSize, readBatchSize), &readBytes))
         {
             printf("Can't read file '%s'\n", outputFileName.c_str());
-            fclose(output);
+            output = nullptr;
             boost::filesystem::remove(outputPath);
             return false;
         }
@@ -1259,7 +1256,7 @@ bool ExtractDB2File(uint32 fileDataId, char const* cascFileName, int locale, boo
         if (!readBytes)
             break;
 
-        fwrite(buffer, 1, readBytes, output);
+        fwrite(buffer, 1, readBytes, output.get());
         fileSize -= readBytes;
         readBatchSize = 0x10000;
         if (!fileSize) // now we have read entire file
@@ -1267,7 +1264,6 @@ bool ExtractDB2File(uint32 fileDataId, char const* cascFileName, int locale, boo
 
     } while (true);
 
-    fclose(output);
     return true;
 }
 
diff --git a/src/tools/map_extractor/loadlib.cpp b/src/tools/map_extractor/loadlib.cpp
index 64787c36024..9168070a55f 100644
--- a/src/tools/map_extractor/loadlib.cpp
+++ b/src/tools/map_extractor/loadlib.cpp
@@ -15,12 +15,9 @@
  * with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#define _CRT_SECURE_NO_DEPRECATE
-
 #include "loadlib.h"
 #include <CascLib.h>
-
-u_map_fcc MverMagic = { { 'R','E','V','M' } };
+#include <algorithm>
 
 ChunkedFile::ChunkedFile()
 {
@@ -89,14 +86,12 @@ bool ChunkedFile::loadFile(std::shared_ptr<CASC::Storage const> mpq, uint32 file
 
 bool ChunkedFile::prepareLoadedData()
 {
-    FileChunk* chunk = GetChunk("MVER");
+    FileChunk const* chunk = GetChunk("MVER");
     if (!chunk)
         return false;
 
     // Check version
     file_MVER* version = chunk->As<file_MVER>();
-    if (version->fcc != MverMagic.fcc)
-        return false;
     if (version->ver != FILE_FORMAT_VERSION)
         return false;
     return true;
@@ -104,9 +99,6 @@ bool ChunkedFile::prepareLoadedData()
 
 void ChunkedFile::free()
 {
-    for (auto& chunk : chunks)
-        delete chunk.second;
-
     chunks.clear();
 
     delete[] data;
@@ -114,18 +106,18 @@ void ChunkedFile::free()
     data_size = 0;
 }
 
-u_map_fcc InterestingChunks[] =
+u_map_fcc constexpr InterestingChunks[] =
 {
-    { { 'R', 'E', 'V', 'M' } },
-    { { 'N', 'I', 'A', 'M' } },
-    { { 'O', '2', 'H', 'M' } },
-    { { 'K', 'N', 'C', 'M' } },
-    { { 'T', 'V', 'C', 'M' } },
-    { { 'O', 'M', 'W', 'M' } },
-    { { 'Q', 'L', 'C', 'M' } },
-    { { 'O', 'B', 'F', 'M' } },
-    { { 'D', 'H', 'P', 'M' } },
-    { { 'D', 'I', 'A', 'M' } }
+    { .fcc_txt = { 'R', 'E', 'V', 'M' } },
+    { .fcc_txt = { 'N', 'I', 'A', 'M' } },
+    { .fcc_txt = { 'O', '2', 'H', 'M' } },
+    { .fcc_txt = { 'K', 'N', 'C', 'M' } },
+    { .fcc_txt = { 'T', 'V', 'C', 'M' } },
+    { .fcc_txt = { 'O', 'M', 'W', 'M' } },
+    { .fcc_txt = { 'Q', 'L', 'C', 'M' } },
+    { .fcc_txt = { 'O', 'B', 'F', 'M' } },
+    { .fcc_txt = { 'D', 'H', 'P', 'M' } },
+    { .fcc_txt = { 'D', 'I', 'A', 'M' } }
 };
 
 bool IsInterestingChunk(u_map_fcc const& fcc)
@@ -143,18 +135,16 @@ void ChunkedFile::parseChunks()
     // Make sure there's enough data to read u_map_fcc struct and the uint32 size after it
     while (ptr <= GetData() + GetDataSize() - 8)
     {
-        u_map_fcc header = *(u_map_fcc*)ptr;
+        u_map_fcc& header = *(u_map_fcc*)ptr;
         if (IsInterestingChunk(header))
         {
             uint32 size = *(uint32*)(ptr + 4);
             if (size <= data_size)
             {
-                std::swap(header.fcc_txt[0], header.fcc_txt[3]);
-                std::swap(header.fcc_txt[1], header.fcc_txt[2]);
+                std::ranges::reverse(header.fcc_txt);
 
-                FileChunk* chunk = new FileChunk(ptr, size);
-                chunk->parseSubChunks();
-                chunks.insert({ std::string(header.fcc_txt, 4), chunk });
+                FileChunk& chunk = chunks.emplace(std::piecewise_construct, std::forward_as_tuple(header.fcc_txt, 4), std::forward_as_tuple(ptr, size))->second;
+                chunk.parseSubChunks();
             }
 
             // move to next chunk
@@ -165,40 +155,32 @@ void ChunkedFile::parseChunks()
     }
 }
 
-FileChunk* ChunkedFile::GetChunk(std::string const& name)
+FileChunk const* ChunkedFile::GetChunk(std::string_view name) const
 {
     auto range = chunks.equal_range(name);
     if (std::distance(range.first, range.second) == 1)
-        return range.first->second;
+        return &range.first->second;
 
     return nullptr;
 }
 
-FileChunk::~FileChunk()
-{
-    for (auto& subchunk : subchunks)
-        delete subchunk.second;
-
-    subchunks.clear();
-}
+FileChunk::~FileChunk() = default;
 
 void FileChunk::parseSubChunks()
 {
     uint8* ptr = data + 8; // skip self
     while (ptr < data + size)
     {
-        u_map_fcc header = *(u_map_fcc*)ptr;
+        u_map_fcc& header = *(u_map_fcc*)ptr;
         if (IsInterestingChunk(header))
         {
             uint32 subsize = *(uint32*)(ptr + 4);
             if (subsize < size)
             {
-                std::swap(header.fcc_txt[0], header.fcc_txt[3]);
-                std::swap(header.fcc_txt[1], header.fcc_txt[2]);
+                std::ranges::reverse(header.fcc_txt);
 
-                FileChunk* chunk = new FileChunk(ptr, subsize);
-                chunk->parseSubChunks();
-                subchunks.insert({ std::string(header.fcc_txt, 4), chunk });
+                FileChunk& chunk = subchunks.emplace(std::piecewise_construct, std::forward_as_tuple(header.fcc_txt, 4), std::forward_as_tuple(ptr, subsize))->second;
+                chunk.parseSubChunks();
             }
 
             // move to next chunk
@@ -209,11 +191,11 @@ void FileChunk::parseSubChunks()
     }
 }
 
-FileChunk* FileChunk::GetSubChunk(std::string const& name)
+FileChunk const* FileChunk::GetSubChunk(std::string_view name) const
 {
     auto range = subchunks.equal_range(name);
     if (std::distance(range.first, range.second) == 1)
-        return range.first->second;
+        return &range.first->second;
 
     return nullptr;
 }
diff --git a/src/tools/map_extractor/loadlib/loadlib.h b/src/tools/map_extractor/loadlib/loadlib.h
index aadf8cc8724..dc9c1e647eb 100644
--- a/src/tools/map_extractor/loadlib/loadlib.h
+++ b/src/tools/map_extractor/loadlib/loadlib.h
@@ -64,10 +64,10 @@ public:
     uint32 size;
 
     template<class T>
-    T* As() { return (T*)data; }
+    T* As() const { return (T*)data; }
     void parseSubChunks();
-    std::multimap<std::string, FileChunk*> subchunks;
-    FileChunk* GetSubChunk(std::string const& name);
+    std::multimap<std::string_view, FileChunk> subchunks;
+    FileChunk const* GetSubChunk(std::string_view name) const;
 };
 
 class ChunkedFile
@@ -87,8 +87,8 @@ public:
     void free();
 
     void parseChunks();
-    std::multimap<std::string, FileChunk*> chunks;
-    FileChunk* GetChunk(std::string const& name);
+    std::multimap<std::string_view, FileChunk> chunks;
+    FileChunk const* GetChunk(std::string_view name) const;
 };
 
 #pragma pack(pop)
diff --git a/src/tools/vmap4_extractor/cascfile.h b/src/tools/vmap4_extractor/cascfile.h
index 53193c931a5..8da9d7794fd 100644
--- a/src/tools/vmap4_extractor/cascfile.h
+++ b/src/tools/vmap4_extractor/cascfile.h
@@ -15,11 +15,6 @@
  * with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#define _CRT_SECURE_NO_DEPRECATE
-#ifndef _CRT_SECURE_NO_WARNINGS // fuck the police^Wwarnings
-#define _CRT_SECURE_NO_WARNINGS
-#endif
-
 #ifndef MPQ_H
 #define MPQ_H