Core/Misc: Replace some sprintf with Trinity::StringFormat (TrinityCore/TrinityCore#31740)

Thelsen · Shauren · Krigsgaldrnet · commit 924fb5c270ce · 2026-04-13T00:01:12.000+02:00
Co-authored-by: Shauren &lt;shauren.trinity@gmail.com&gt;
diff --git a/src/tools/mmaps_generator/MapBuilder.cpp b/src/tools/mmaps_generator/MapBuilder.cpp
@@ -114,7 +114,6 @@ namespace MMAP
     {
         std::vector<std::string> files;
         uint32 mapID, tileX, tileY, tileID, count = 0;
-        char filter[12];
 
         printf("Discovering maps... ");
         getDirContents(files, "maps");
@@ -148,9 +147,8 @@ namespace MMAP
             std::set<uint32>* tiles = (*itr).m_tiles;
             mapID = (*itr).m_mapId;
 
-            sprintf(filter, "%03u*.vmtile", mapID);
             files.clear();
-            getDirContents(files, "vmaps", filter);
+            getDirContents(files, "vmaps", Trinity::StringFormat("{:03}*.vmtile", mapID));
             for (uint32 i = 0; i < files.size(); ++i)
             {
                 tileX = uint32(atoi(files[i].substr(7,2).c_str()));
@@ -161,9 +159,8 @@ namespace MMAP
                 count++;
             }
 
-            sprintf(filter, "%03u*", mapID);
             files.clear();
-            getDirContents(files, "maps", filter);
+            getDirContents(files, "maps", Trinity::StringFormat("{:03}*", mapID));
             for (uint32 i = 0; i < files.size(); ++i)
             {
                 tileY = uint32(atoi(files[i].substr(3,2).c_str()));
@@ -597,9 +594,8 @@ namespace MMAP
         dtNavMesh* navMesh)
     {
         // console output
-        char tileString[20];
-        sprintf(tileString, "[Map %03i] [%02i,%02i]: ", mapID, tileX, tileY);
-        printf("%s Building movemap tiles...\n", tileString);
+        std::string tileString = Trinity::StringFormat("[Map {:03}] [{:02},{:02}]]: ", mapID, tileX, tileY);
+        printf("%s Building movemap tiles...\n", tileString.c_str());
 
         IntermediateValues iv;
 
@@ -656,7 +652,7 @@ namespace MMAP
                 tile.solid = rcAllocHeightfield();
                 if (!tile.solid || !rcCreateHeightfield(m_rcContext, *tile.solid, tileCfg.width, tileCfg.height, tileCfg.bmin, tileCfg.bmax, tileCfg.cs, tileCfg.ch))
                 {
-                    printf("%s Failed building heightfield!            \n", tileString);
+                    printf("%s Failed building heightfield!            \n", tileString.c_str());
                     continue;
                 }
 
@@ -686,54 +682,54 @@ namespace MMAP
                 tile.chf = rcAllocCompactHeightfield();
                 if (!tile.chf || !rcBuildCompactHeightfield(m_rcContext, tileCfg.walkableHeight, tileCfg.walkableClimb, *tile.solid, *tile.chf))
                 {
-                    printf("%s Failed compacting heightfield!            \n", tileString);
+                    printf("%s Failed compacting heightfield!            \n", tileString.c_str());
                     continue;
                 }
 
                 // build polymesh intermediates
                 if (!rcErodeWalkableArea(m_rcContext, config.walkableRadius, *tile.chf))
                 {
-                    printf("%s Failed eroding area!                    \n", tileString);
+                    printf("%s Failed eroding area!                    \n", tileString.c_str());
                     continue;
                 }
 
                 if (!rcMedianFilterWalkableArea(m_rcContext, *tile.chf))
                 {
-                    printf("%s Failed filtering area!                  \n", tileString);
+                    printf("%s Failed filtering area!                  \n", tileString.c_str());
                     continue;
                 }
 
                 if (!rcBuildDistanceField(m_rcContext, *tile.chf))
                 {
-                    printf("%s Failed building distance field!         \n", tileString);
+                    printf("%s Failed building distance field!         \n", tileString.c_str());
                     continue;
                 }
 
                 if (!rcBuildRegions(m_rcContext, *tile.chf, tileCfg.borderSize, tileCfg.minRegionArea, tileCfg.mergeRegionArea))
                 {
-                    printf("%s Failed building regions!                \n", tileString);
+                    printf("%s Failed building regions!                \n", tileString.c_str());
                     continue;
                 }
 
                 tile.cset = rcAllocContourSet();
                 if (!tile.cset || !rcBuildContours(m_rcContext, *tile.chf, tileCfg.maxSimplificationError, tileCfg.maxEdgeLen, *tile.cset))
                 {
-                    printf("%s Failed building contours!               \n", tileString);
+                    printf("%s Failed building contours!               \n", tileString.c_str());
                     continue;
                 }
 
                 // build polymesh
                 tile.pmesh = rcAllocPolyMesh();
                 if (!tile.pmesh || !rcBuildPolyMesh(m_rcContext, *tile.cset, tileCfg.maxVertsPerPoly, *tile.pmesh))
                 {
-                    printf("%s Failed building polymesh!               \n", tileString);
+                    printf("%s Failed building polymesh!               \n", tileString.c_str());
                     continue;
                 }
 
                 tile.dmesh = rcAllocPolyMeshDetail();
                 if (!tile.dmesh || !rcBuildPolyMeshDetail(m_rcContext, *tile.pmesh, *tile.chf, tileCfg.detailSampleDist, tileCfg.detailSampleMaxError, *tile.dmesh))
                 {
-                    printf("%s Failed building polymesh detail!        \n", tileString);
+                    printf("%s Failed building polymesh detail!        \n", tileString.c_str());
                     continue;
                 }
 
@@ -756,7 +752,7 @@ namespace MMAP
         iv.polyMesh = rcAllocPolyMesh();
         if (!iv.polyMesh)
         {
-            printf("%s alloc iv.polyMesh FAILED!\n", tileString);
+            printf("%s alloc iv.polyMesh FAILED!\n", tileString.c_str());
             delete[] pmmerge;
             delete[] dmmerge;
             delete[] tiles;
@@ -767,7 +763,7 @@ namespace MMAP
         iv.polyMeshDetail = rcAllocPolyMeshDetail();
         if (!iv.polyMeshDetail)
         {
-            printf("%s alloc m_dmesh FAILED!\n", tileString);
+            printf("%s alloc m_dmesh FAILED!\n", tileString.c_str());
             delete[] pmmerge;
             delete[] dmmerge;
             delete[] tiles;
@@ -838,12 +834,12 @@ namespace MMAP
             // so we have a clear error message
             if (params.nvp > DT_VERTS_PER_POLYGON)
             {
-                printf("%s Invalid verts-per-polygon value!        \n", tileString);
+                printf("%s Invalid verts-per-polygon value!        \n", tileString.c_str());
                 break;
             }
             if (params.vertCount >= 0xffff)
             {
-                printf("%s Too many vertices!                      \n", tileString);
+                printf("%s Too many vertices!                      \n", tileString.c_str());
                 break;
             }
             if (!params.vertCount || !params.verts)
@@ -852,37 +848,37 @@ namespace MMAP
                 // loaded but those models don't span into this tile
 
                 // message is an annoyance
-                //printf("%sNo vertices to build tile!              \n", tileString);
+                //printf("%sNo vertices to build tile!              \n", tileString.c_str());
                 break;
             }
             if (!params.polyCount || !params.polys)
             {
                 // we have flat tiles with no actual geometry - don't build those, its useless
                 // keep in mind that we do output those into debug info
-                printf("%s No polygons to build on tile!              \n", tileString);
+                printf("%s No polygons to build on tile!              \n", tileString.c_str());
                 break;
             }
             if (!params.detailMeshes || !params.detailVerts || !params.detailTris)
             {
-                printf("%s No detail mesh to build tile!           \n", tileString);
+                printf("%s No detail mesh to build tile!           \n", tileString.c_str());
                 break;
             }
 
-            printf("%s Building navmesh tile...\n", tileString);
+            printf("%s Building navmesh tile...\n", tileString.c_str());
             if (!dtCreateNavMeshData(&params, &navData, &navDataSize))
             {
-                printf("%s Failed building navmesh tile!           \n", tileString);
+                printf("%s Failed building navmesh tile!           \n", tileString.c_str());
                 break;
             }
 
             dtTileRef tileRef = 0;
-            printf("%s Adding tile to navmesh...\n", tileString);
+            printf("%s Adding tile to navmesh...\n", tileString.c_str());
             // DT_TILE_FREE_DATA tells detour to unallocate memory when the tile
             // is removed via removeTile()
             dtStatus dtResult = navMesh->addTile(navData, navDataSize, DT_TILE_FREE_DATA, 0, &tileRef);
             if (!tileRef || dtResult != DT_SUCCESS)
             {
-                printf("%s Failed adding tile to navmesh!           \n", tileString);
+                printf("%s Failed adding tile to navmesh!           \n", tileString.c_str());
                 break;
             }
 
@@ -896,7 +892,7 @@ namespace MMAP
                 break;
             }
 
-            printf("%s Writing to file...\n", tileString);
+            printf("%s Writing to file...\n", tileString.c_str());
 
             // write header
             MmapTileHeader header;
diff --git a/src/tools/vmap4_extractor/adtfile.cpp b/src/tools/vmap4_extractor/adtfile.cpp
@@ -74,7 +74,7 @@ char* GetExtension(char* FileName)
     return nullptr;
 }
 
-ADTFile::ADTFile(char* filename) : _file(filename)
+ADTFile::ADTFile(char const* filename) : _file(filename)
 {
     Adtfilename.append(filename);
 }
diff --git a/src/tools/vmap4_extractor/adtfile.h b/src/tools/vmap4_extractor/adtfile.h
@@ -56,7 +56,7 @@ class ADTFile
     MPQFile _file;
     std::string Adtfilename;
 public:
-    ADTFile(char* filename);
+    ADTFile(char const* filename);
     ~ADTFile();
     std::vector<std::string> WmoInstanceNames;
     std::vector<std::string> ModelInstanceNames;
diff --git a/src/tools/vmap4_extractor/vmapexport.cpp b/src/tools/vmap4_extractor/vmapexport.cpp
@@ -182,12 +182,10 @@ bool ExtractSingleWmo(std::string& fname)
 
 void ParsMapFiles()
 {
-    char fn[512];
     //char id_filename[64];
     for (unsigned int i=0; i<map_count; ++i)
     {
-        sprintf(fn,"World\\Maps\\%s\\%s.wdt", map_ids[i].name, map_ids[i].name);
-        WDTFile WDT(fn,map_ids[i].name);
+        WDTFile WDT(Trinity::StringFormat("World\\Maps\\{}\\{}.wdt", map_ids[i].name, map_ids[i].name).c_str(), map_ids[i].name);
         if (WDT.init(map_ids[i].id))
         {
             printf("Processing Map %u\n[", map_ids[i].id);
diff --git a/src/tools/vmap4_extractor/wdtfile.cpp b/src/tools/vmap4_extractor/wdtfile.cpp
@@ -31,9 +31,9 @@ char * wdtGetPlainName(char * FileName)
     return FileName;
 }
 
-WDTFile::WDTFile(char* file_name, char* file_name1) : _file(file_name)
+WDTFile::WDTFile(char const* file_name, char const* file_name1) : _file(file_name)
 {
-    filename.append(file_name1,strlen(file_name1));
+    filename.append(file_name1, strlen(file_name1));
 }
 
 bool WDTFile::init(uint32 mapId)
@@ -125,8 +125,5 @@ ADTFile* WDTFile::GetMap(int x, int z)
     if(!(x>=0 && z >= 0 && x<64 && z<64))
         return nullptr;
 
-    char name[512];
-
-    sprintf(name,"World\\Maps\\%s\\%s_%d_%d.adt", filename.c_str(), filename.c_str(), x, z);
-    return new ADTFile(name);
+    return new ADTFile(Trinity::StringFormat("World\\Maps\\{}\\{}_{}_{}.adt", filename, filename, x, z).c_str());
 }
diff --git a/src/tools/vmap4_extractor/wdtfile.h b/src/tools/vmap4_extractor/wdtfile.h
@@ -26,7 +26,7 @@ class ADTFile;
 class WDTFile
 {
 public:
-    WDTFile(char* file_name, char* file_name1);
+    WDTFile(char const* file_name, char const* file_name1);
     ~WDTFile(void);
 
     bool init(uint32 mapId);

Original file line number	Diff line number	Diff line change
`@@ -114,7 +114,6 @@ namespace MMAP`
`114`	`114`	`{`
`115`	`115`	`std::vector<std::string> files;`
`116`	`116`	`uint32 mapID, tileX, tileY, tileID, count = 0;`
`117`		`- char filter[12];`
`118`	`117`
`119`	`118`	`printf("Discovering maps... ");`
`120`	`119`	`getDirContents(files, "maps");`
`@@ -148,9 +147,8 @@ namespace MMAP`
`148`	`147`	`std::set<uint32>* tiles = (*itr).m_tiles;`
`149`	`148`	`mapID = (*itr).m_mapId;`
`150`	`149`
`151`		`- sprintf(filter, "%03u*.vmtile", mapID);`
`152`	`150`	`files.clear();`
`153`		`- getDirContents(files, "vmaps", filter);`
	`151`	`+ getDirContents(files, "vmaps", Trinity::StringFormat("{:03}*.vmtile", mapID));`
`154`	`152`	`for (uint32 i = 0; i < files.size(); ++i)`
`155`	`153`	`{`
`156`	`154`	`tileX = uint32(atoi(files[i].substr(7,2).c_str()));`
`@@ -161,9 +159,8 @@ namespace MMAP`
`161`	`159`	`count++;`
`162`	`160`	`}`
`163`	`161`
`164`		`- sprintf(filter, "%03u*", mapID);`
`165`	`162`	`files.clear();`
`166`		`- getDirContents(files, "maps", filter);`
	`163`	`+ getDirContents(files, "maps", Trinity::StringFormat("{:03}*", mapID));`
`167`	`164`	`for (uint32 i = 0; i < files.size(); ++i)`
`168`	`165`	`{`
`169`	`166`	`tileY = uint32(atoi(files[i].substr(3,2).c_str()));`
`@@ -597,9 +594,8 @@ namespace MMAP`
`597`	`594`	`dtNavMesh* navMesh)`
`598`	`595`	`{`
`599`	`596`	`// console output`
`600`		`- char tileString[20];`
`601`		`- sprintf(tileString, "[Map %03i] [%02i,%02i]: ", mapID, tileX, tileY);`
`602`		`- printf("%s Building movemap tiles...\n", tileString);`
	`597`	`+ std::string tileString = Trinity::StringFormat("[Map {:03}] [{:02},{:02}]]: ", mapID, tileX, tileY);`
	`598`	`+ printf("%s Building movemap tiles...\n", tileString.c_str());`
`603`	`599`
`604`	`600`	`IntermediateValues iv;`
`605`	`601`
`@@ -656,7 +652,7 @@ namespace MMAP`
`656`	`652`	`tile.solid = rcAllocHeightfield();`
`657`	`653`	`if (!tile.solid \|\| !rcCreateHeightfield(m_rcContext, *tile.solid, tileCfg.width, tileCfg.height, tileCfg.bmin, tileCfg.bmax, tileCfg.cs, tileCfg.ch))`
`658`	`654`	`{`
`659`		`- printf("%s Failed building heightfield! \n", tileString);`
	`655`	`+ printf("%s Failed building heightfield! \n", tileString.c_str());`
`660`	`656`	`continue;`
`661`	`657`	`}`
`662`	`658`
`@@ -686,54 +682,54 @@ namespace MMAP`
`686`	`682`	`tile.chf = rcAllocCompactHeightfield();`
`687`	`683`	`if (!tile.chf \|\| !rcBuildCompactHeightfield(m_rcContext, tileCfg.walkableHeight, tileCfg.walkableClimb, tile.solid, tile.chf))`
`688`	`684`	`{`
`689`		`- printf("%s Failed compacting heightfield! \n", tileString);`
	`685`	`+ printf("%s Failed compacting heightfield! \n", tileString.c_str());`
`690`	`686`	`continue;`
`691`	`687`	`}`
`692`	`688`
`693`	`689`	`// build polymesh intermediates`
`694`	`690`	`if (!rcErodeWalkableArea(m_rcContext, config.walkableRadius, *tile.chf))`
`695`	`691`	`{`
`696`		`- printf("%s Failed eroding area! \n", tileString);`
	`692`	`+ printf("%s Failed eroding area! \n", tileString.c_str());`
`697`	`693`	`continue;`
`698`	`694`	`}`
`699`	`695`
`700`	`696`	`if (!rcMedianFilterWalkableArea(m_rcContext, *tile.chf))`
`701`	`697`	`{`
`702`		`- printf("%s Failed filtering area! \n", tileString);`
	`698`	`+ printf("%s Failed filtering area! \n", tileString.c_str());`
`703`	`699`	`continue;`
`704`	`700`	`}`
`705`	`701`
`706`	`702`	`if (!rcBuildDistanceField(m_rcContext, *tile.chf))`
`707`	`703`	`{`
`708`		`- printf("%s Failed building distance field! \n", tileString);`
	`704`	`+ printf("%s Failed building distance field! \n", tileString.c_str());`
`709`	`705`	`continue;`
`710`	`706`	`}`
`711`	`707`
`712`	`708`	`if (!rcBuildRegions(m_rcContext, *tile.chf, tileCfg.borderSize, tileCfg.minRegionArea, tileCfg.mergeRegionArea))`
`713`	`709`	`{`
`714`		`- printf("%s Failed building regions! \n", tileString);`
	`710`	`+ printf("%s Failed building regions! \n", tileString.c_str());`
`715`	`711`	`continue;`
`716`	`712`	`}`
`717`	`713`
`718`	`714`	`tile.cset = rcAllocContourSet();`
`719`	`715`	`if (!tile.cset \|\| !rcBuildContours(m_rcContext, tile.chf, tileCfg.maxSimplificationError, tileCfg.maxEdgeLen, tile.cset))`
`720`	`716`	`{`
`721`		`- printf("%s Failed building contours! \n", tileString);`
	`717`	`+ printf("%s Failed building contours! \n", tileString.c_str());`
`722`	`718`	`continue;`
`723`	`719`	`}`
`724`	`720`
`725`	`721`	`// build polymesh`
`726`	`722`	`tile.pmesh = rcAllocPolyMesh();`
`727`	`723`	`if (!tile.pmesh \|\| !rcBuildPolyMesh(m_rcContext, tile.cset, tileCfg.maxVertsPerPoly, tile.pmesh))`
`728`	`724`	`{`
`729`		`- printf("%s Failed building polymesh! \n", tileString);`
	`725`	`+ printf("%s Failed building polymesh! \n", tileString.c_str());`
`730`	`726`	`continue;`
`731`	`727`	`}`
`732`	`728`
`733`	`729`	`tile.dmesh = rcAllocPolyMeshDetail();`
`734`	`730`	`if (!tile.dmesh \|\| !rcBuildPolyMeshDetail(m_rcContext, tile.pmesh, tile.chf, tileCfg.detailSampleDist, tileCfg.detailSampleMaxError, *tile.dmesh))`
`735`	`731`	`{`
`736`		`- printf("%s Failed building polymesh detail! \n", tileString);`
	`732`	`+ printf("%s Failed building polymesh detail! \n", tileString.c_str());`
`737`	`733`	`continue;`
`738`	`734`	`}`
`739`	`735`
`@@ -756,7 +752,7 @@ namespace MMAP`
`756`	`752`	`iv.polyMesh = rcAllocPolyMesh();`
`757`	`753`	`if (!iv.polyMesh)`
`758`	`754`	`{`
`759`		`- printf("%s alloc iv.polyMesh FAILED!\n", tileString);`
	`755`	`+ printf("%s alloc iv.polyMesh FAILED!\n", tileString.c_str());`
`760`	`756`	`delete[] pmmerge;`
`761`	`757`	`delete[] dmmerge;`
`762`	`758`	`delete[] tiles;`
`@@ -767,7 +763,7 @@ namespace MMAP`
`767`	`763`	`iv.polyMeshDetail = rcAllocPolyMeshDetail();`
`768`	`764`	`if (!iv.polyMeshDetail)`
`769`	`765`	`{`
`770`		`- printf("%s alloc m_dmesh FAILED!\n", tileString);`
	`766`	`+ printf("%s alloc m_dmesh FAILED!\n", tileString.c_str());`
`771`	`767`	`delete[] pmmerge;`
`772`	`768`	`delete[] dmmerge;`
`773`	`769`	`delete[] tiles;`
`@@ -838,12 +834,12 @@ namespace MMAP`
`838`	`834`	`// so we have a clear error message`
`839`	`835`	`if (params.nvp > DT_VERTS_PER_POLYGON)`
`840`	`836`	`{`
`841`		`- printf("%s Invalid verts-per-polygon value! \n", tileString);`
	`837`	`+ printf("%s Invalid verts-per-polygon value! \n", tileString.c_str());`
`842`	`838`	`break;`
`843`	`839`	`}`
`844`	`840`	`if (params.vertCount >= 0xffff)`
`845`	`841`	`{`
`846`		`- printf("%s Too many vertices! \n", tileString);`
	`842`	`+ printf("%s Too many vertices! \n", tileString.c_str());`
`847`	`843`	`break;`
`848`	`844`	`}`
`849`	`845`	`if (!params.vertCount \|\| !params.verts)`
`@@ -852,37 +848,37 @@ namespace MMAP`
`852`	`848`	`// loaded but those models don't span into this tile`
`853`	`849`
`854`	`850`	`// message is an annoyance`
`855`		`- //printf("%sNo vertices to build tile! \n", tileString);`
	`851`	`+ //printf("%sNo vertices to build tile! \n", tileString.c_str());`
`856`	`852`	`break;`
`857`	`853`	`}`
`858`	`854`	`if (!params.polyCount \|\| !params.polys)`
`859`	`855`	`{`
`860`	`856`	`// we have flat tiles with no actual geometry - don't build those, its useless`
`861`	`857`	`// keep in mind that we do output those into debug info`
`862`		`- printf("%s No polygons to build on tile! \n", tileString);`
	`858`	`+ printf("%s No polygons to build on tile! \n", tileString.c_str());`
`863`	`859`	`break;`
`864`	`860`	`}`
`865`	`861`	`if (!params.detailMeshes \|\| !params.detailVerts \|\| !params.detailTris)`
`866`	`862`	`{`
`867`		`- printf("%s No detail mesh to build tile! \n", tileString);`
	`863`	`+ printf("%s No detail mesh to build tile! \n", tileString.c_str());`
`868`	`864`	`break;`
`869`	`865`	`}`
`870`	`866`
`871`		`- printf("%s Building navmesh tile...\n", tileString);`
	`867`	`+ printf("%s Building navmesh tile...\n", tileString.c_str());`
`872`	`868`	`if (!dtCreateNavMeshData(&params, &navData, &navDataSize))`
`873`	`869`	`{`
`874`		`- printf("%s Failed building navmesh tile! \n", tileString);`
	`870`	`+ printf("%s Failed building navmesh tile! \n", tileString.c_str());`
`875`	`871`	`break;`
`876`	`872`	`}`
`877`	`873`
`878`	`874`	`dtTileRef tileRef = 0;`
`879`		`- printf("%s Adding tile to navmesh...\n", tileString);`
	`875`	`+ printf("%s Adding tile to navmesh...\n", tileString.c_str());`
`880`	`876`	`// DT_TILE_FREE_DATA tells detour to unallocate memory when the tile`
`881`	`877`	`// is removed via removeTile()`
`882`	`878`	`dtStatus dtResult = navMesh->addTile(navData, navDataSize, DT_TILE_FREE_DATA, 0, &tileRef);`
`883`	`879`	`if (!tileRef \|\| dtResult != DT_SUCCESS)`
`884`	`880`	`{`
`885`		`- printf("%s Failed adding tile to navmesh! \n", tileString);`
	`881`	`+ printf("%s Failed adding tile to navmesh! \n", tileString.c_str());`
`886`	`882`	`break;`
`887`	`883`	`}`
`888`	`884`
`@@ -896,7 +892,7 @@ namespace MMAP`
`896`	`892`	`break;`
`897`	`893`	`}`
`898`	`894`
`899`		`- printf("%s Writing to file...\n", tileString);`
	`895`	`+ printf("%s Writing to file...\n", tileString.c_str());`
`900`	`896`
`901`	`897`	`// write header`
`902`	`898`	`MmapTileHeader header;`
Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@ char* GetExtension(char* FileName)`
`74`	`74`	`return nullptr;`
`75`	`75`	`}`
`76`	`76`
`77`		`-ADTFile::ADTFile(char* filename) : _file(filename)`
	`77`	`+ADTFile::ADTFile(char const* filename) : _file(filename)`
`78`	`78`	`{`
`79`	`79`	`Adtfilename.append(filename);`
`80`	`80`	`}`
Original file line number	Diff line number	Diff line change
`@@ -182,12 +182,10 @@ bool ExtractSingleWmo(std::string& fname)`
`182`	`182`
`183`	`183`	`void ParsMapFiles()`
`184`	`184`	`{`
`185`		`- char fn[512];`
`186`	`185`	`//char id_filename[64];`
`187`	`186`	`for (unsigned int i=0; i<map_count; ++i)`
`188`	`187`	`{`
`189`		`- sprintf(fn,"World\\Maps\\%s\\%s.wdt", map_ids[i].name, map_ids[i].name);`
`190`		`- WDTFile WDT(fn,map_ids[i].name);`
	`188`	`+ WDTFile WDT(Trinity::StringFormat("World\\Maps\\{}\\{}.wdt", map_ids[i].name, map_ids[i].name).c_str(), map_ids[i].name);`
`191`	`189`	`if (WDT.init(map_ids[i].id))`
`192`	`190`	`{`
`193`	`191`	`printf("Processing Map %u\n[", map_ids[i].id);`
Original file line number	Diff line number	Diff line change
`@@ -31,9 +31,9 @@ char * wdtGetPlainName(char * FileName)`
`31`	`31`	`return FileName;`
`32`	`32`	`}`
`33`	`33`
`34`		`-WDTFile::WDTFile(char* file_name, char* file_name1) : _file(file_name)`
	`34`	`+WDTFile::WDTFile(char const* file_name, char const* file_name1) : _file(file_name)`
`35`	`35`	`{`
`36`		`- filename.append(file_name1,strlen(file_name1));`
	`36`	`+ filename.append(file_name1, strlen(file_name1));`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`bool WDTFile::init(uint32 mapId)`
`@@ -125,8 +125,5 @@ ADTFile* WDTFile::GetMap(int x, int z)`
`125`	`125`	`if(!(x>=0 && z >= 0 && x<64 && z<64))`
`126`	`126`	`return nullptr;`
`127`	`127`
`128`		`- char name[512];`
`129`		`-`
`130`		`- sprintf(name,"World\\Maps\\%s\\%s_%d_%d.adt", filename.c_str(), filename.c_str(), x, z);`
`131`		`- return new ADTFile(name);`
	`128`	`+ return new ADTFile(Trinity::StringFormat("World\\Maps\\{}\\{}_{}_{}.adt", filename, filename, x, z).c_str());`
`132`	`129`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ class ADTFile;`
`26`	`26`	`class WDTFile`
`27`	`27`	`{`
`28`	`28`	`public:`
`29`		`- WDTFile(char* file_name, char* file_name1);`
	`29`	`+ WDTFile(char const* file_name, char const* file_name1);`
`30`	`30`	`~WDTFile(void);`
`31`	`31`
`32`	`32`	`bool init(uint32 mapId);`