public void RunBuild()
{
Logger.Info($"Loading all m2 files in \\{LoadDirectory} directory...");
var files = AllM2FilesRecursive(LoadDirectory, new List <string>());
Logger.Info($"Loaded {files.Count} m2 files.");
Logger.Info($"Loading {Config.Config.BindingsDirectory}\\CreatureModelData.dbc...");
var modelData = DBCManager.GetInstance().ReadLocalDbcForBinding("CreatureModelData");
Logger.Info($"Loading {Config.Config.BindingsDirectory}\\CreatureDisplayInfo.dbc...");
var displayInfo = DBCManager.GetInstance().ReadLocalDbcForBinding("CreatureDisplayInfo");
Logger.Info($"Creating {files.Count} new entries in both DBC's...");
PopulateNewEntries(modelData, displayInfo, files);
Logger.Info("Creating Export\\CreatureModelData.dbc...");
modelData.SaveToFile("CreatureModelData");
Logger.Info("Creating Export\\CreatureDisplayInfo.dbc...");
displayInfo.SaveToFile("CreatureDisplayInfo");
Logger.Info("Creating queries...");
SaveQueries(files);
Logger.Info("Done.");
}
public DataTablesResult Get(string name, string build, int draw, int start, int length)
{
var searching = false;
if (string.IsNullOrWhiteSpace(Request.Query["search[value]"]))
{
Console.WriteLine("Handling data " + start + "," + length + " for dbc " + name + " (" + build + ") for draw " + draw);
}
else
{
searching = true;
Console.WriteLine("Handling data " + start + "," + length + " for dbc " + name + " (" + build + ") for draw " + draw + " with filter " + Request.Query["search[value]"]);
}
var searchValue = Request.Query["search[value]"];
var result = new DataTablesResult();
result.draw = draw;
var storage = DBCManager.LoadDBC(name, build);
if (storage.Values.Count == 0)
{
throw new Exception("No rows found!");
}
result.recordsTotal = storage.Values.Count;
var fields = DefinitionManager.definitionCache[(name, build)].GetFields();
public Dictionary <uint, List <uint> > Get(int filedataid, string build)
{
var modelFileData = DBCManager.LoadDBC("modelfiledata", build, true);
var itemDisplayInfo = DBCManager.LoadDBC("itemdisplayinfo", build, true);
var textureFileData = DBCManager.LoadDBC("texturefiledata", build, true);
var creatureModelData = DBCManager.LoadDBC("creaturemodeldata", build, true);
var creatureDisplayInfo = DBCManager.LoadDBC("creaturedisplayinfo", build, true);
var returnList = new Dictionary <uint, List <uint> >();
if (modelFileData.Contains(filedataid))
{
dynamic mfdEntry = modelFileData[filedataid];
foreach (dynamic idiEntry in itemDisplayInfo.Values)
{
if (idiEntry.ModelResourcesID[0] != mfdEntry.ModelResourcesID && idiEntry.ModelResourcesID[1] != mfdEntry.ModelResourcesID)
{
continue;
}
var textureFileDataList = new List <uint>();
foreach (dynamic tfdEntry in textureFileData.Values)
{
if (tfdEntry.MaterialResourcesID == idiEntry.ModelMaterialResourcesID[0] || tfdEntry.MaterialResourcesID == idiEntry.ModelMaterialResourcesID[1])
{
textureFileDataList.Add((uint)tfdEntry.FileDataID);
}
}
returnList.Add((uint)idiEntry.ID, textureFileDataList);
}
foreach (dynamic cmdEntry in creatureModelData.Values)
{
if (cmdEntry.FileDataID != filedataid)
{
continue;
}
foreach (dynamic cdiEntry in creatureDisplayInfo.Values)
{
if (cdiEntry.ModelID != cmdEntry.ID)
{
continue;
}
returnList.Add((uint)cdiEntry.ID, new List <uint> {
(uint)cdiEntry.TextureVariationFileDataID[0], (uint)cdiEntry.TextureVariationFileDataID[1], (uint)cdiEntry.TextureVariationFileDataID[2]
});
}
break;
}
}
return(returnList);
}
public SpellDataSupplier(DBCManager dbcManager, string build, byte level = 60, sbyte difficulty = -1, short mapID = -1)
{
this.build = build;
this.dbcManager = dbcManager;
this.level = level;
this.difficulty = difficulty;
this.mapID = mapID;
}
public override void OnStart()
{
if (!ObjectManager.IsInGame)
{
return;
}
DBCManager dbc = new DBCManager();
dbc.Initialize();
Stop();
}
public ActionResult ExportCSV(string name, string build)
{
Logger.WriteLine("Exporting DBC " + name + " for build " + build);
try
{
var storage = DBCManager.LoadDBC(name, build);
if (storage.Values.Count == 0)
{
throw new Exception("No rows found!");
}
var fields = DefinitionManager.definitionCache[(name, build)].GetFields();
public HeaderResult Get(string name, string build)
{
Console.WriteLine("Handling headers for " + name + " (" + build + ")");
var result = new HeaderResult();
var storage = DBCManager.LoadDBC(name, build);
if (storage.Values.Count == 0)
{
throw new Exception("No rows found!");
}
if (!DefinitionManager.definitionLookup.ContainsKey(name))
{
throw new KeyNotFoundException("Definition for " + name);
}
var definition = DefinitionManager.definitionLookup[name];
var fields = DefinitionManager.definitionCache[(name, build)].GetFields();
public ExportController(IDBCManager dbcManager)
{
this.dbcManager = dbcManager as DBCManager;
}
public TooltipController(IDBDProvider dbdProvider, IDBCManager dbcManager)
{
this.dbdProvider = dbdProvider as DBDProvider;
this.dbcManager = dbcManager as DBCManager;
}
public HotfixController(IDBCManager dbcManager)
{
this.dbcManager = dbcManager as DBCManager;
}
public SpellDataSupplier(DBCManager dbcManager, string build)
{
this.build = build;
this.dbcManager = dbcManager;
}
public PeekController(IDBCManager dbcManager)
{
this.dbcManager = dbcManager as DBCManager;
}
private void UpdateMapListView()
{
if (!File.Exists("mapnames.csv"))
{
UpdateMapList();
}
if (File.Exists("mapnames.csv") && mapNames.Count == 0)
{
using (var parser = new TextFieldParser("mapnames.csv"))
{
parser.TextFieldType = FieldType.Delimited;
parser.SetDelimiters(",");
while (!parser.EndOfData)
{
var fields = parser.ReadFields();
if (fields[0] != "ID")
{
mapNames.Add(int.Parse(fields[0]), new NiceMapEntry {
ID = fields[0], Name = fields[4], Internal = fields[2], Type = fields[3], Expansion = fields[5]
});
}
}
}
}
mapListBox.DisplayMemberPath = "Value";
mapListBox.Items.Clear();
try
{
if (!File.Exists("definitions/Map.dbd"))
{
UpdateDefinition("Map");
}
var build = CASC.BuildName;
var storage = DBCManager.LoadDBC("map", build, true);
foreach (dynamic entry in storage.Values)
{
var mapID = entry.ID;
var mapDirectory = entry.Directory;
var mapName = entry.MapName_lang;
var mapExpansionID = entry.ExpansionID;
if (CASC.FileExists("World/Maps/" + mapDirectory + "/" + mapDirectory + ".wdt"))
{
var mapItem = new MapListItem {
Internal = mapDirectory
};
if (mapNames.ContainsKey(mapID))
{
mapItem.Name = mapNames[mapID].Name;
mapItem.Type = mapNames[mapID].Type;
var expansionID = ExpansionNameToID(mapNames[mapID].Expansion);
mapItem.Image = "pack://application:,,,/Resources/wow" + expansionID + ".png";
if (!mapFilters.Contains("wow" + expansionID) || !mapFilters.Contains(mapItem.Type))
{
continue;
}
}
else
{
mapItem.Name = mapName;
mapItem.Type = "Unknown";
mapItem.Image = "pack://application:,,,/Resources/wow" + (mapExpansionID + 1) + ".png";
}
if (string.IsNullOrEmpty(filterTextBox.Text) || (mapDirectory.IndexOf(filterTextBox.Text, 0, StringComparison.CurrentCultureIgnoreCase) != -1 || mapName.IndexOf(filterTextBox.Text, 0, StringComparison.CurrentCultureIgnoreCase) != -1))
{
mapListBox.Items.Add(mapItem);
}
}
}
}
catch (Exception ex)
{
Console.WriteLine("An error occured during DBC reading.. falling back to CSV!" + ex.Message);
foreach (var map in mapNames)
{
if (CASC.FileExists("World/Maps/" + map.Value.Internal + "/" + map.Value.Internal + ".wdt"))
{
mapListBox.Items.Add(new MapListItem {
Name = map.Value.Name, Internal = map.Value.Internal, Type = map.Value.Type, Image = "pack://application:,,,/Resources/wow" + ExpansionNameToID(map.Value.Expansion) + ".png"
});
}
}
}
mapsLoaded = true;
}
private static void Main(string[] args)
{
var config = new ConfigurationBuilder().SetBasePath(Directory.GetCurrentDirectory()).AddJsonFile("settings.json", true, true).Build();
var saveExplored = bool.Parse(config["saveExploredMaps"]);
var saveUnexplored = bool.Parse(config["saveUnexploredMaps"]);
var saveLayers = bool.Parse(config["saveMapLayers"]);
if (saveExplored && !Directory.Exists("explored"))
{
Directory.CreateDirectory("explored");
}
if (saveUnexplored && !Directory.Exists("unexplored"))
{
Directory.CreateDirectory("unexplored");
}
if (saveLayers && !Directory.Exists("layers"))
{
Directory.CreateDirectory("layers");
}
var locale = CASCLib.LocaleFlags.enUS;
if (config["locale"] != string.Empty)
{
switch (config["locale"])
{
case "deDE":
locale = CASCLib.LocaleFlags.deDE;
break;
case "enUS":
locale = CASCLib.LocaleFlags.enUS;
break;
case "ruRU":
locale = CASCLib.LocaleFlags.ruRU;
break;
case "zhCN":
locale = CASCLib.LocaleFlags.zhCN;
break;
case "zhTW":
locale = CASCLib.LocaleFlags.zhTW;
break;
}
}
if (config["installDir"] != string.Empty && Directory.Exists(config["installDir"]))
{
CASC.InitCasc(null, config["installDir"], config["program"], locale);
}
else
{
CASC.InitCasc(null, null, config["program"], locale);
}
using (var UIMapStream = CASC.OpenFile("DBFilesClient\\UIMap.db2"))
using (var UIMapXArtStream = CASC.OpenFile("DBFilesClient\\UIMapXMapArt.db2"))
using (var UIMapArtTileStream = CASC.OpenFile("DBFilesClient\\UIMapArtTile.db2"))
using (var WorldMapOverlayStream = CASC.OpenFile("DBFilesClient\\WorldMapOverlay.db2"))
using (var WorldMapOverlayTileStream = CASC.OpenFile("DBFilesClient\\WorldMapOverlayTile.db2"))
{
if (!Directory.Exists("dbcs"))
{
Directory.CreateDirectory("dbcs");
}
var uimapfs = File.Create("dbcs/UIMap.db2");
UIMapStream.CopyTo(uimapfs);
uimapfs.Close();
var uimapxartfs = File.Create("dbcs/UIMapXMapArt.db2");
UIMapXArtStream.CopyTo(uimapxartfs);
uimapxartfs.Close();
var uimapatfs = File.Create("dbcs/UIMapArtTile.db2");
UIMapArtTileStream.CopyTo(uimapatfs);
uimapatfs.Close();
var wmofs = File.Create("dbcs/WorldMapOverlay.db2");
WorldMapOverlayStream.CopyTo(wmofs);
wmofs.Close();
var wmotfs = File.Create("dbcs/WorldMapOverlayTile.db2");
WorldMapOverlayTileStream.CopyTo(wmotfs);
wmotfs.Close();
}
var UIMap = DBCManager.LoadDBC("UIMap", CASC.BuildName);
var UIMapXArt = DBCManager.LoadDBC("UIMapXMapArt", CASC.BuildName);
var UIMapArtTile = DBCManager.LoadDBC("UIMapArtTile", CASC.BuildName);
var WorldMapOverlay = DBCManager.LoadDBC("WorldMapOverlay", CASC.BuildName);
var WorldMapOverlayTile = DBCManager.LoadDBC("WorldMapOverlayTile", CASC.BuildName);
Console.WriteLine(); // new line after wdc2 debug output
foreach (dynamic mapRow in UIMap)
{
var mapName = mapRow.Value.Name_lang;
Console.WriteLine(mapRow.Key + " = " + mapName);
foreach (dynamic mxaRow in UIMapXArt)
{
var uiMapArtID = mxaRow.Value.UiMapArtID;
var uiMapID = mxaRow.Value.UiMapID;
if (mxaRow.Value.PhaseID != 0)
{
continue; // Skip phase stuff for now
}
if (uiMapID == mapRow.Key)
{
var maxRows = uint.MinValue;
var maxCols = uint.MinValue;
var tileDict = new Dictionary <string, int>();
foreach (dynamic matRow in UIMapArtTile)
{
var matUiMapArtID = matRow.Value.UiMapArtID;
if (matUiMapArtID == uiMapArtID)
{
var fdid = matRow.Value.FileDataID;
var rowIndex = matRow.Value.RowIndex;
var colIndex = matRow.Value.ColIndex;
var layerIndex = matRow.Value.LayerIndex;
// Skip other layers for now
if (layerIndex != 0)
{
continue;
}
if (rowIndex > maxRows)
{
maxRows = rowIndex;
}
if (colIndex > maxCols)
{
maxCols = colIndex;
}
tileDict.Add(rowIndex + "," + colIndex, fdid);
}
}
var res_x = (maxRows + 1) * 256;
var res_y = (maxCols + 1) * 256;
var bmp = new Bitmap((int)res_y, (int)res_x);
var g = Graphics.FromImage(bmp);
for (var cur_x = 0; cur_x < maxRows + 1; cur_x++)
{
for (var cur_y = 0; cur_y < maxCols + 1; cur_y++)
{
var fdid = tileDict[cur_x + "," + cur_y];
if (CASC.FileExists((uint)fdid))
{
using (var stream = CASC.OpenFile((uint)fdid))
{
try
{
var blp = new BlpFile(stream);
g.DrawImage(blp.GetBitmap(0), cur_y * 256, cur_x * 256, new Rectangle(0, 0, 256, 256), GraphicsUnit.Pixel);
}
catch (Exception e)
{
Console.WriteLine("An error occured opening BLP with filedataid " + fdid);
}
}
}
}
}
if (saveUnexplored)
{
bmp.Save("unexplored/ " + CleanFileName(mapRow.Key + " - " + mapName + ".png"));
}
if (!saveLayers && !saveExplored)
{
continue;
}
foreach (dynamic wmorow in WorldMapOverlay)
{
var WMOUIMapArtID = wmorow.Value.UiMapArtID;
var offsetX = wmorow.Value.OffsetX;
var offsetY = wmorow.Value.OffsetY;
uint maxWMORows = 0;
uint maxWMOCols = 0;
var wmoTileDict = new Dictionary <string, int>();
if (WMOUIMapArtID == uiMapArtID)
{
foreach (dynamic wmotrow in WorldMapOverlayTile)
{
var worldMapOverlayID = wmotrow.Value.WorldMapOverlayID;
// something wrong in/around this check
if (worldMapOverlayID == wmorow.Key)
{
var fdid = wmotrow.Value.FileDataID;
var rowIndex = wmotrow.Value.RowIndex;
var colIndex = wmotrow.Value.ColIndex;
var layerIndex = wmotrow.Value.LayerIndex;
// Skip other layers for now
if (layerIndex != 0)
{
continue;
}
if (rowIndex > maxWMORows)
{
maxWMORows = rowIndex;
}
if (colIndex > maxWMOCols)
{
maxWMOCols = colIndex;
}
wmoTileDict.Add(rowIndex + "," + colIndex, fdid);
}
}
}
if (wmoTileDict.Count == 0)
{
continue;
}
var layerResX = (maxWMORows + 1) * 256;
var layerResY = (maxWMOCols + 1) * 256;
var layerBitmap = new Bitmap((int)layerResY, (int)layerResX);
var layerGraphics = Graphics.FromImage(layerBitmap);
for (var cur_x = 0; cur_x < maxWMORows + 1; cur_x++)
{
for (var cur_y = 0; cur_y < maxWMOCols + 1; cur_y++)
{
var fdid = wmoTileDict[cur_x + "," + cur_y];
if (CASC.FileExists((uint)fdid))
{
using (var stream = CASC.OpenFile((uint)fdid))
{
try
{
var blp = new BlpFile(stream);
var posY = cur_y * 256 + offsetX;
var posX = cur_x * 256 + offsetY;
if (saveLayers)
{
layerGraphics.DrawImage(blp.GetBitmap(0), cur_y * 256, cur_x * 256, new Rectangle(0, 0, 256, 256), GraphicsUnit.Pixel);
}
g.DrawImage(blp.GetBitmap(0), posY, posX, new Rectangle(0, 0, 256, 256), GraphicsUnit.Pixel);
}
catch (Exception e)
{
Console.WriteLine("An error occured opening BLP with filedataid " + fdid);
}
}
}
}
}
if (saveLayers)
{
if (!Directory.Exists("layers/" + CleanFileName(mapRow.Key + " - " + mapName) + "/"))
{
Directory.CreateDirectory("layers/" + CleanFileName(mapRow.Key + " - " + mapName) + "/");
}
layerBitmap.Save("layers/" + CleanFileName(mapRow.Key + " - " + mapName) + "/" + wmorow.Key + ".png");
}
}
if (saveExplored)
{
bmp.Save("explored/ " + CleanFileName(mapRow.Key + " - " + mapName + ".png"));
}
}
}
}
}
public FindController(IDBCManager dbcManager)
{
this.dbcManager = dbcManager as DBCManager;
}
public ReloadDefsController(IDBDProvider dbdProvider, IDBCManager dbcManager)
{
this.dbdProvider = dbdProvider as DBDProvider;
this.dbcManager = dbcManager as DBCManager;
}
public DiffController(IDBCManager dbcManager)
{
this.dbcManager = dbcManager as DBCManager;
}
public TextureController(IDBCManager dbcManager)
{
this.dbcManager = dbcManager as DBCManager;
}
public EncryptedSectionController(IDBDProvider dbdProvider, IDBCManager dbcManager)
{
this.dbdProvider = dbdProvider as DBDProvider;
this.dbcManager = dbcManager as DBCManager;
}
