/// <summary>
/// Fills this chunk with blocks of the given id from the given yLow altitude up to the given yHigh altitude.
/// </summary>
/// <param name="blockId">The id of the blocks to fill the chunk with.</param>
/// <param name="yLow">The low y coordinate to start filling at.</param>
/// <param name="yHigh">The high y coordinate to stop filling at (yHigh is filled, as well).</param>
public void Fill(int blockId, int yLow, int yHigh)
{
AlphaBlockCollection blocks = Blocks;
if (yLow < 0)
{
throw new ArgumentOutOfRangeException(
"The given yLow value must be between 0 and " + blocks.YDim.ToString() + ". Given: " + yLow.ToString()
);
}
else if (yHigh < 0 || yHigh > blocks.YDim)
{
throw new ArgumentOutOfRangeException(
"The given yHigh value must be between 0 and " + blocks.YDim.ToString() + ". Given: " + yHigh.ToString()
);
}
else if (yLow > yHigh)
{
throw new ArgumentOutOfRangeException(
"The given yHigh value must be greater than or equal to the given yLow value. yLow = " + yLow.ToString() + ", yHigh = " + yHigh.ToString()
);
}
blocks.Fill(new BoundingBox(0, yLow, 0, blocks.XDim - 1, yHigh, blocks.ZDim - 1), blockId);
}
/// <summary>
/// Loads the Chunk from an NBT tree rooted at the given TagValue node.
/// </summary>
/// <param name="tree">Root node of an NBT tree.</param>
/// <returns>A reference to the current Chunk, or null if the tree is unparsable.</returns>
public Chunk LoadTree(TagNode tree)
{
TagNodeCompound ctree = tree as TagNodeCompound;
if (ctree == null)
{
return(null);
}
_tree = new NbtTree(ctree);
TagNodeCompound level = _tree.Root["Level"] as TagNodeCompound;
_blocks = new XZYByteArray(XDIM, YDIM, ZDIM, level["Blocks"] as TagNodeByteArray);
_data = new XZYNibbleArray(XDIM, YDIM, ZDIM, level["Data"] as TagNodeByteArray);
_blockLight = new XZYNibbleArray(XDIM, YDIM, ZDIM, level["BlockLight"] as TagNodeByteArray);
_skyLight = new XZYNibbleArray(XDIM, YDIM, ZDIM, level["SkyLight"] as TagNodeByteArray);
_heightMap = new ZXByteArray(XDIM, ZDIM, level["HeightMap"] as TagNodeByteArray);
_entities = level["Entities"] as TagNodeList;
_tileEntities = level["TileEntities"] as TagNodeList;
if (level.ContainsKey("TileTicks"))
{
_tileTicks = level["TileTicks"] as TagNodeList;
}
else
{
_tileTicks = new TagNodeList(TagType.TAG_COMPOUND);
}
// List-type patch up
if (_entities.Count == 0)
{
level["Entities"] = new TagNodeList(TagType.TAG_COMPOUND);
_entities = level["Entities"] as TagNodeList;
}
if (_tileEntities.Count == 0)
{
level["TileEntities"] = new TagNodeList(TagType.TAG_COMPOUND);
_tileEntities = level["TileEntities"] as TagNodeList;
}
if (_tileTicks.Count == 0)
{
level["TileTicks"] = new TagNodeList(TagType.TAG_COMPOUND);
_tileTicks = level["TileTicks"] as TagNodeList;
}
_cx = level["xPos"].ToTagInt();
_cz = level["zPos"].ToTagInt();
_blockManager = new AlphaBlockCollection(_blocks, _data, _blockLight, _skyLight, _heightMap, _tileEntities, _tileTicks);
_entityManager = new EntityCollection(_entities);
return(this);
}
/// <summary>
/// Crrates a new <see cref="AlphaBlock"/> from a given block in an existing <see cref="AlphaBlockCollection"/>.
/// </summary>
/// <param name="chunk">The block collection to reference.</param>
/// <param name="lx">The local X-coordinate of a block within the collection.</param>
/// <param name="ly">The local Y-coordinate of a block within the collection.</param>
/// <param name="lz">The local Z-coordinate of a block within the collection.</param>
public AlphaBlock(AlphaBlockCollection chunk, int lx, int ly, int lz)
{
_id = chunk.GetID(lx, ly, lz);
_data = chunk.GetData(lx, ly, lz);
TileEntity te = chunk.GetTileEntity(lx, ly, lz);
if (te != null)
{
_tileEntity = te.Copy();
}
}
/// <summary>
/// Gets an internal Chunk reference from cache or queries the container for it.
/// </summary>
/// <returns>The ChunkRef's underlying Chunk.</returns>
private Chunk GetChunk()
{
if (_chunk == null)
{
_chunk = _container.GetChunk(_cx, _cz);
if (_chunk != null)
{
_blocks = _chunk.Blocks;
_entities = _chunk.Entities;
// Set callback functions in the underlying block collection
_blocks.ResolveNeighbor += ResolveNeighborHandler;
_blocks.TranslateCoordinates += TranslateCoordinatesHandler;
}
}
return(_chunk);
}
private void BuildNBTTree()
{
int elements2 = XDIM * ZDIM;
int elements3 = elements2 * YDIM;
TagNodeByteArray blocks = new TagNodeByteArray(new byte[elements3]);
TagNodeByteArray data = new TagNodeByteArray(new byte[elements3 >> 1]);
TagNodeByteArray blocklight = new TagNodeByteArray(new byte[elements3 >> 1]);
TagNodeByteArray skylight = new TagNodeByteArray(new byte[elements3 >> 1]);
TagNodeByteArray heightMap = new TagNodeByteArray(new byte[elements2]);
_blocks = new XZYByteArray(XDIM, YDIM, ZDIM, blocks);
_data = new XZYNibbleArray(XDIM, YDIM, ZDIM, data);
_blockLight = new XZYNibbleArray(XDIM, YDIM, ZDIM, blocklight);
_skyLight = new XZYNibbleArray(XDIM, YDIM, ZDIM, skylight);
_heightMap = new ZXByteArray(XDIM, ZDIM, heightMap);
_entities = new TagNodeList(TagType.TAG_COMPOUND);
_tileEntities = new TagNodeList(TagType.TAG_COMPOUND);
_tileTicks = new TagNodeList(TagType.TAG_COMPOUND);
TagNodeCompound level = new TagNodeCompound();
level.Add("Blocks", blocks);
level.Add("Data", data);
level.Add("SkyLight", blocklight);
level.Add("BlockLight", skylight);
level.Add("HeightMap", heightMap);
level.Add("Entities", _entities);
level.Add("TileEntities", _tileEntities);
level.Add("TileTicks", _tileTicks);
level.Add("LastUpdate", new TagNodeLong(Timestamp()));
level.Add("xPos", new TagNodeInt(_cx));
level.Add("zPos", new TagNodeInt(_cz));
level.Add("TerrainPopulated", new TagNodeByte());
_tree = new NbtTree();
_tree.Root.Add("Level", level);
_blockManager = new AlphaBlockCollection(_blocks, _data, _blockLight, _skyLight, _heightMap, _tileEntities);
_entityManager = new EntityCollection(_entities);
}
/// <summary>
/// Gets an internal Chunk reference from cache or queries the container for it.
/// </summary>
/// <returns>The ChunkRef's underlying Chunk.</returns>
private IChunk GetChunk()
{
if (_chunk == null) {
_chunk = _container.GetChunk(_cx, _cz);
if (_chunk != null)
{
_blocks = _chunk.Blocks;
_biomes = _chunk.Biomes;
_entities = _chunk.Entities;
// Set callback functions in the underlying block collection
_blocks.ResolveNeighbor += ResolveNeighborHandler;
_blocks.TranslateCoordinates += TranslateCoordinatesHandler;
}
}
return _chunk;
}
public static void Generate(frmMace frmLogForm, string strUserCityName,
bool booIncludeFarms, bool booIncludeMoat, bool booIncludeWalls,
bool booIncludeDrawbridges, bool booIncludeGuardTowers, bool booIncludeBuildings,
bool booIncludePaths, bool booIncludeMineshaft, bool booIncludeItemsInChests,
bool booIncludeValuableBlocks, bool booIncludeGhostdancerSpawners,
string strCitySize, string strMoatType, string strCityEmblem,
string strOutsideLights, string strTowerAddition, string strWallMaterial,
string strCitySeed, string strWorldSeed, bool booExportSchematic)
{
#region seed the random number generators
int intCitySeed, intWorldSeed;
Random randSeeds = new Random();
if (strCitySeed.Length == 0)
{
intCitySeed = randSeeds.Next();
frmLogForm.UpdateLog("Random city seed: " + intCitySeed);
}
else
{
intCitySeed = JavaStringHashCode(strCitySeed);
frmLogForm.UpdateLog("Random city seed: " + strCitySeed);
}
if (strWorldSeed.Length == 0)
{
intWorldSeed = randSeeds.Next();
frmLogForm.UpdateLog("Random world seed: " + intWorldSeed);
}
else
{
intWorldSeed = JavaStringHashCode(strWorldSeed);
frmLogForm.UpdateLog("Random world seed: " + strWorldSeed);
}
RandomHelper.SetSeed(intCitySeed);
#endregion
#region create minecraft world directory from a random unused city name
string strFolder = String.Empty, strCityName = String.Empty;
strUserCityName = SafeFilename(strUserCityName);
if (strUserCityName.ToLower().Trim().Length == 0)
{
strUserCityName = "random";
}
if (strUserCityName.ToLower().Trim() != "random")
{
if (Directory.Exists(Utils.GetMinecraftSavesDirectory(strUserCityName)))
{
if (MessageBox.Show("A world called \"" + strUserCityName + "\" already exists. " +
"Would you like to use a random name instead?", "World already exists",
MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == DialogResult.Cancel)
{
frmLogForm.UpdateLog("Cancelled, because a world with this name already exists.");
return;
}
}
else
{
strCityName = strUserCityName;
strFolder = Utils.GetMinecraftSavesDirectory(strCityName);
}
}
if (strCityName.Length == 0)
{
string strStart, strEnd;
do
{
strStart = RandomHelper.RandomFileLine(Path.Combine("Resources", "CityAdj.txt"));
strEnd = RandomHelper.RandomFileLine(Path.Combine("Resources", "CityNoun.txt"));
strCityName = "City of " + strStart + strEnd;
strFolder = Utils.GetMinecraftSavesDirectory(strCityName);
} while (strStart.ToLower().Trim() == strEnd.ToLower().Trim() || Directory.Exists(strFolder) || (strStart + strEnd).Length > 14);
}
Directory.CreateDirectory(strFolder);
RandomHelper.SetSeed(intCitySeed);
#endregion
#region get handles to world, chunk manager and block manager
BetaWorld worldDest = BetaWorld.Create(@strFolder);
BetaChunkManager cmDest = worldDest.GetChunkManager();
BlockManager bmDest = worldDest.GetBlockManager();
bmDest.AutoLight = false;
#endregion
#region determine block sizes
// first we set the city size by chunks
int intCitySize = 12;
switch (strCitySize)
{
case "Random":
intCitySize = RandomHelper.Next(8, 16);
break;
case "Very small":
intCitySize = 2;
break;
case "Small":
intCitySize = 4;
break;
case "Medium":
intCitySize = 8;
break;
case "Large":
intCitySize = 16;
break;
case "Very large":
intCitySize = 32;
break;
default:
Debug.Fail("Invalid switch result");
break;
}
// then we multiply by 16, because that's the x and z of a chunk
intCitySize *= 16;
int intFarmLength = booIncludeFarms ? 32 : 8;
int intMapLength = intCitySize + (intFarmLength * 2);
#endregion
#region setup classes
BlockShapes.SetupClass(bmDest, intMapLength);
BlockHelper.SetupClass(bmDest, intMapLength);
if (!SourceWorld.SetupClass(worldDest, booIncludeItemsInChests, booIncludeGhostdancerSpawners))
{
return;
}
NoticeBoard.SetupClass(intCitySeed, intWorldSeed);
#endregion
#region determine random options
// ensure selected options take priority, but don't set things on fire
if (strTowerAddition == "Random")
{
strTowerAddition = RandomHelper.RandomString("Fire beacon", "Flag");
}
if (strWallMaterial.StartsWith("Wood"))
{
if (strMoatType == "Lava" || strMoatType == "Fire" || strMoatType == "Random")
{
strMoatType = RandomHelper.RandomString("Drop to Bedrock", "Cactus", "Water");
}
strOutsideLights = "Torches";
}
if (strWallMaterial == "Random")
{
if (strMoatType == "Lava" || strMoatType == "Fire" || strOutsideLights == "Fire")
{
strWallMaterial = RandomHelper.RandomString("Brick", "Cobblestone", "Sandstone", "Stone");
}
else
{
strWallMaterial = RandomHelper.RandomString("Brick", "Cobblestone", "Sandstone",
"Stone", "Wood Planks");
if (strWallMaterial.StartsWith("Wood"))
{
if (strMoatType == "Random")
{
strMoatType = RandomHelper.RandomString("Drop to Bedrock", "Cactus", "Water");
}
strOutsideLights = "Torches";
}
}
}
if (strOutsideLights == "Random")
{
strOutsideLights = RandomHelper.RandomString("Fire", "Torches");
}
if (strMoatType == "Random")
{
int intRand = RandomHelper.Next(100);
if (intRand >= 90)
{
strMoatType = "Drop to Bedrock";
}
else if (intRand >= 80)
{
strMoatType = "Cactus";
}
else if (intRand >= 50)
{
strMoatType = "Lava";
}
else if (intRand >= 40)
{
strMoatType = "Fire";
}
else
{
strMoatType = "Water";
}
}
int intWallMaterial = BlockType.STONE;
switch (strWallMaterial)
{
case "Brick":
intWallMaterial = BlockType.BRICK_BLOCK;
break;
case "Cobblestone":
intWallMaterial = BlockType.COBBLESTONE;
break;
case "Sandstone":
intWallMaterial = BlockType.SANDSTONE;
break;
case "Stone":
intWallMaterial = BlockType.STONE;
break;
case "Wood Planks":
intWallMaterial = BlockType.WOOD_PLANK;
break;
case "Wood Logs":
intWallMaterial = BlockType.WOOD;
break;
case "Bedrock":
intWallMaterial = BlockType.BEDROCK;
break;
case "Mossy Cobblestone":
intWallMaterial = BlockType.MOSS_STONE;
break;
case "Netherrack":
intWallMaterial = BlockType.NETHERRACK;
break;
case "Glass":
intWallMaterial = BlockType.GLASS;
break;
case "Ice":
intWallMaterial = BlockType.ICE;
break;
case "Snow":
intWallMaterial = BlockType.SNOW_BLOCK;
break;
case "Glowstone":
intWallMaterial = BlockType.GLOWSTONE_BLOCK;
break;
case "Dirt":
intWallMaterial = BlockType.DIRT;
break;
case "Obsidian":
intWallMaterial = BlockType.OBSIDIAN;
break;
case "Jack-o-Lantern":
intWallMaterial = BlockType.JACK_O_LANTERN;
break;
case "Soul sand":
intWallMaterial = BlockType.SOUL_SAND;
break;
case "Gold":
intWallMaterial = BlockType.GOLD_BLOCK;
break;
case "Diamond":
intWallMaterial = BlockType.DIAMOND_BLOCK;
break;
case "Stone brick - 1.8!":
intWallMaterial = BlockType.STONE_BRICK;
break;
default:
Debug.Fail("Invalid switch result");
break;
}
#endregion
#region make the city
frmLogForm.UpdateLog("Creating underground terrain");
Chunks.CreateInitialChunks(cmDest, intMapLength / 16, frmLogForm);
frmLogForm.UpdateProgress(25);
Buildings.structPoint spMineshaftEntrance = new Buildings.structPoint();
if (booIncludeWalls)
{
frmLogForm.UpdateLog("Creating city walls");
Walls.MakeWalls(worldDest, intFarmLength, intMapLength, strCityEmblem, strOutsideLights, intWallMaterial);
}
frmLogForm.UpdateProgress(34);
if (booIncludeBuildings || booIncludePaths)
{
frmLogForm.UpdateLog("Creating inner-city paths");
int[,] intArea = Paths.MakePaths(worldDest, bmDest, intFarmLength, intMapLength, strCitySize,
booIncludeMineshaft);
frmLogForm.UpdateProgress(36);
if (booIncludeBuildings)
{
frmLogForm.UpdateLog("Creating buildings");
spMineshaftEntrance = Buildings.MakeInsideCity(bmDest, worldDest, intArea, intFarmLength, intMapLength, booIncludePaths);
frmLogForm.UpdateProgress(45);
if (booIncludeMineshaft)
{
frmLogForm.UpdateLog("Creating mineshaft");
Mineshaft.MakeMineshaft(worldDest, bmDest, intFarmLength, intMapLength, spMineshaftEntrance);
}
}
}
frmLogForm.UpdateProgress(51);
if (booIncludeMoat)
{
frmLogForm.UpdateLog("Creating moat");
Moat.MakeMoat(intFarmLength, intMapLength, strMoatType, booIncludeGuardTowers);
}
frmLogForm.UpdateProgress(52);
if (booIncludeDrawbridges)
{
frmLogForm.UpdateLog("Creating drawbridges");
Drawbridge.MakeDrawbridges(bmDest, intFarmLength, intMapLength, booIncludeMoat,
booIncludeWalls, booIncludeItemsInChests, intWallMaterial, strMoatType, strCityName);
}
frmLogForm.UpdateProgress(53);
if (booIncludeGuardTowers)
{
frmLogForm.UpdateLog("Creating guard towers");
GuardTowers.MakeGuardTowers(bmDest, intFarmLength, intMapLength, booIncludeWalls,
strOutsideLights, strTowerAddition, booIncludeItemsInChests, intWallMaterial);
}
frmLogForm.UpdateProgress(54);
if (booIncludeFarms)
{
frmLogForm.UpdateLog("Creating farms");
Farms.MakeFarms(worldDest, bmDest, intFarmLength, intMapLength);
}
frmLogForm.UpdateProgress(58);
if (!booIncludeValuableBlocks)
{
cmDest.Save();
worldDest.Save();
Chunks.ReplaceValuableBlocks(worldDest, bmDest, intMapLength, intWallMaterial);
}
frmLogForm.UpdateProgress(60);
Chunks.PositionRails(worldDest, bmDest, intMapLength);
frmLogForm.UpdateProgress(62);
#endregion
#region world settings
// spawn looking at one of the city entrances
if (booIncludeFarms)
{
SpawnPoint spLevel = new SpawnPoint(7, 11, 13);
worldDest.Level.Spawn = spLevel;
worldDest.Level.Spawn = new SpawnPoint(intMapLength / 2, 64, intMapLength - (intFarmLength - 10));
}
else
{
worldDest.Level.Spawn = new SpawnPoint(intMapLength / 2, 64, intMapLength - (intFarmLength - 7));
}
// spawn in the middle of the city
//#if DEBUG
//worldDest.Level.Spawn = new SpawnPoint(intMapLength / 2, 64, intMapLength / 2);
//#endif
if (strWorldSeed.Length > 0)
{
worldDest.Level.RandomSeed = intWorldSeed;
}
#if RELEASE
worldDest.Level.Time = RandomHelper.Next(24000);
if (RandomHelper.NextDouble() < 0.15)
{
worldDest.Level.IsRaining = true;
// one-quarter to three-quarters of a day
worldDest.Level.RainTime = RandomHelper.Next(6000, 18000);
if (RandomHelper.NextDouble() < 0.25)
{
worldDest.Level.IsThundering = true;
worldDest.Level.ThunderTime = worldDest.Level.RainTime;
}
}
#endif
#endregion
#if DEBUG
MakeHelperChest(bmDest, worldDest.Level.Spawn.X + 2, worldDest.Level.Spawn.Y, worldDest.Level.Spawn.Z + 2);
#endif
frmLogForm.UpdateLog("Creating lighting data");
Chunks.ResetLighting(worldDest, cmDest, frmLogForm, (int)Math.Pow(intMapLength / 16, 2));
worldDest.Level.LevelName = strCityName;
worldDest.Save();
if (booExportSchematic)
{
frmLogForm.UpdateLog("Creating schematic");
AlphaBlockCollection abcExport = new AlphaBlockCollection(intMapLength, 128, intMapLength);
for (int x = 0; x < intMapLength; x++)
{
for (int z = 0; z < intMapLength; z++)
{
for (int y = 0; y < 128; y++)
{
abcExport.SetBlock(x, y, z, bmDest.GetBlock(x, y, z));
}
}
}
Schematic CitySchematic = new Schematic(intMapLength, 128, intMapLength);
CitySchematic.Blocks = abcExport;
CitySchematic.Export(Utils.GetMinecraftSavesDirectory(strCityName) + "\\" + strCityName + ".schematic");
}
frmLogForm.UpdateLog("\r\nCreated the " + strCityName + "!");
frmLogForm.UpdateLog("It'll be at the end of your MineCraft world list.");
}
private void BuildNBTTree()
{
int elements2 = XDIM * ZDIM;
_sections = new AnvilSection[16];
TagNodeList sections = new TagNodeList(TagType.TAG_COMPOUND);
for (int i = 0; i < _sections.Length; i++)
{
_sections[i] = new AnvilSection(i);
sections.Add(_sections[i].BuildTree());
}
FusedDataArray3[] blocksBA = new FusedDataArray3[_sections.Length];
YZXNibbleArray[] dataBA = new YZXNibbleArray[_sections.Length];
YZXNibbleArray[] skyLightBA = new YZXNibbleArray[_sections.Length];
YZXNibbleArray[] blockLightBA = new YZXNibbleArray[_sections.Length];
for (int i = 0; i < _sections.Length; i++)
{
blocksBA[i] = new FusedDataArray3(_sections[i].AddBlocks, _sections[i].Blocks);
dataBA[i] = _sections[i].Data;
skyLightBA[i] = _sections[i].SkyLight;
blockLightBA[i] = _sections[i].BlockLight;
}
_blocks = new CompositeDataArray3(blocksBA);
_data = new CompositeDataArray3(dataBA);
_skyLight = new CompositeDataArray3(skyLightBA);
_blockLight = new CompositeDataArray3(blockLightBA);
TagNodeIntArray heightMap = new TagNodeIntArray(new int[elements2]);
_heightMap = new ZXIntArray(XDIM, ZDIM, heightMap);
TagNodeByteArray biomes = new TagNodeByteArray(new byte[elements2]);
_biomes = new ZXByteArray(XDIM, ZDIM, biomes);
for (int x = 0; x < XDIM; x++)
{
for (int z = 0; z < ZDIM; z++)
{
_biomes[x, z] = BiomeType.Default;
}
}
_entities = new TagNodeList(TagType.TAG_COMPOUND);
_tileEntities = new TagNodeList(TagType.TAG_COMPOUND);
_tileTicks = new TagNodeList(TagType.TAG_COMPOUND);
TagNodeCompound level = new TagNodeCompound();
level.Add("Sections", sections);
level.Add("HeightMap", heightMap);
level.Add("Biomes", biomes);
level.Add("Entities", _entities);
level.Add("TileEntities", _tileEntities);
level.Add("TileTicks", _tileTicks);
level.Add("LastUpdate", new TagNodeLong(Timestamp()));
level.Add("xPos", new TagNodeInt(_cx));
level.Add("zPos", new TagNodeInt(_cz));
level.Add("TerrainPopulated", new TagNodeByte());
_tree = new NbtTree();
_tree.Root.Add("Level", level);
_blockManager = new AlphaBlockCollection(_blocks, _data, _blockLight, _skyLight, _heightMap, _tileEntities);
_entityManager = new EntityCollection(_entities);
}
public AnvilChunk LoadTree(TagNode tree)
{
TagNodeCompound ctree = tree as TagNodeCompound;
if (ctree == null)
{
return(null);
}
_tree = new NbtTree(ctree);
TagNodeCompound level = _tree.Root["Level"] as TagNodeCompound;
TagNodeList sections = level["Sections"] as TagNodeList;
foreach (TagNodeCompound section in sections)
{
AnvilSection anvilSection = new AnvilSection(section);
if (anvilSection.Y < 0 || anvilSection.Y >= _sections.Length)
{
continue;
}
_sections[anvilSection.Y] = anvilSection;
}
FusedDataArray3[] blocksBA = new FusedDataArray3[_sections.Length];
YZXNibbleArray[] dataBA = new YZXNibbleArray[_sections.Length];
YZXNibbleArray[] skyLightBA = new YZXNibbleArray[_sections.Length];
YZXNibbleArray[] blockLightBA = new YZXNibbleArray[_sections.Length];
for (int i = 0; i < _sections.Length; i++)
{
if (_sections[i] == null)
{
_sections[i] = new AnvilSection(i);
}
blocksBA[i] = new FusedDataArray3(_sections[i].AddBlocks, _sections[i].Blocks);
dataBA[i] = _sections[i].Data;
skyLightBA[i] = _sections[i].SkyLight;
blockLightBA[i] = _sections[i].BlockLight;
}
_blocks = new CompositeDataArray3(blocksBA);
_data = new CompositeDataArray3(dataBA);
_skyLight = new CompositeDataArray3(skyLightBA);
_blockLight = new CompositeDataArray3(blockLightBA);
_heightMap = new ZXIntArray(XDIM, ZDIM, level["HeightMap"] as TagNodeIntArray);
if (level.ContainsKey("Biomes"))
{
_biomes = new ZXByteArray(XDIM, ZDIM, level["Biomes"] as TagNodeByteArray);
}
else
{
level["Biomes"] = new TagNodeByteArray(new byte[256]);
_biomes = new ZXByteArray(XDIM, ZDIM, level["Biomes"] as TagNodeByteArray);
for (int x = 0; x < XDIM; x++)
{
for (int z = 0; z < ZDIM; z++)
{
_biomes[x, z] = BiomeType.Default;
}
}
}
_entities = level["Entities"] as TagNodeList;
_tileEntities = level["TileEntities"] as TagNodeList;
if (level.ContainsKey("TileTicks"))
{
_tileTicks = level["TileTicks"] as TagNodeList;
}
else
{
_tileTicks = new TagNodeList(TagType.TAG_COMPOUND);
}
// List-type patch up
if (_entities.Count == 0)
{
level["Entities"] = new TagNodeList(TagType.TAG_COMPOUND);
_entities = level["Entities"] as TagNodeList;
}
if (_tileEntities.Count == 0)
{
level["TileEntities"] = new TagNodeList(TagType.TAG_COMPOUND);
_tileEntities = level["TileEntities"] as TagNodeList;
}
if (_tileTicks.Count == 0)
{
level["TileTicks"] = new TagNodeList(TagType.TAG_COMPOUND);
_tileTicks = level["TileTicks"] as TagNodeList;
}
_cx = level["xPos"].ToTagInt();
_cz = level["zPos"].ToTagInt();
_blockManager = new AlphaBlockCollection(_blocks, _data, _blockLight, _skyLight, _heightMap, _tileEntities, _tileTicks);
_entityManager = new EntityCollection(_entities);
_biomeManager = new AnvilBiomeCollection(_biomes);
return(this);
}
internal AlphaBlockRef(AlphaBlockCollection collection, int index)
{
_collection = collection;
_index = index;
}
internal AlphaBlockRef(AlphaBlockCollection collection, int index)
{
_collection = collection;
_index = index;
}
public void save()
{
int maxX, maxY, maxZ;
maxX = maxY = maxZ = 0;
foreach (var block in blocks)
{
maxX = Math.Max(maxX, block.Key.x);
maxY = Math.Max(maxY, block.Key.y);
maxZ = Math.Max(maxZ, block.Key.z);
}
AlphaBlockCollection schematicBlocks = new AlphaBlockCollection(maxX + 1, maxY + 1, maxZ + 1);
EntityCollection schematicEntities = new EntityCollection(new TagNodeList(TagType.TAG_COMPOUND));
foreach (var block in blocks)
{
if (block.Key.x > maxX)
throw new IndexOutOfRangeException();
if (block.Key.y > maxY)
throw new IndexOutOfRangeException();
if (block.Key.z > maxZ)
throw new IndexOutOfRangeException();
if (block.Key.x < 0)
throw new IndexOutOfRangeException();
if (block.Key.y < 0)
throw new IndexOutOfRangeException();
if (block.Key.z < 0)
throw new IndexOutOfRangeException();
schematicBlocks.SetBlock(block.Key.x, block.Key.y, block.Key.z, block.Value);
}
Schematic schematic = new Schematic(schematicBlocks, schematicEntities);
schematic.Export(path);
}
