public MpqTerrainManager(TileIdentifier tileId)
{
var wowRootDir = DBCTool.FindWowDir();
MpqManager = new MpqManager(wowRootDir);
TileId = tileId;
var entries = GetMapEntries();
MapInfo entry = null;
foreach (var item in entries)
{
if (item.Id != tileId.MapId)
{
continue;
}
entry = item;
break;
}
WDTParser.MpqManager = MpqManager;
_wdt = WDTParser.Process(entry);
_adtManager = new ADTManager(this);
_wmoManager = new WMOManager();
_m2Manager = new M2Manager();
_meshManager = new NavMeshManager();
_selectedTriangleManager = new SelectedTriangleManager(_adtManager);
}
public static ADT ExtractWMOOnly(WDT wdt)
{
var tileId = new TileIdentifier
{
MapId = wdt.Entry.Id,
MapName = wdt.Name,
TileX = 0,
TileY = 0
};
var adt = new ADT(tileId);
adt.ObjectDefinitions.Capacity = wdt.WmoDefinitions.Count;
foreach (var wmoDefinition in wdt.WmoDefinitions)
{
adt.ObjectDefinitions.Add(wmoDefinition);
}
adt.ObjectFiles.Capacity = wdt.WmoFiles.Count;
foreach (var wmoFile in wdt.WmoFiles)
{
adt.ObjectFiles.Add(wmoFile);
}
foreach (var def in adt.ObjectDefinitions)
{
LoadWMO(wdt.Manager, def);
}
adt.IsWMOOnly = true;
return(adt);
}
private static void StartDefaultViewer(World world, TileIdentifier tileId)
{
using (var game = new TerrainViewer(AvatarPosition.ToXna(), world, tileId))
{
game.Run();
}
}
public MpqTerrainManager(TileIdentifier tileId)
{
var wowRootDir = DBCTool.FindWowDir();
MpqManager = new MpqManager(wowRootDir);
TileId = tileId;
var entries = GetMapEntries();
MapInfo entry = null;
foreach (var item in entries)
{
if (item.Id != tileId.MapId) continue;
entry = item;
break;
}
WDTParser.MpqManager = MpqManager;
_wdt = WDTParser.Process(entry);
_adtManager = new ADTManager(this);
_wmoManager = new WMOManager();
_m2Manager = new M2Manager();
_meshManager = new NavMeshManager();
_selectedTriangleManager = new SelectedTriangleManager(_adtManager);
}
private static void StartDefaultViewer(World world, TileIdentifier tileId)
{
using (var game = new TerrainViewer(AvatarPosition.ToXna(), world, tileId))
{
game.Run();
}
}
private Vector3 GetTileCenterPosition(TileIdentifier tileID, Vector3 tileSize)
{
Vector3 center = new Vector3((tileID.coordX + 0.5f) * tileSize.x, 0.45f * tileSize.y, (tileID.coordZ + 0.5f) * tileSize.z);
center.y += Utility.GetTerrainHeight(center);
return(center);
}
public static void ExtractAndWriteAll()
{
foreach (MapId mapId in Enum.GetValues(typeof(MapId)))
{
var name = TileIdentifier.GetName(mapId);
if (string.IsNullOrEmpty(name))
{
Console.WriteLine(@"No ADT for map {0}.", mapId);
continue;
}
var terrain = new SimpleTerrain(mapId);
for (var tileX = 0; tileX < 64; tileX++)
{
for (var tileY = 0; tileY < 64; tileY++)
{
string filePath;
MpqLibrarian mpqFinder;
if (!ADTReader.TryGetADTPath(mapId, tileX, tileY, out filePath, out mpqFinder))
{
continue;
}
// try to extract from MPQ
//var adt = ADTReader.ReadADT(terrain, tileX, tileY);
//Console.WriteLine(@"EXPORTING: Tile ({0}, {1}) in Map {2} ...", tileX, tileY, mapId);
//Console.WriteLine(@"Extraction will take a while, please have patience...");
try
{
var adt = WDT.LoadTile(mapId, tileX, tileY);
if (adt != null)
{
Console.WriteLine(@"Tile ({0}, {1}) in Map {2} has been imported...", tileX, tileY, mapId);
Console.WriteLine(@"Writing to file...");
// export to file
SimpleTileWriter.WriteADT(adt);
// try loading again
Console.WriteLine(@"Loading extracted tile and generating Navigation mesh...");
terrain.ForceLoadTile(tileX, tileY);
if (terrain.IsAvailable(tileX, tileY))
{
Console.WriteLine(@"Done. Tile ({0}, {1}) in Map {2} has been loaded successfully.", tileX, tileY, mapId);
continue;
}
}
}
catch (ArgumentException)
{
}
Console.WriteLine(@"Loading FAILED: Tile ({0}, {1}) in Map {2} could not be loaded", tileX, tileY, mapId);
}
}
}
}
public bool LoadTile(TileIdentifier tileId)
{
var loaded = _adtManager.LoadTile(tileId);
if (!loaded)
{
// Do something drastic
}
return(loaded);
}
public ExtractedTerrainManager(string dataPath, TileIdentifier tileId)
{
_mapId = tileId.MapId;
_baseDirectory = dataPath;
_adtManager = new ExtractedADTManager(this, _baseDirectory, _mapId);
_m2Manager = new ExtractedM2Manager(_baseDirectory, _mapId);
_wmoManager = new ExtractedWMOManager(_baseDirectory, _mapId);
_meshManager = new NavMeshManager();
_selectedTriangleManager = new SelectedTriangleManager(_adtManager);
}
internal static Rect GetTileBoundingRect(TileIdentifier tileId)
{
var tileX = tileId.TileX;
var tileY = tileId.TileY;
var x = TerrainConstants.CenterPoint - (tileX * TerrainConstants.TileSize);
var botX = x - TerrainConstants.TileSize;
var y = TerrainConstants.CenterPoint - (tileY * TerrainConstants.TileSize);
var botY = y - TerrainConstants.TileSize;
return(new Rect(new Point(x, y), new Point(TerrainConstants.TileSize, TerrainConstants.TileSize)));
}
private static void LoadInitialData(TileIdentifier defaultTileId)
{
var terrain = new SimpleWDTTerrain(defaultTileId.MapId, false);
world.WorldTerrain.Add(defaultTileId.MapId, terrain);
terrain.GetOrCreateTile(defaultTileId.MapId, defaultTileId.X, defaultTileId.Y);
AvatarPosition = new Vector3(TerrainConstants.CenterPoint - (defaultTileId.X + 1) * TerrainConstants.TileSize,
TerrainConstants.CenterPoint - (defaultTileId.Y) * TerrainConstants.TileSize,
100.0f);
}
public ExtractedTerrainManager(string dataPath, TileIdentifier tileId)
{
_mapId = tileId.MapId;
_baseDirectory = dataPath;
_adtManager = new ExtractedADTManager(this, _baseDirectory, _mapId);
_m2Manager = new ExtractedM2Manager(_baseDirectory, _mapId);
_wmoManager = new ExtractedWMOManager(_baseDirectory, _mapId);
_meshManager = new NavMeshManager();
_selectedTriangleManager = new SelectedTriangleManager(_adtManager);
}
private static void LoadInitialData(TileIdentifier defaultTileId)
{
var terrain = new SimpleWDTTerrain(defaultTileId.MapId, false);
world.WorldTerrain.Add(defaultTileId.MapId, terrain);
terrain.GetOrCreateTile(defaultTileId.MapId, defaultTileId.X, defaultTileId.Y);
AvatarPosition = new Vector3(TerrainConstants.CenterPoint - (defaultTileId.X + 1) * TerrainConstants.TileSize,
TerrainConstants.CenterPoint - (defaultTileId.Y) * TerrainConstants.TileSize,
100.0f);
}
public static string GetFilename(MapId map, int x, int y)
{
var name = TileIdentifier.GetName(map);
if (name == null)
{
throw new ArgumentException("Map does not exist: " + map);
}
var fileName = string.Format("{0}\\{0}_{1}_{2}{3}", name, y, x, Extension);
return(Path.Combine(baseDir, fileName));
}
public static void CreateAndWriteAllMeshes()
{
GC.AddMemoryPressure(1 * 1024 * 1024 * 1024);
foreach (MapId mapId in Enum.GetValues(typeof(MapId)))
{
var name = TileIdentifier.GetName(mapId);
if (string.IsNullOrEmpty(name))
{
Console.WriteLine(@"No ADT for map {0}.", mapId);
continue;
}
var terrain = new SimpleTerrain(mapId);
for (var tileX = 0; tileX < 64; tileX++)
{
for (var tileY = 0; tileY < 64; tileY++)
{
string filePath;
MpqLibrarian mpqFinder;
if (!ADTReader.TryGetADTPath(mapId, tileX, tileY, out filePath, out mpqFinder))
{
continue;
}
try
{
var adt = WDT.LoadTile(mapId, tileX, tileY);
if (adt != null)
{
// try loading
Console.WriteLine(@"Loading extracted tile and generating Navigation mesh...");
terrain.ForceLoadTile(tileX, tileY);
if (terrain.IsAvailable(tileX, tileY))
{
Console.WriteLine(@"Done. Tile ({0}, {1}) in Map {2} has been loaded successfully.", tileX, tileY, mapId);
terrain.Tiles[tileX, tileY] = null;
continue;
}
}
}
catch (ArgumentException)
{
}
Console.WriteLine(@"Extracting FAILED: Tile ({0}, {1}) in Map {2} could not be loaded", tileX, tileY, mapId);
}
}
}
GC.RemoveMemoryPressure(1 * 1024 * 1024 * 1024);
}
/// <summary>
/// Tries to get the tile with the given TileId. If the tile is not loaded,
/// tries to load the tile from disk.
/// </summary>
/// <param name="tileId"><see cref="TileIdentifier"/> that describes the desired Tile.</param>
/// <param name="tile">Tile object to fill with data</param>
/// <returns>True if able to find/load the tile.</returns>
private bool TryGetTile(TileIdentifier tileId, out Tile tile)
{
if (!_tiles.TryGetValue(tileId, out tile))
{
if (!Tile.TryLoad(tileId, out tile))
{
log.Warn("Unable to load requested tile: {0}", tileId);
return(false);
}
_tiles.Add(tileId, tile);
}
return(true);
}
private Vector3[] GetPathInNavmesh(TileIdentifier tile, Vector3 startPos, Vector3 endPos)
{
SetNavmeshSurface(tile, mapInfoLevel_1);
surface.BuildNavMesh();
//NavMesh.SamplePosition(startPos, out var startHit, 0.4f, areaMask);
//NavMesh.SamplePosition(startPos, out var endHit, 0.4f, areaMask);
NavMesh.CalculatePath(startPos, endPos, areaMask, navmeshPath);
if (navmeshPath.status == NavMeshPathStatus.PathComplete)
{
return(navmeshPath.corners);
}
Debug.LogError("Error Path " + navmeshPath.status + " " + tile);
Debug.DrawLine(startPos, endPos, Color.red, 10f);
return(new Vector3[0]);
}
public static void ExtractAllADTs()
{
foreach (MapId mapId in Enum.GetValues(typeof(MapId)))
{
var name = TileIdentifier.GetName(mapId);
if (string.IsNullOrEmpty(name))
{
Console.WriteLine(@"No ADT for map {0}.", mapId);
continue;
}
var wdt = new WDT(mapId);
for (var tileX = 0; tileX < 64; tileX++)
{
for (var tileY = 0; tileY < 64; tileY++)
{
string filePath;
MpqLibrarian mpqFinder;
if (!ADTReader.TryGetADTPath(mapId, tileX, tileY, out filePath, out mpqFinder))
{
continue;
}
try
{
wdt.TileProfile[tileX, tileY] = true;
var adt = ADTReader.ReadADT(wdt, tileX, tileY);
if (adt != null)
{
adt.GenerateMapWithNoSimplification();
Console.WriteLine(@"Tile ({0}, {1}) in Map {2} has been imported...", tileX, tileY, mapId);
Console.WriteLine(@"Writing to file...");
// export to file
SimpleTileWriter.WriteADT(adt);
continue;
}
}
catch (ArgumentException)
{
}
Console.WriteLine(@"Extracting FAILED: Tile ({0}, {1}) in Map {2} could not be loaded", tileX, tileY, mapId);
}
}
}
}
internal static bool TryLoad(TileIdentifier tileId, out Tile tile)
{
tile = null;
var mpqManager = new MpqTerrainManager(tileId);
if (!mpqManager.LoadTile(tileId)) return false;
tile = new Tile
{
//_terrainTree = mpqManager.ADTManager.MapTiles[0].QuadTree,
//_m2Tree = ((M2Manager) mpqManager.M2Manager).QuadTree,
//_wmoTree = ((WMOManager) mpqManager.WMOManager).QuadTree,
Bounds = PositionUtil.GetTileBoundingRect(tileId),
};
return true;
}
internal static bool TryLoad(TileIdentifier tileId, out Tile tile)
{
tile = null;
var mpqManager = new MpqTerrainManager(tileId);
if (!mpqManager.LoadTile(tileId)) return false;
tile = new Tile
{
//_terrainTree = mpqManager.ADTManager.MapTiles[0].QuadTree,
//_m2Tree = ((M2Manager) mpqManager.M2Manager).QuadTree,
//_wmoTree = ((WMOManager) mpqManager.WMOManager).QuadTree,
Bounds = PositionUtil.GetTileBoundingRect(tileId),
};
return true;
}
public static ADT[,] ExtractMapTiles(WDT wdt)
{
var mapTiles = new ADT[TerrainConstants.TilesPerMapSide, TerrainConstants.TilesPerMapSide];
for (var x = 0; x < TerrainConstants.TilesPerMapSide; x++)
{
for (var y = 0; y < TerrainConstants.TilesPerMapSide; y++)
{
if (!wdt.TileProfile[y, x])
{
continue;
}
if (x != 49 || y != 36)
{
continue;
}
var tileId = new TileIdentifier
{
MapId = wdt.Entry.Id,
MapName = wdt.Name,
TileX = x,
TileY = y
};
var adt = ADTParser.Process(WDTExtractor.MpqManager, tileId);
if (adt == null)
{
continue;
}
adt.IsWMOOnly = false;
// Load in the WMORoots and their DoodadDefinitions
// Load in the ADTs referenced M2Models
PrepareChunkInfo(wdt.Manager, adt);
ReduceTerrainTris(adt);
LoadQuadTree(adt);
mapTiles[y, x] = adt;
}
}
return(mapTiles);
}
/// <summary>
/// Loads an ADT into the manager.
/// </summary>
/// <param name="tileId">The <see cref="TileIdentifier"/> describing the tile to load.</param>
public bool LoadTile(TileIdentifier tileId)
{
var currentADT = ADTParser.Process(MpqTerrainManager.MpqManager, tileId);
foreach (var objectDef in currentADT.ObjectDefinitions)
{
_mpqTerrainManager.WMOManager.AddWMO(objectDef);
}
foreach (var doodadDef in currentADT.DoodadDefinitions)
{
_mpqTerrainManager.M2Manager.Add(doodadDef);
}
currentADT.GenerateHeightVertexAndIndices();
currentADT.GenerateLiquidVertexAndIndices();
currentADT.LoadQuadTree();
_ADTs.Add(currentADT);
return(false);
}
/// <summary>
/// Loads an ADT into the manager.
/// </summary>
/// <param name="tileId">The <see cref="TileIdentifier"/> describing the tile to load.</param>
public bool LoadTile(TileIdentifier tileId)
{
var currentADT = ADTParser.Process(MpqTerrainManager.MpqManager, tileId);
foreach (var objectDef in currentADT.ObjectDefinitions)
{
_mpqTerrainManager.WMOManager.AddWMO(objectDef);
}
foreach (var doodadDef in currentADT.DoodadDefinitions)
{
_mpqTerrainManager.M2Manager.Add(doodadDef);
}
currentADT.GenerateHeightVertexAndIndices();
currentADT.GenerateLiquidVertexAndIndices();
currentADT.LoadQuadTree();
_ADTs.Add(currentADT);
return false;
}
public bool LoadTile(TileIdentifier tileId)
{
var tileX = tileId.TileX;
var tileY = tileId.TileY;
if (!Directory.Exists(_basePath))
{
throw new DirectoryNotFoundException(string.Format("Invalid base directory for extracted map data: {0}", _basePath));
}
var mapPath = Path.Combine(_basePath, _mapId.ToString());
var fileName = string.Format("{0}_{1}{2}", tileY, tileX, ".map");
var filePath = Path.Combine(mapPath, fileName);
if (!File.Exists(filePath))
{
throw new FileNotFoundException("Invalid path or file name: {0}", filePath);
}
var currentADT = ExtractedADTParser.Process(filePath, _mapId, tileX, tileY);
foreach (var def in currentADT.M2Defs)
{
_terrainManager.M2Manager.Add(def);
}
foreach (var def in currentADT.WMODefs)
{
_terrainManager.WMOManager.AddWMO(def);
}
currentADT.GenerateHeightVertexAndIndices();
currentADT.GenerateLiquidVertexAndIndices();
MapTiles.Add(currentADT);
return(true);
}
public bool LoadTile(TileIdentifier tileId)
{
var tileX = tileId.TileX;
var tileY = tileId.TileY;
if (!Directory.Exists(_basePath))
{
throw new DirectoryNotFoundException(string.Format("Invalid base directory for extracted map data: {0}", _basePath));
}
var mapPath = Path.Combine(_basePath, _mapId.ToString());
var fileName = string.Format("{0}_{1}{2}", tileY, tileX, ".map");
var filePath = Path.Combine(mapPath, fileName);
if (!File.Exists(filePath))
{
throw new FileNotFoundException("Invalid path or file name: {0}", filePath);
}
var currentADT = ExtractedADTParser.Process(filePath, _mapId, tileX, tileY);
foreach (var def in currentADT.M2Defs)
{
_terrainManager.M2Manager.Add(def);
}
foreach (var def in currentADT.WMODefs)
{
_terrainManager.WMOManager.AddWMO(def);
}
currentADT.GenerateHeightVertexAndIndices();
currentADT.GenerateLiquidVertexAndIndices();
MapTiles.Add(currentADT);
return true;
}
/// <summary>
/// Tries to get the tile with the given TileId. If the tile is not loaded,
/// tries to load the tile from disk.
/// </summary>
/// <param name="tileId"><see cref="TileIdentifier"/> that describes the desired Tile.</param>
/// <param name="tile">Tile object to fill with data</param>
/// <returns>True if able to find/load the tile.</returns>
private bool TryGetTile(TileIdentifier tileId, out Tile tile)
{
if (!_tiles.TryGetValue(tileId, out tile))
{
if (!Tile.TryLoad(tileId, out tile))
{
log.Warn("Unable to load requested tile: {0}", tileId);
return false;
}
_tiles.Add(tileId, tile);
}
return true;
}
private static void ExtractMapObjects(WDT wdt)
{
if (wdt == null) return;
if (wdt.Header.Header1.HasFlag(WDTFlags.GlobalWMO))
{
// No terrain, load the global WMO
if (wdt.WmoDefinitions == null) return;
ExtractWMOs(wdt.WmoDefinitions);
}
else
{
for (var tileX = 0; tileX < TerrainConstants.TilesPerMapSide; tileX++)
{
for (var tileY = 0; tileY < TerrainConstants.TilesPerMapSide; tileY++)
{
if (!wdt.TileProfile[tileY, tileX]) continue;
if (tileX != 49 || tileY != 36) continue;
ADT adt = null;
if (TileExtractor.TerrainInfo != null)
{
adt = TileExtractor.TerrainInfo[tileY, tileX];
}
if (adt == null)
{
var tileId = new TileIdentifier
{
MapId = wdt.Entry.Id,
MapName = wdt.Entry.InternalName,
TileX = tileX,
TileY = tileY
};
adt = ADTParser.Process(wdt.Manager, tileId);
}
if (adt == null) continue;
ExtractTileWMOs(adt);
ExtractTileM2s(adt);
}
}
}
PrepareMapWMOs();
PrepareMapM2s();
WriteMapM2s(wdt.Entry);
WriteMapWMOs(wdt.Entry);
}
public TerrainTile GetOrCreateTile(TileIdentifier tileId)
{
return GetOrCreateTile(tileId.MapId, tileId.X, tileId.Y);
}
public static ADT Process(MpqManager mpqManager, TileIdentifier tileId)
{
var fileName = string.Format("{0}\\{0}_{1}_{2}{3}", tileId.MapName, tileId.TileY, tileId.TileX, Extension);
var filePath = Path.Combine(baseDir, fileName);
var adt = new ADT(tileId);
if (!mpqManager.FileExists(filePath))
{
log.Error("ADT file does not exist: ", filePath);
}
using (var stream = mpqManager.OpenFile(filePath))
using (var fileReader = new BinaryReader(stream))
{
ReadMVER(fileReader, adt);
ReadMHDR(fileReader, adt);
if (adt.Header.offsInfo != 0)
{
fileReader.BaseStream.Position = adt.Header.Base + adt.Header.offsInfo;
ReadMCIN(fileReader, adt);
}
//if (adt.Header.offsTex != 0)
//{
// fileReader.BaseStream.Position = adt.Header.Base + adt.Header.offsTex;
// ReadMTEX(fileReader, adt);
//}
if (adt.Header.offsModels != 0)
{
fileReader.BaseStream.Position = adt.Header.Base + adt.Header.offsModels;
ReadMMDX(fileReader, adt);
}
if (adt.Header.offsModelIds != 0)
{
fileReader.BaseStream.Position = adt.Header.Base + adt.Header.offsModelIds;
ReadMMID(fileReader, adt);
}
if (adt.Header.offsMapObjects != 0)
{
fileReader.BaseStream.Position = adt.Header.Base + adt.Header.offsMapObjects;
ReadMWMO(fileReader, adt);
}
if (adt.Header.offsMapObjectIds != 0)
{
fileReader.BaseStream.Position = adt.Header.Base + adt.Header.offsMapObjectIds;
ReadMWID(fileReader, adt);
}
if (adt.Header.offsDoodadDefinitions != 0)
{
fileReader.BaseStream.Position = adt.Header.Base + adt.Header.offsDoodadDefinitions;
ReadMDDF(fileReader, adt);
}
if (adt.Header.offsObjectDefinitions != 0)
{
fileReader.BaseStream.Position = adt.Header.Base + adt.Header.offsObjectDefinitions;
ReadMODF(fileReader, adt);
}
//if (adt.Header.offsFlightBoundary != 0)
//{
// fileReader.BaseStream.Position = adt.Header.Base + adt.Header.offsFlightBoundary;
// ReadMFBO(fileReader, adt);
//}
if (adt.Header.offsMH2O != 0)
{
fileReader.BaseStream.Position = adt.Header.Base + adt.Header.offsMH2O;
ReadMH2O(fileReader, adt);
}
ReadMCNK(fileReader, adt);
}
return(adt);
}
public static ADT[,] ExtractMapTiles(WDT wdt)
{
var mapTiles = new ADT[TerrainConstants.TilesPerMapSide, TerrainConstants.TilesPerMapSide];
for (var x = 0; x < TerrainConstants.TilesPerMapSide; x++)
{
for (var y = 0; y < TerrainConstants.TilesPerMapSide; y++)
{
if (!wdt.TileProfile[y, x]) continue;
if (x != 49 || y != 36) continue;
var tileId = new TileIdentifier
{
MapId = wdt.Entry.Id,
MapName = wdt.Name,
TileX = x,
TileY = y
};
var adt = ADTParser.Process(WDTExtractor.MpqManager, tileId);
if (adt == null) continue;
adt.IsWMOOnly = false;
// Load in the WMORoots and their DoodadDefinitions
// Load in the ADTs referenced M2Models
PrepareChunkInfo(wdt.Manager, adt);
ReduceTerrainTris(adt);
LoadQuadTree(adt);
mapTiles[y, x] = adt;
}
}
return mapTiles;
}
private void AddTileToDisplay(TileIdentifier tileId)
{
var terrain = world.GetOrLoadSimpleWDTTerrain(tileId.MapId);
var tile = terrain.GetOrCreateTile(tileId);
if (tile == null) return;
var renderer = new TileRenderer(this, tile);
renderer.LiquidEnabled = liquidRenderingEnabled;
renderer.NavMeshEnabled = navMeshRenderingEnabled;
TileRenderers.Add(tileId, renderer);
Tiles.Add(tile);
Components.Add(renderer);
}
/// <summary>
/// Constructor for the game.
/// </summary>
public TerrainViewer(XVector3 avatarPosition, World world, TileIdentifier tileId)
{
TerrainViewer.avatarPosition = avatarPosition;
_graphics = new GraphicsDeviceManager(this);
_graphics.GraphicsProfile = GraphicsProfile.HiDef;
Content.RootDirectory = "Content";
avatarYaw = MathHelper.ToRadians(90);
Form = (Form)Control.FromHandle(Window.Handle);
this.world = world;
activeTerrain = (SimpleWDTTerrain)world.WorldTerrain[tileId.MapId];
var tile = activeTerrain.Tiles[tileId.X, tileId.Y];
ActiveTile = tile;
m_Tiles = new List<TerrainTile> { tile };
TileRenderers = new Dictionary<TileIdentifier, TileRenderer>((int)MapId.End);
}
public bool LoadTile(TileIdentifier tileId)
{
var loaded = _adtManager.LoadTile(tileId);
return loaded;
}
public bool LoadTile(TileIdentifier tileId)
{
var loaded = _adtManager.LoadTile(tileId);
if (!loaded)
{
// Do something drastic
}
return loaded;
}
/// <summary>
/// Extracts all heightfields of the given map
/// </summary>
public static bool ExtractHeightfield(MapId mapId)
{
var name = TileIdentifier.GetName(mapId);
if (string.IsNullOrEmpty(name))
{
Console.WriteLine(@"No ADT for map {0}.", mapId);
return(false);
}
// get started
var mpqFinder = WCellTerrainSettings.GetDefaultMPQFinder();
// Create WDT
var wdt = new WDT(mapId);
var startTime = DateTime.Now;
// compute total size
Console.Write(@"Estimating workload... ");
var totalAmount = 0;
var archives = new HashSet <string>();
for (var tileX = 0; tileX < TerrainConstants.TilesPerMapSide; tileX++)
{
for (var tileY = 0; tileY < TerrainConstants.TilesPerMapSide; tileY++)
{
var fname = ADTReader.GetFilename(mapId, tileX, tileY);
var archive = mpqFinder.GetArchive(fname);
if (archive != null && archive.GetFileSize(fname) > 0)
{
//totalSize += archive.GetFileSize(fname);
++totalAmount;
archives.Add(archive.Path);
}
}
}
Console.WriteLine(@"Done - Found {0} tiles in {1} files.", totalAmount, archives.Count);
// Get cooking:
Console.WriteLine();
Console.WriteLine("Extracting...");
// Load all ADTs and write them to file
var processedTiles = 0;
for (var tileX = 0; tileX < TerrainConstants.TilesPerMapSide; tileX++)
{
for (var tileY = 0; tileY < TerrainConstants.TilesPerMapSide; tileY++)
{
try
{
var fname = ADTReader.GetFilename(mapId, tileX, tileY);
long fsize;
var archive = mpqFinder.GetArchive(fname);
if (archive != null && (fsize = archive.GetFileSize(fname)) > 0)
{
//processedSize += fsize;
var adt = ADTReader.ReadADT(wdt, tileX, tileY, false);
Console.Write(@"Tile ({0}, {1}) in Map {2} has been read from {3}. Writing... ",
tileX, tileY, mapId, Path.GetFileName(archive.Path));
// write to file
WriteHeightfield(adt);
// stats
++processedTiles;
var timePassed = DateTime.Now - startTime;
var timePerTile = timePassed.Ticks / processedTiles;
var progress = processedTiles / (float)totalAmount;
var timeRemaining = new TimeSpan((totalAmount - processedTiles) * timePerTile);
Console.WriteLine(@"Done. [{0}/{1} {2:F2}% - {3} (Remaining: {4})]",
processedTiles,
totalAmount,
100 * progress,
timePassed.Format(),
timeRemaining.Format());
continue;
}
}
catch (Exception e)
{
Console.WriteLine();
LogUtil.ErrorException(e, @"Extraction FAILED: Tile ({0}, {1}) in Map {2} could not be loaded", tileX, tileY, mapId);
return(false);
}
}
}
return(true);
}
private static void ExtractMapObjects(WDT wdt)
{
if (wdt == null)
{
return;
}
if (wdt.Header.Header1.HasFlag(WDTFlags.GlobalWMO))
{
// No terrain, load the global WMO
if (wdt.WmoDefinitions == null)
{
return;
}
ExtractWMOs(wdt.WmoDefinitions);
}
else
{
for (var tileX = 0; tileX < TerrainConstants.TilesPerMapSide; tileX++)
{
for (var tileY = 0; tileY < TerrainConstants.TilesPerMapSide; tileY++)
{
if (!wdt.TileProfile[tileY, tileX])
{
continue;
}
if (tileX != 49 || tileY != 36)
{
continue;
}
ADT adt = null;
if (TileExtractor.TerrainInfo != null)
{
adt = TileExtractor.TerrainInfo[tileY, tileX];
}
if (adt == null)
{
var tileId = new TileIdentifier
{
MapId = wdt.Entry.Id,
MapName = wdt.Entry.InternalName,
TileX = tileX,
TileY = tileY
};
adt = ADTParser.Process(wdt.Manager, tileId);
}
if (adt == null)
{
continue;
}
ExtractTileWMOs(adt);
ExtractTileM2s(adt);
}
}
}
PrepareMapWMOs();
PrepareMapM2s();
WriteMapM2s(wdt.Entry);
WriteMapWMOs(wdt.Entry);
}
/// <summary>
/// Constructor for the game.
/// </summary>
public TerrainViewer(XVector3 avatarPosition, World world, TileIdentifier tileId)
{
TerrainViewer.avatarPosition = avatarPosition;
_graphics = new GraphicsDeviceManager(this);
_graphics.GraphicsProfile = GraphicsProfile.HiDef;
Content.RootDirectory = "Content";
avatarYaw = MathHelper.ToRadians(90);
Form = (Form)Control.FromHandle(Window.Handle);
this.world = world;
m_Tiles = new List<TerrainTile>();
TileRenderers = new Dictionary<TileIdentifier, TileRenderer>((int)MapId.End);
if (world.WorldTerrain.TryGetValue(tileId.MapId, out activeTerrain))
{
InitialTile = activeTerrain.Tiles[tileId.X, tileId.Y];
}
}
public void SearchOnLevel1()
{
finalPath.Clear();
_currentPath.Clear();
TileIdentifier startTile = mapInfoLevel_1.GetTileIdentifier(start.transform.position);
TileIdentifier endTile = mapInfoLevel_1.GetTileIdentifier(end.transform.position);
List <NavigationNode> startNodes = mapInfoLevel_1.navigationGraph.GetTileNodes(startTile);
List <NavigationNode> endNodes = mapInfoLevel_1.navigationGraph.GetTileNodes(endTile);
Debug.Log($"{startTile} Start Nodes Count :{startNodes.Count} \n" +
$" {endTile} End Nodes Count : {endNodes.Count}");
SetNavmeshSurface(startTile, mapInfoLevel_1);
surface.BuildNavMesh();
if (startTile == endTile)
{
NavMesh.CalculatePath(start.transform.position, end.transform.position, areaMask, navmeshPath);
if (navmeshPath.status == NavMeshPathStatus.PathComplete)
{
finalPath.AddRange(navmeshPath.corners);
}
return;
}
bool hasPath = false;
for (int i = 0; i < startNodes.Count; i++)
{
NavMesh.CalculatePath(start.transform.position, startNodes[i].value.position, areaMask, navmeshPath);
Debug.Log(navmeshPath.status);
if (navmeshPath.status != NavMeshPathStatus.PathComplete)
{
Debug.DrawLine(start.transform.position, startNodes[i].value.position, Color.red, 5f);
continue;
}
for (int j = 0; j < endNodes.Count; j++)
{
hasPath = mapInfoLevel_1.navigationGraph.Search(startNodes[i], endNodes[j], _currentPath);
if (hasPath)
{
break;
}
}
if (hasPath)
{
Debug.Log("Find abstract path! Count : " + _currentPath.Count);
break;
}
}
if (hasPath && findDetailedPath)
{
Vector3 startPos = start.transform.position;
Vector3 endPos = end.transform.position;
for (int i = 0; i < _currentPath.Count; i++)
{
if (_currentPath[i].value.ownerTileID == startTile && i == 0)
{
finalPath.AddRange(GetPathInNavmesh(startTile, startPos, _currentPath[i].value.position));
}
if (_currentPath[i].value.ownerTileID == endTile && i == _currentPath.Count - 1)
{
finalPath.AddRange(GetPathInNavmesh(endTile, _currentPath[i].value.position, endPos));
return;
}
bool isCrossTile = mapInfoLevel_1.navigationGraph.IsCrossTileNeibour(_currentPath[i], _currentPath[i + 1]);
if (isCrossTile)
{
finalPath.Add(_currentPath[i].value.position);
finalPath.Add(_currentPath[i + 1].value.position);
}
else
{
finalPath.AddRange(GetPathInNavmesh(_currentPath[i].value.ownerTileID, _currentPath[i].value.position, _currentPath[i + 1].value.position));
}
}
}
}
public ADT(TileIdentifier tileId)
{
_tileId = tileId;
}
private static string GetMapMPQDir(MapId map)
{
var mapName = TileIdentifier.GetName(map);
return(Path.Combine(baseDir, mapName));
}
public bool LoadTile(TileIdentifier tileId)
{
var loaded = _adtManager.LoadTile(tileId);
return(loaded);
}
private bool ToggleDisplayedTile(MapId map, Point2D coords)
{
var tileId = new TileIdentifier(map, coords);
if (TileRenderers.ContainsKey(tileId))
{
RemoveTileFromDisplay(tileId);
IsMenuVisible = false;
return false;
}
// GUI stuff
if (worker.IsBusy) return false;
IsMenuVisible = false;
GetOrCreateWaitingBox("Loading tile - Please wait...").Visible = true;
addingTile = (sender, b) => AddTileToDisplay(tileId);
worker.DoWork += addingTile;
completedLoad = (sender, e) =>
{
UpdateTerrainViewer(false);
worker.DoWork -= addingTile;
worker.RunWorkerCompleted -= completedLoad;
};
worker.RunWorkerCompleted += completedLoad;
worker.RunWorkerAsync();
return true;
}
/// <summary>
/// Checks this Map for LOS between two positions.
/// </summary>
/// <param name="pos1">The start position.</param>
/// <param name="pos2">The end position.</param>
/// <returns>True if there is a clear LOS between the points.</returns>
internal bool HasLOS(Vector3 pos1, Vector3 pos2)
{
// The max distance check has already been performed.
var tile1Id = TileIdentifier.ByPosition(MapId, pos1);
if (tile1Id == null)
{
log.Warn("Got an invalid Tile Coord for {0}. Assuming LOS for now.", pos1);
return(true);
}
var tile2Id = TileIdentifier.ByPosition(MapId, pos2);
if (tile2Id == null)
{
log.Warn("Got an invalid Tile Coord for {0}. ", pos1);
return(true);
}
Tile tile;
if (!TryGetTile(tile1Id, out tile))
{
log.Error("Unable to load the given tile: {0} to check for LOS. Assuming LOS for now.", tile1Id);
return(true);
}
// if the positions are on the same tile, things get easier
if (tile1Id == tile2Id)
{
return(tile.HasLOS(pos1, pos2));
}
// else the LOS line segment crosses tile boundaries (possibly more than one.)
var lineRect = new Rect(new Point(pos1.X, pos1.Y), new Point(pos2.X, pos2.Y));
var tile1Rect = tile.Bounds;
lineRect.Intersect(tile1Rect);
// we know that pos1 was internal to tile1, so lineRect contains pos1 and the new pos2.
var newPoint = lineRect.BottomRight;
var newPos2 = new Vector3(newPoint.X, newPoint.Y, pos2.Z);
if (!tile.HasLOS(pos1, newPos2))
{
return(false);
}
// clip the LOS line segment against the intervening tiles until tile2 is reached
pos1 = newPos2;
var dir = (pos2 - pos1);
dir.Normalize();
while (true)
{
// advance the start position by a small amount to ensure that we're on the new tile
pos1 += 1e-3f * dir;
tile1Id = TileIdentifier.ByPosition(MapId, pos1);
if (tile1Id == null)
{
log.Warn("Got an invalid Tile Coord for {0}. Assuming LOS for now.", pos1);
return(true);
}
if (!TryGetTile(tile1Id, out tile))
{
log.Error("Unable to load the given tile: {0} to check for LOS. Assuming LOS for now.", tile1Id);
return(true);
}
if (tile1Id == tile2Id)
{
return(tile.HasLOS(pos1, pos2));
}
lineRect = new Rect(new Point(pos1.X, pos1.Y), new Point(pos2.X, pos2.Y));
tile1Rect = tile.Bounds;
lineRect.Intersect(tile1Rect);
newPoint = lineRect.BottomRight;
newPos2 = new Vector3(newPoint.X, newPoint.Y, pos2.Z);
if (!tile.HasLOS(pos1, newPos2))
{
return(false);
}
pos1 = newPos2;
}
}
public ADT(TileIdentifier tileId, MpqTerrainManager mpqTerrainManager) : this(tileId)
{
_mpqTerrainManager = mpqTerrainManager;
}
private TerrainTile LoadAndDisplayTile(TileIdentifier tileId, bool loadNeis)
{
while (m_Tiles.Count > MaxTileCount)
{
// Can't display too many tiles at once due to memory limitations
// Remove renderer from Components and tile from tiles
RemoveTileFromDisplay(m_Tiles[0].TileId);
}
var terrain = world.GetOrLoadSimpleWDTTerrain(tileId.MapId);
var tile = terrain.GetOrCreateTile(tileId);
Form.Invoke(new Action(() => DisplayTile(tile)));
if (loadNeis && tile != null)
{
LoadAndDisplayNeighbors(tile);
}
return tile;
}
private bool ToggleTileDisplay(MapId map, Point2D coords, bool move)
{
var tileId = new TileIdentifier(map, coords);
if (TileRenderers.ContainsKey(tileId))
{
RemoveTileFromDisplay(tileId);
UpdateTerrainViewer(false);
IsMenuVisible = false;
return false;
}
// GUI stuff & background loader
if (worker.IsBusy) return false;
IsMenuVisible = false;
GetOrCreateWaitingBox("Loading tile - Please wait...").Visible = true;
addingTile = (sender, b) => b.Result = LoadAndDisplayTile(tileId, move);
worker.DoWork += addingTile;
completedLoad = (sender, args) =>
{
// type: RunWorkerCompletedEventArgs
var tile = (TerrainTile)args.Result;
UpdateTerrainViewer(false);
worker.DoWork -= addingTile;
worker.RunWorkerCompleted -= completedLoad;
if (move)
{
avatarPosition = new WVector3(TerrainConstants.CenterPoint - (tile.TileX + 1) * TerrainConstants.TileSize,
TerrainConstants.CenterPoint - (tile.TileY) * TerrainConstants.TileSize,
100.0f).ToXna();
}
};
worker.RunWorkerCompleted += completedLoad;
worker.RunWorkerAsync();
return true;
}
public override int GetHashCode()
{
var tileHash = TileIdentifier == null ? 0x0 : 0x675FABC1 ^ TileIdentifier.GetHashCode();
return(tileHash ^ (Name ?? String.Empty).GetHashCode());
}
private void LoadAndDisplayNeighbors(TerrainTile tile, int radius = 4)
{
for (var y = tile.TileY - radius; y < tile.TileY + radius; ++y)
{
for (var x = tile.TileX - radius; x < tile.TileX + radius; ++x)
{
var id = new TileIdentifier(tile.TileId, x, y);
LoadAndDisplayTile(id, false);
}
}
}
public void SetNavmeshSurface(TileIdentifier tileID, NavigationMapInfo mapInfo)
{
surface.size = mapInfo.tileSize + new Vector3(2.0f, 0, 2.0f);
surface.center = GetTileCenterPosition(tileID, mapInfo.tileSize);
}
private void RemoveTileFromDisplay(TileIdentifier tileId)
{
var renderer = TileRenderers[tileId];
TileRenderers.Remove(tileId);
Tiles.RemoveFirst(tile => (tile.TileId == tileId));
Components.Remove(renderer);
renderer.Dispose();
}
public static ADT ExtractWMOOnly(WDT wdt)
{
var tileId = new TileIdentifier
{
MapId = wdt.Entry.Id,
MapName = wdt.Name,
TileX = 0,
TileY = 0
};
var adt = new ADT(tileId);
adt.ObjectDefinitions.Capacity = wdt.WmoDefinitions.Count;
foreach (var wmoDefinition in wdt.WmoDefinitions)
{
adt.ObjectDefinitions.Add(wmoDefinition);
}
adt.ObjectFiles.Capacity = wdt.WmoFiles.Count;
foreach (var wmoFile in wdt.WmoFiles)
{
adt.ObjectFiles.Add(wmoFile);
}
foreach (var def in adt.ObjectDefinitions)
{
LoadWMO(wdt.Manager, def);
}
adt.IsWMOOnly = true;
return adt;
}
