private void button1_Click(object sender, EventArgs e) { Bitmap bm = new Bitmap(2048, 2176); NbtWorld world = NbtWorld.Open(@"E:\games\Curse\Instances\Modern Skyblock 2\saves\Kekimuro"); // The chunk manager is more efficient than the block manager for // this purpose, since we'll inspect every block Substrate.Core.IChunkManager rcm = world.GetChunkManager(); foreach (ChunkRef chunk in rcm) { // You could hardcode your dimensions, but maybe some day they // won't always be 16. Also the CLR is a bit stupid and has // trouble optimizing repeated calls to Chunk.Blocks.xx, so we // cache them in locals int xdim = chunk.Blocks.XDim; int ydim = chunk.Blocks.YDim; int zdim = chunk.Blocks.ZDim; AnvilBiomeCollection chunkBiome = chunk.Biomes; // x, z, y is the most efficient order to scan blocks (not that // you should care about internal detail) for (int x = 0; x < xdim; x++) { for (int z = 0; z < zdim; z++) { int biome = chunkBiome.GetBiome(x, z); bm.SetPixel(chunk.X * xdim + x, chunk.Z * zdim + z, Biomes.id2color(biome)); } } } pictureBox1.Image = bm; }
public void BlockTest_1_9_2_debug() { NbtWorld world = NbtWorld.Open(@"..\..\Data\1_9_2-debug\"); Assert.IsNotNull(world); bool dataError = false; for (int x = DebugWorld.MinX; x < DebugWorld.MaxX; x += 2) { for (int z = DebugWorld.MinZ; z < DebugWorld.MaxZ; z += 2) { var blockRef = world.GetBlockManager().GetBlockRef(x, DebugWorld.Y, z); var blockInfo = BlockInfo.BlockTable[blockRef.ID]; Debug.WriteLine(string.Format("ID:{0} ({1}), Data:{2}", blockRef.ID, blockInfo.Name, blockRef.Data)); Assert.IsTrue(blockInfo.Registered, "Block ID {0} has not been registered", blockRef.ID); if (!blockInfo.TestData(blockRef.Data)) { dataError = true; Debug.WriteLine("Data value '0x{0:X4}' not recognised for block '{1}' at {2},{3}", blockRef.Data, blockInfo.Name, x, z); } } } }
static void Main(string[] args) { if (args.Length != 4) { Console.WriteLine("Usage: MoveSpawn <world> <x> <y> <z>"); return; } string dest = args[0]; int x = Convert.ToInt32(args[1]); int y = Convert.ToInt32(args[2]); int z = Convert.ToInt32(args[3]); // Open our world NbtWorld world = NbtWorld.Open(dest); // Set the level's spawn // Note: Players do not have separate spawns by default // If you wanted to change a player's spawn, you must set all // 3 coordinates for it to stick. It will not take the level's defaults. world.Level.Spawn = new SpawnPoint(x, y, z); // Save the changes world.Save(); }
public static void Main(string[] args) { TileEntityFactory.Register(TileEntityBrewingStand.TypeId, typeof(TileEntityBrewingStand)); TileEntityFactory.Register(TileEntityChest.TypeId, typeof(TileEntityChest)); TileEntityFactory.Register(TileEntityTrap.TypeId, typeof(TileEntityTrap)); TileEntityFactory.Register(TileEntityMobSpawner.TypeId, typeof(TileEntityMobSpawner)); string path = args.Length == 0 ? "." : string.Join(" ", args); NbtWorld world = NbtWorld.Open(path); if (world == null) { Dialog.WorldInvalidDialog(); return; } Console.WriteLine("Working with world: {0}", world.Level.LevelName); fixPotions = Dialog.FixPotionsDialog(); fixSpawners = Dialog.FixSpawnersDialog(); DateTime startTime = DateTime.Now; LoopChunks(world, Dimension.DEFAULT); LoopChunks(world, Dimension.NETHER); LoopChunks(world, Dimension.THE_END); TimeSpan time = DateTime.Now.Subtract(startTime); Console.Write("Finished searching {0} in {1}. Fixed:", world.Level.LevelName, time.ToString(@"h\:mm\:ss")); Console.Write(" [{0} chest{1}]", fixedIssues["chest"], fixedIssues["chest"] == 1 ? "" : "s"); Console.Write(" [{0} potion{1}]", fixedIssues["potion"], fixedIssues["potion"] == 1 ? "" : "s"); Console.Write(" [{0} spawner{1}]", fixedIssues["spawner"], fixedIssues["spawner"] == 1 ? "" : "s"); Console.WriteLine(); Dialog.NewDialog(); }
public override void Run() { NbtWorld world = GetWorld(opt); IChunkManager cm = world.GetChunkManager(opt.OPT_DIM); FilteredChunkManager fcm = new FilteredChunkManager(cm, opt.GetChunkFilter()); int affectedChunks = 0; foreach (ChunkRef chunk in fcm) { if (chunk == null || !chunk.IsTerrainPopulated) { continue; } if (opt.OPT_V) { Console.WriteLine("Processing Chunk (" + chunk.X + "," + chunk.Z + ")"); } affectedChunks++; ApplyChunk(world, chunk); fcm.Save(); } Console.WriteLine("Affected Chunks: " + affectedChunks); }
public override void Run() { NbtWorld world = GetWorld(opt); IChunkManager cm = world.GetChunkManager(opt.OPT_DIM); FilteredChunkManager fcm = new FilteredChunkManager(cm, opt.GetChunkFilter()); StreamWriter fstr; try { fstr = new StreamWriter(opt._outFile, false); } catch (IOException e) { Console.WriteLine(e.Message); return; } fstr.WriteLine("["); bool first = true; foreach (ChunkRef chunk in fcm) { if (!first) { fstr.Write(","); } Chunk c = chunk.GetChunkRef(); if (!opt._dumpBlocks) { c.Tree.Root["Level"].ToTagCompound().Remove("Blocks"); c.Tree.Root["Level"].ToTagCompound().Remove("Data"); c.Tree.Root["Level"].ToTagCompound().Remove("BlockLight"); c.Tree.Root["Level"].ToTagCompound().Remove("SkyLight"); c.Tree.Root["Level"].ToTagCompound().Remove("HeightMap"); } if (!opt._dumpEntities) { c.Tree.Root["Level"].ToTagCompound().Remove("Entities"); } if (!opt._dumpTileEntities) { c.Tree.Root["Level"].ToTagCompound().Remove("TileEntities"); } string s = JSONSerializer.Serialize(c.Tree.Root["Level"], 1); fstr.Write(s); first = false; } fstr.WriteLine(); fstr.WriteLine("]"); fstr.Close(); }
private World([NotNull] NbtWorld world) { if (world == null) { throw new ArgumentNullException("world"); } _nbtWorld = world; _directory = new DirectoryInfo(world.Path); }
public mapReader(string mapFilePath) { nbtWorld = NbtWorld.Open(mapFilePath); chunkManager = nbtWorld.GetChunkManager(); chunkEnumerator = chunkManager.GetEnumerator(); chunkEnumerator.MoveNext(); CurrentChunk = chunkEnumerator.Current; CurrentHeight = 0; readASlice(); }
public void initializeMinecraftWorld() { currentWorld = AnvilWorld.Create(Settings.Default.outputPath); // We can set different world parameters currentWorld.Level.LevelName = Settings.Default.levelName; currentWorld.Level.Spawn = new SpawnPoint(20, 255, 20); currentWorld.Level.GameType = GameType.CREATIVE; currentWorld.Level.AllowCommands = true; }
static void Main(string[] args) { if (args.Length != 3) { Console.WriteLine("Usage: BlockReplace <world> <before-id> <after-id>"); return; } string dest = args[0]; int before = Convert.ToInt32(args[1]); int after = Convert.ToInt32(args[2]); // Open our world NbtWorld world = NbtWorld.Open(dest); // The chunk manager is more efficient than the block manager for // this purpose, since we'll inspect every block IChunkManager cm = world.GetChunkManager(); foreach (ChunkRef chunk in cm) { // You could hardcode your dimensions, but maybe some day they // won't always be 16. Also the CLR is a bit stupid and has // trouble optimizing repeated calls to Chunk.Blocks.xx, so we // cache them in locals int xdim = chunk.Blocks.XDim; int ydim = chunk.Blocks.YDim; int zdim = chunk.Blocks.ZDim; // x, z, y is the most efficient order to scan blocks (not that // you should care about internal detail) for (int x = 0; x < xdim; x++) { for (int z = 0; z < zdim; z++) { for (int y = 0; y < ydim; y++) { // Replace the block with after if it matches before if (chunk.Blocks.GetID(x, y, z) == before) { chunk.Blocks.SetData(x, y, z, 0); chunk.Blocks.SetID(x, y, z, after); } } } } // Save the chunk cm.Save(); Console.WriteLine("Processed Chunk {0},{1}", chunk.X, chunk.Z); } }
public static World Open(string path) { var world = NbtWorld.Open(path); if (world == null) { return(null); } var mcfire = new World(world); return(mcfire); }
/// <summary> /// Loads the Mincraft world files into a Nbt file using Substrate /// </summary> /// <param name="inputPath">Location of Minecraft saved wold files</param> /// <returns>True if successfully loaded world</returns> public static bool LoadWorld(string inputPath) { importedWorld = NbtWorld.Open(inputPath); if (importedWorld != null) { return(true); } else { return(false); } }
static void Main(string[] args) { if (args.Length != 2) { Console.WriteLine("Usage: GoodyChest <world> <prob>"); return; } string dest = args[0]; double p = Convert.ToDouble(args[1]); rand = new Random(); // Open our world NbtWorld world = NbtWorld.Open(dest); IChunkManager cm = world.GetChunkManager(); int added = 0; // Iterate through every chunk in the world // With proability p, pick a random location // inside the chunk to place a chest, above the // first solid block foreach (ChunkRef chunk in cm) { if (rand.NextDouble() < p) { int x = rand.Next(chunk.Blocks.XDim); int z = rand.Next(chunk.Blocks.ZDim); int y = chunk.Blocks.GetHeight(x, z); // Can't build this high (-2 to account for new MC 1.6 height limitation) if (y >= chunk.Blocks.YDim - 2) { continue; } // Get a block object, then assign it to the chunk AlphaBlock block = BuildChest(); chunk.Blocks.SetBlock(x, y + 1, z, block); // Save the chunk cm.Save(); added++; } } // And we're done Console.WriteLine("Added {0} goody chests to world", added); }
static void Main(string[] args) { if (args.Length != 3) { Console.WriteLine("Usage: Convert <world> <dest> <alpha|beta|anvil>"); return; } string src = args[0]; string dst = args[1]; string srctype = args[2]; if (!Directory.Exists(dst)) { Directory.CreateDirectory(dst); } // Open source and destrination worlds depending on conversion type NbtWorld srcWorld = NbtWorld.Open(src); NbtWorld dstWorld; switch (srctype) { case "alpha": dstWorld = AlphaWorld.Create(dst); break; case "beta": dstWorld = BetaWorld.Create(dst); break; case "anvil": dstWorld = AnvilWorld.Create(dst); break; default: throw new Exception("Invalid conversion type"); } // Grab chunk managers to copy chunks IChunkManager cmsrc = srcWorld.GetChunkManager(); IChunkManager cmdst = dstWorld.GetChunkManager(); // Copy each chunk from source to dest foreach (ChunkRef chunk in cmsrc) { cmdst.SetChunk(chunk.X, chunk.Z, chunk.GetChunkRef()); Console.WriteLine("Copying chunk: {0}, {1}", chunk.X, chunk.Z); } // Copy level data from source to dest dstWorld.Level.LoadTreeSafe(srcWorld.Level.BuildTree()); // Save level.dat dstWorld.Level.Save(); }
static void Main(string[] args) { if (args.Length < 1) { Console.WriteLine("You must specify a target directory"); return; } string dest = args[0]; NbtVerifier.InvalidTagType += (e) => { throw new Exception("Invalid Tag Type: " + e.TagName + " [" + e.Tag + "]"); }; NbtVerifier.InvalidTagValue += (e) => { throw new Exception("Invalid Tag Value: " + e.TagName + " [" + e.Tag + "]"); }; NbtVerifier.MissingTag += (e) => { throw new Exception("Missing Tag: " + e.TagName); }; // Opening an NbtWorld will try to autodetect if a world is Alpha-style or Beta-style NbtWorld world = NbtWorld.Open(dest); // Grab a generic chunk manager reference IChunkManager cm = world.GetChunkManager(); // First blank out all of the lighting in all of the chunks foreach (ChunkRef chunk in cm) { chunk.Blocks.RebuildHeightMap(); chunk.Blocks.ResetBlockLight(); chunk.Blocks.ResetSkyLight(); cm.Save(); Console.WriteLine("Reset Chunk {0},{1}", chunk.X, chunk.Z); } // In a separate pass, reconstruct the light foreach (ChunkRef chunk in cm) { chunk.Blocks.RebuildBlockLight(); chunk.Blocks.RebuildSkyLight(); // Save the chunk to disk so it doesn't hang around in RAM cm.Save(); Console.WriteLine("Lit Chunk {0},{1}", chunk.X, chunk.Z); } }
protected override void SetWorld() { // Open MCA world m_MCAWorld = NbtWorld.Open(MCAPath); //m_cm = m_MCAWorld.GetChunkManager(); // Sanity check //int tmp = 0; //foreach(ChunkRef ch in m_cm) //{ // tmp++; // if(tmp > 100) { break; } // if(ch.Blocks == null) { continue; } // Debug.Log($"Good chunk at {ch.X}, {ch.Z}"); //} }
public override void Run() { NbtWorld world = GetWorld(opt); IChunkManager cm = world.GetChunkManager(opt.OPT_DIM); FilteredChunkManager fcm = new FilteredChunkManager(cm, opt.GetChunkFilter()); int affectedChunks = 0; foreach (ChunkRef chunk in fcm) { affectedChunks++; fcm.DeleteChunk(chunk.X, chunk.Z); } Console.WriteLine("Purged Chunks: " + affectedChunks); }
static void Main(string[] args) { if (args.Length != 1) { Console.WriteLine("Usage: CustomBlock <world>"); return; } string dest = args[0]; // Open our world NbtWorld world = NbtWorld.Open(dest); // The chunk manager is more efficient than the block manager for // this purpose, since we'll inspect every block IChunkManager cm = world.GetChunkManager(); foreach (ChunkRef chunk in cm) { // You could hardcode your dimensions, but maybe some day they // won't always be 16. Also the CLR is a bit stupid and has // trouble optimizing repeated calls to Chunk.Blocks.xx, so we // cache them in locals int xdim = chunk.Blocks.XDim; int ydim = chunk.Blocks.YDim; int zdim = chunk.Blocks.ZDim; chunk.Blocks.AutoFluid = true; // x, z, y is the most efficient order to scan blocks (not that // you should care about internal detail) for (int x = 0; x < xdim; x++) { for (int z = 0; z < zdim; z++) { for (int y = 0; y < ydim; y++) { BlockInfo info = chunk.Blocks.GetInfo(x, y, z); if (info.ID == BlockInfoM.LightSensor.ID) { Console.WriteLine("Found custom block '{0}' at {1}", info.Name, new BlockKey(x, y, z)); } } } } } }
static void Main(string[] args) { // Process arguments if (args.Length != 2 && args.Length != 6) { Console.WriteLine("Usage: PurgeEntities <world> <entityID> [<x1> <z1> <x2> <z2>]"); return; } string dest = args[0]; string eid = args[1]; // Our initial bounding box is "infinite" int x1 = BlockManager.MIN_X; int x2 = BlockManager.MAX_X; int z1 = BlockManager.MIN_Z; int z2 = BlockManager.MAX_Z; // If we have all coordinate parameters, set the bounding box if (args.Length == 6) { x1 = Convert.ToInt32(args[2]); z1 = Convert.ToInt32(args[3]); x2 = Convert.ToInt32(args[4]); z2 = Convert.ToInt32(args[5]); } // Load world NbtWorld world = NbtWorld.Open(dest); IChunkManager cm = world.GetChunkManager(); // Remove entities foreach (ChunkRef chunk in cm) { // Skip chunks that don't cover our selected area if (((chunk.X + 1) * chunk.Blocks.XDim < x1) || (chunk.X * chunk.Blocks.XDim >= x2) || ((chunk.Z + 1) * chunk.Blocks.ZDim < z1) || (chunk.Z * chunk.Blocks.ZDim >= z2)) { continue; } // Delete the specified entities chunk.Entities.RemoveAll(eid); cm.Save(); } }
//NbtWorld nbtWorld; public MCALoaderChunkGeneratorJob(bool useID, NbtWorld nbtWorld, string savePath, int x, int ySize, int z, List <Chunk> chunksFromYBottomToTop) : base(chunksFromYBottomToTop) { this.useID = useID; this.x = x; this.ySize = ySize; this.z = z; //this.nbtWorld = nbtWorld; if (cmPool == null) { cmPool = new Matryoshka.Utils.PerThreadPool <IChunkManager>(() => { //return NbtWorld.Open(savePath).GetChunkManager(); return(nbtWorld.GetChunkManager()); }); } this.isUnique = false; }
static void Main(string[] args) { if (args.Length != 4) { Console.WriteLine("Usage: GiveItem <world> <player> <item-id> <cnt>"); return; } string dest = args[0]; string player = args[1]; int itemid = Convert.ToInt32(args[2]); int count = Convert.ToInt32(args[3]); // Open the world and grab its player manager NbtWorld world = NbtWorld.Open(dest); IPlayerManager pm = world.GetPlayerManager(); // Check that the named player exists if (!pm.PlayerExists(player)) { Console.WriteLine("No such player {0}!", player); return; } // Get player (returned object is independent of the playermanager) Player p = pm.GetPlayer(player); // Find first slot to place item for (int i = 0; i < p.Items.Capacity; i++) { if (!p.Items.ItemExists(i)) { // Create the item and set its stack count Item item = new Item(itemid); item.Count = count; p.Items[i] = item; // Don't keep adding items break; } } // Save the player pm.SetPlayer(player, p); }
/// <summary> /// Creates a new <see cref="Map"/> object with copied data. /// </summary> /// <param name="p">A <see cref="Map"/> to copy data from.</param> protected Map(Map p) { _world = p._world; _id = p._id; _scale = p._scale; _dimension = p._dimension; _height = p._height; _width = p._width; _x = p._x; _z = p._z; _colors = new byte[_width * _height]; if (p._colors != null) { p._colors.CopyTo(_colors, 0); } }
private static void Main(string[] args) { if (args.Length < 2) { Console.WriteLine("Usage: BlockReplace <world> <blockids>"); return; } var sw = Stopwatch.StartNew(); var dest = args[0]; var blockIds = args.Skip(1).Select(arg => new BlockType(arg)).ToList(); new ChunkProcessor(NbtWorld.Open(dest), blockIds).Run(); Console.WriteLine("Elapsed time: {0}", sw.Elapsed); }
public ChunkProcessor(NbtWorld world, List <BlockType> blockArgs) { _world = world; _blockIds = new Dictionary <int, Dictionary <int, BlockType> >(); foreach (var blockArg in blockArgs) { if (_blockIds.ContainsKey(blockArg.Id)) { _blockIds[blockArg.Id][blockArg.Data] = blockArg; continue; } _blockIds[blockArg.Id] = new Dictionary <int, BlockType>(); _blockIds[blockArg.Id][blockArg.Data] = blockArg; } _blockArgs = blockArgs; }
public override void Run() { NbtWorld world = GetWorld(opt); IChunkManager cm = world.GetChunkManager(opt.OPT_DIM); FilteredChunkManager fcm = new FilteredChunkManager(cm, opt.GetChunkFilter()); int affectedChunks = 0; foreach (ChunkRef chunk in fcm) { if (opt.OPT_V) { Console.WriteLine("Processing chunk {0},{1}...", chunk.X, chunk.Z); } ApplyChunk(world, chunk); affectedChunks += fcm.Save() > 0 ? 1 : 0; } Console.WriteLine("Affected Chunks: " + affectedChunks); }
ReaderWriterObjectLock <IChunk> GetChunkLock(ChunkPositionDimension pos) { lock (_chunkAccessLock) { ReaderWriterObjectLock <IChunk> chunkLock; if (_chunkAccess.TryGetValue(pos, out chunkLock)) { return(chunkLock); } // create a new chunkLock if (NbtWorld == null) { return(_chunkAccess[pos] = new ReaderWriterObjectLock <IChunk>(null)); } var chunk = NbtWorld.GetChunkManager(pos.Dimension).GetChunk(pos.ChunkX, pos.ChunkZ); return(_chunkAccess[pos] = new ReaderWriterObjectLock <IChunk>(chunk)); } }
public NbtWorld GetWorld(TKOptions opt) { NbtWorld world = null; try { if (opt.OPT_ALPHA) { world = AlphaWorld.Open(opt.OPT_WORLD); } else { world = BetaWorld.Open(opt.OPT_WORLD); } } catch (Exception ex) { Console.WriteLine("Error: " + ex.Message); Environment.Exit(1); } return(world); }
public override void Run() { if (!Directory.Exists(opt.OPT_WORLD) && !File.Exists(opt.OPT_WORLD)) { Console.WriteLine("Error: Could not locate path: " + opt.OPT_WORLD); return; } NbtWorld world = null; IChunkManager cm = null; FilteredChunkManager fcm = null; try { world = NbtWorld.Open(opt.OPT_WORLD); cm = world.GetChunkManager(opt.OPT_DIM); fcm = new FilteredChunkManager(cm, opt.GetChunkFilter()); } catch (Exception e) { Console.WriteLine("Error: Failed to open world: " + opt.OPT_WORLD); Console.WriteLine("Exception: " + e.Message); Console.WriteLine(e.StackTrace); return; } int affectedChunks = 0; foreach (ChunkRef chunk in fcm) { if (opt.OPT_V) { Console.WriteLine("Processing chunk {0},{1}...", chunk.X, chunk.Z); } ApplyChunk(world, chunk); affectedChunks += fcm.Save() > 0 ? 1 : 0; } Console.WriteLine("Affected Chunks: " + affectedChunks); }
public static void SetBiomeData(string dest) { NbtWorld world = NbtWorld.Open(dest); IChunkManager cm = world.GetChunkManager(); foreach (ChunkRef chunk in cm) { AnvilChunk anvil_chunk = chunk.GetChunkRef() as AnvilChunk; TagNodeByteArray biomeNode = anvil_chunk.Tree.Root["Level"].ToTagCompound()["Biomes"].ToTagByteArray(); ZXByteArray biomeData = new ZXByteArray(16, 16, biomeNode.Data); for (int x = 0; x <= 15; x++) { for (int y = 0; y <= 15; y++) { biomeData[x, y] = biomes[chunk.X + "." + chunk.Z]; } } chunk.SetChunkRef(anvil_chunk); cm.Save(); } world.Save(); }
public void ApplyChunk(NbtWorld world, ChunkRef chunk) { if (opt.OPT_V) { Console.WriteLine("Generating {0} size {1} deposits of {2} between {3} and {4}", opt.OPT_ROUNDS, opt.OPT_SIZE, opt.OPT_ID, opt.OPT_MIN, opt.OPT_MAX); } IGenerator generator; if (opt.OPT_DATA == null) { generator = new NativeGenOre((int)opt.OPT_ID, (int)opt.OPT_SIZE); ((NativeGenOre)generator).MathFix = opt.OPT_MATHFIX; } else { generator = new NativeGenOre((int)opt.OPT_ID, (int)opt.OPT_DATA, (int)opt.OPT_SIZE); ((NativeGenOre)generator).MathFix = opt.OPT_MATHFIX; } IChunkManager cm = world.GetChunkManager(opt.OPT_DIM); IBlockManager bm = new GenOreBlockManager(cm, opt); for (int i = 0; i < opt.OPT_ROUNDS; i++) { if (opt.OPT_VV) { Console.WriteLine("Generating round {0}...", i); } int x = chunk.X * chunk.Blocks.XDim + rand.Next(chunk.Blocks.XDim); int y = (int)opt.OPT_MIN + rand.Next((int)opt.OPT_MAX - (int)opt.OPT_MIN); int z = chunk.Z * chunk.Blocks.ZDim + rand.Next(chunk.Blocks.ZDim); generator.Generate(bm, rand, x, y, z); } }