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 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 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; }
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; }