コード例 #1
0
ファイル: Program.cs プロジェクト: Nze25/StarWarsMod
        private static void Main(string[] args)
        {
            Arguments.EmptyChestRandom    = false;
            Arguments.IgnoreAirBlocks     = false;
            Arguments.IgnoreChestToEntity = false;
            Arguments.UseTemplate         = "default.java";
            Arguments.UsePackage          = "your.mod.pkg";
            Arguments.UseBlocks           = "blocks.txt";
            Arguments.UseItems            = "items.txt";

            Console.ForegroundColor = ConsoleColor.White;

            Console.Title = "SchematicExporter - Ready";

            if (!Directory.Exists("logs/"))
            {
                Directory.CreateDirectory("logs/");
            }
            _logWriter = new StreamWriter(string.Format("logs/log-{0}.log", DateTime.Now.Ticks));

            _logWriter.WriteLine("Running with args: {0}\n\n", string.Join(", ", args));

            if (args.Length > 0)
            {
                foreach (var s in args)
                {
                    switch (s)
                    {
                    case "-emptyloot":
                        Arguments.EmptyChestRandom = true;
                        Console.WriteLine("Custom Setting: empty chests will be filled with random loot");
                        break;

                    case "-ignoreair":
                        Arguments.IgnoreAirBlocks = true;
                        Console.WriteLine("Custom Setting: air blocks will not be exported");
                        break;

                    case "-r":
                        Arguments.SearchRecursive = true;
                        Console.WriteLine("Custom Setting: input directory searched recursively");
                        break;

                    case "-nochestentity":
                        Arguments.IgnoreChestToEntity = true;
                        Console.WriteLine(
                            "Custom Setting: chests with entity selectors inside will not export as entities");
                        break;

                    case "-help":
                        Console.WriteLine("Available arguments:");
                        Console.WriteLine(
                            "-emptyloot\n\tEmpty chests (instead of blaze rod in top left corner) will be filled with random loot");
                        Console.WriteLine(
                            "-template:<template file>\n\tOutout will be generated based off of template/<template file>" +
                            "\n\tPlaceholders:" +
                            "\n\t\t{{CLASS_COMMENT}}" +
                            "\n\t\t{{PACKAGE}}" +
                            "\n\t\t{{CLASS}}" +
                            "\n\t\t{{GEN_METHODS}}" +
                            "\n\t\t{{IMPORTS}}");
                        Console.WriteLine("-package:<package>\n\tThe package for the file to be exported for");
                        Console.WriteLine("-blocks:<blocks>\n\tThe dictionary file to pull blocks from");
                        Console.WriteLine("-items:<items>\n\tThe dictionary file to pull items from");
                        Console.WriteLine("-ignoreair\n\tAir blocks will not be exported");
                        Console.WriteLine("-r\n\tInput directory will be searched recursively");
                        Console.WriteLine(
                            "-nochestentity\n\tChests with entity selectors inside will not export as entities");
                        Console.WriteLine("Press any key to exit...");
                        Console.ReadKey();
                        Environment.Exit(0);
                        break;

                    default:
                        if (new Regex("-template:(\\S+)").IsMatch(s))
                        {
                            Arguments.UseTemplate = s.Split(':')[1];
                            Console.WriteLine("Custom Setting: using template/{0}", Arguments.UseTemplate);
                        }
                        else if (new Regex("-package:(\\S+)").IsMatch(s))
                        {
                            Arguments.UsePackage = s.Split(':')[1];
                            Console.WriteLine("Custom Setting: using package {0}", Arguments.UsePackage);
                        }
                        else if (new Regex("-blocks:(\\S+)").IsMatch(s))
                        {
                            Arguments.UseBlocks = s.Split(':')[1];
                            Console.WriteLine("Custom Setting: using block dictionary data/{0}", Arguments.UseBlocks);
                        }
                        else if (new Regex("-items:(\\S+)").IsMatch(s))
                        {
                            Arguments.UseItems = s.Split(':')[1];
                            Console.WriteLine("Custom Setting: using item dictionary data/{0}", Arguments.UseItems);
                        }
                        else
                        {
                            Console.WriteLine("Invalid argument: \"{0}\"", s);
                            Console.WriteLine("Use \"-help\" for a list of available arguments");
                        }
                        break;
                    }
                }
                Console.WriteLine();
            }

            // Check I/O directories
            if (!Directory.Exists("input/"))
            {
                Directory.CreateDirectory("input/");
                Console.WriteLine("Created input directory");
                _logWriter.WriteLine("Input directory not found, created one.");
            }
            if (!Directory.Exists("output/"))
            {
                Directory.CreateDirectory("output/");
                Console.WriteLine("Created output directory");
                _logWriter.WriteLine("Output directory not found, created one.");
            }
            // Draw the header
            Console.WriteLine("{0}{1}{2}{3}{4}{5}{6}{7}", "File".PadRight(40), "Iterate".PadRight(10),
                              "Blocks".PadRight(10), "Tiles".PadRight(10), "Methods".PadRight(10), "Write".PadRight(10),
                              "Total".PadRight(10), "Filesize".PadRight(10));
            Console.WriteLine("".PadRight(110, '='));

            // Start a stopwatch to time the exports
            var totalElapse = new Stopwatch();

            totalElapse.Start();

            // File counter
            var files = 0;

            foreach (var rFile in Utils.GetFiles("input", "*.schematic", Arguments.SearchRecursive))
            {
                //load the schematic
                var s = new Schematic(rFile);
                _logWriter.WriteLine("Loaded schematic {0}, found {1} blocks", rFile, s.Size());

                var upperFirstName = Utils.UpperFirst(Path.GetFileNameWithoutExtension(rFile));
                // Set how you want to export
                var options = new ExportOptions("WorldGen" + upperFirstName + "{0}.java", Arguments.UsePackage,
                                                "WorldGen" + upperFirstName + "{0}", Path.GetDirectoryName(rFile).Substring(5));

                _logWriter.WriteLine("Exporting with options: className={0}, package={1}", string.Format(options.ClassName, ""), options.Package);

                // Actually export the schematic
                var oldChunks = Metrics.TotalChunks;
                _logWriter.Write("Exporting chunks... ");
                try
                {
                    Metrics.TotalChunks += Exporter.Export(options, s);
                    _logWriter.WriteLine("Exported {0} chunks", Metrics.TotalChunks - oldChunks);
                }
                catch (Exception exception)
                {
                    Console.ForegroundColor = ConsoleColor.Yellow;
                    Console.WriteLine("\nError while exporting, check log for details!\n");
                    _logWriter.WriteLine("Error while exporting {0}: {1}\n{2}", rFile, exception.Message, exception.StackTrace);
                }

                _logWriter.WriteLine();

                Console.ForegroundColor = ConsoleColor.DarkCyan;

                files++;
            }
            totalElapse.Stop();
            Console.Title           = "SchematicExporter - Done";
            Console.ForegroundColor = ConsoleColor.White;
            Console.WriteLine();
            Console.WriteLine("Done exporting {0:n0} file{3} ({2:n0} chunk{4}) in {1}", files,
                              Utils.MillisToHrd(totalElapse.ElapsedMilliseconds), Metrics.TotalChunks, files == 1 ? "" : "s", Metrics.TotalChunks == 1 ? "" : "s");
            if (Metrics.TotalChunks > 0)
            {
                Console.WriteLine("\tAverage Time\t\t{0}",
                                  Utils.MillisToHrd(totalElapse.ElapsedMilliseconds / Metrics.TotalChunks));
                Console.WriteLine("\tAverage Files/Second\t{0:n0}", 1000 / ((float)totalElapse.ElapsedMilliseconds / Metrics.TotalChunks));
                Console.WriteLine("\tBlocks (incl. air)\t{0:n0}", Metrics.TotalBlocks);
                Console.WriteLine("\tTiles\t\t\t{0:n0}", Metrics.TotalTiles);
                Console.WriteLine("\tAverage Filesize\t{0}", Utils.SizeSuffix(Metrics.TotalFilesize / Metrics.TotalChunks));
                Console.WriteLine("\tTotal Filesize\t\t{0}", Utils.SizeSuffix(Metrics.TotalFilesize));
                Console.WriteLine("\tChunks over 1 MB\t{0:n0} ({1}%)", Metrics.FilesOverOneMeg, 100 * Metrics.FilesOverOneMeg / Metrics.TotalChunks);
            }

            _logWriter.Close();

            Console.Read();
        }
コード例 #2
0
ファイル: ChunkExport.cs プロジェクト: Nze25/StarWarsMod
        /// <summary>
        /// Exports a single chunk
        /// </summary>
        /// <param name="options">The export options</param>
        /// <param name="schematic">The schematic to export</param>
        /// <param name="chunkX">The chunk X to export</param>
        /// <param name="chunkZ">The chunk Y to export</param>
        public static void Export(ExportOptions options, Schematic schematic, int chunkX, int chunkZ)
        {
            if (!Directory.Exists("template/"))
            {
                Directory.CreateDirectory("template/");
            }

            Console.ForegroundColor = ConsoleColor.White;
            string clazz = string.Format(options.ClassName, string.Format("_x{0}_z{1}", chunkX, chunkZ));

            Console.Write((clazz.Length <= 38 ? clazz : "..." + clazz.Substring(clazz.Length - 35, 35)).PadRight(40));

            // Load the java template
            var template = Utils.RequireFile(string.Format("template/{0}", Arguments.UseTemplate)).ReadToEnd();

            Console.ForegroundColor = ConsoleColor.Green;

            var gen      = new StringBuilder();
            var tiles    = new StringBuilder();
            var imports  = new StringBuilder();
            var lImports = new List <string>();

            // Load primary imports
            lImports.Require("net.minecraft.world.World");
            lImports.Require("static com.parzivail.util.world.WorldUtils.b");
            lImports.Require("static com.parzivail.util.world.WorldUtils.m");

            var numStatements = 0;
            var currentGen    = 0;

            // Start an overall timer
            var swOverall = new Stopwatch();

            swOverall.Start();

            // Start an iterate timer
            var swIterate = new Stopwatch();

            swIterate.Start();

            // Iterate over tile entities
            var totalTiles = 0;
            var l          = schematic.GetTileEntities();

            for (var i = 0; i < l.Count; i++)
            {
                var t = (NbtCompound)l[i];
                var x = t["x"].IntValue;
                var y = t["y"].IntValue;
                var z = t["z"].IntValue;

                if (t["id"].StringValue != "Chest" || !(x >= chunkX &&
                                                        x < chunkX + 16 &&
                                                        z >= chunkZ &&
                                                        z < chunkZ + 16))
                {
                    continue;
                }

                tiles.Append(JavaBuilder.MakeChest(ref schematic, ref lImports, totalTiles, x, y, z, "\t\t"));
                totalTiles++;
            }

            // Iterate over blocks
            gen.AppendLine(JavaBuilder.MakeGen(currentGen));
            gen.AppendLine("\t{");
            for (var x = chunkX; x < chunkX + 16; x++)
            {
                for (var y = 0; y < schematic.Height; y++)
                {
                    for (var z = chunkZ; z < chunkZ + 16; z++)
                    {
                        if (x >= schematic.Width || z >= schematic.Length)
                        {
                            continue;
                        }

                        var b = schematic.GetBlockAt(x, y, z);

                        if (schematic.GetFlagAt(x, y, z) ||
                            (b.GetName() == "air" && Arguments.IgnoreAirBlocks))
                        {
                            continue;
                        }

                        lImports.Require("static " + b.CreateJavaVariable());
                        gen.Append(JavaBuilder.MakeSetBlockLine(schematic, ref lImports, x, y, z, chunkX, chunkZ));
                        numStatements++;
                        //Console.WriteLine(schematic.getBlockIdAt(x, y, z));

                        if (numStatements <= Exporter.MaxBlocksPerGen)
                        {
                            continue;
                        }

                        numStatements = 0;
                        currentGen++;
                        gen.AppendLine(JavaBuilder.MakeCallGen(currentGen));
                        gen.AppendLine("\t}");
                        gen.AppendLine(JavaBuilder.MakeGen(currentGen));
                        gen.AppendLine("\t{");
                    }
                }
            }

            // Sort imports
            lImports.Sort();
            for (var i = 0; i < lImports.Count; i++)
            {
                imports.AppendFormat("import {0};\r\n", lImports[i]);
            }

            swIterate.Stop();
            var iterateElapsed = swIterate.ElapsedMilliseconds;

            gen.Append(tiles);

            gen.AppendLine("\t}");

            // Replace template placeholders with true data
            template = template.Replace("{{CLASS_COMMENT}}", Exporter.HeaderComment());
            template = template.Replace("{{PACKAGE}}", options.Package);
            template = template.Replace("{{CLASS}}",
                                        new StringBuilder().AppendFormat(options.ClassName, new StringBuilder().AppendFormat("_x{0}_z{1}", chunkX, chunkZ)).ToString());
            template = template.Replace("{{GEN_METHODS}}", gen.ToString());
            template = template.Replace("{{IMPORTS}}", imports.ToString());

            var blocks = currentGen * Exporter.MaxBlocksPerGen + numStatements;

            swIterate.Restart();

            Metrics.TotalBlocks += blocks;
            Metrics.TotalTiles  += totalTiles;

            // Write data to file
            using (
                var w =
                    new StreamWriter("output/" + options.Path + "/" +
                                     new StringBuilder().AppendFormat(options.FileName, new StringBuilder().AppendFormat("_x{0}_z{1}", chunkX, chunkZ))))
                w.WriteLine(template);

            swIterate.Stop();
            swOverall.Stop();

            Console.ForegroundColor = ConsoleColor.Blue;
            Console.Write(Utils.MillisToHrd(iterateElapsed).PadRight(10));

            Console.ForegroundColor = ConsoleColor.DarkGreen;
            Console.Write("{0}{1}{2}", new StringBuilder().AppendFormat("{0:n0}", blocks).ToString().PadRight(10),
                          new StringBuilder().AppendFormat("{0:n0}", totalTiles).ToString().PadRight(10), new StringBuilder().AppendFormat("{0:n0}", currentGen + 1).ToString().PadRight(10));

            Console.ForegroundColor = ConsoleColor.Blue;
            Console.Write("{0}{1}", Utils.MillisToHrd(swIterate.ElapsedMilliseconds).PadRight(10),
                          Utils.MillisToHrd(swOverall.ElapsedMilliseconds).PadRight(10));

            var isize = File.ReadAllBytes("output/" + options.Path + "/" +
                                          new StringBuilder().AppendFormat(options.FileName, new StringBuilder().AppendFormat("_x{0}_z{1}", chunkX, chunkZ)))
                        .Length;

            Metrics.TotalFilesize += isize;

            var size =
                Utils.SizeSuffix(
                    isize);

            if (size.Contains("MB"))
            {
                Console.ForegroundColor = ConsoleColor.Yellow;
                Metrics.FilesOverOneMeg++;
            }
            else
            {
                Console.ForegroundColor = ConsoleColor.DarkGreen;
            }
            Console.Write(size.PadRight(10));

            Console.WriteLine();
        }