Exemplo n.º 1
0
        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);
                    }
                }
            }
        }
Exemplo n.º 2
0
        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));
        }
Exemplo n.º 3
0
        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);
        }
Exemplo n.º 4
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);
                    }
                }
            }
        }
Exemplo n.º 5
0
        private static string GetMapMPQDir(MapId map)
        {
            var mapName = TileIdentifier.GetName(map);

            return(Path.Combine(baseDir, mapName));
        }
Exemplo n.º 6
0
        /// <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);
        }