forked from mirrors/NBTExplorer
1015 lines
43 KiB
C#
1015 lines
43 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using Substrate.Core;
|
|
using Substrate.NBT;
|
|
|
|
namespace Substrate
|
|
{
|
|
/// <summary>
|
|
/// Functions for reading and modifying a bounded-size collection of Alpha-compatible block data.
|
|
/// </summary>
|
|
/// <remarks>An <see cref="AlphaBlockCollection"/> is a wrapper around existing pieces of data. Although it
|
|
/// holds references to data, it does not "own" the data in the same way that a <see cref="Chunk"/> does. An
|
|
/// <see cref="AlphaBlockCollection"/> simply overlays a higher-level interface on top of existing data.</remarks>
|
|
public class AlphaBlockCollection : IBoundedAlphaBlockCollection
|
|
{
|
|
private readonly int _xdim;
|
|
private readonly int _ydim;
|
|
private readonly int _zdim;
|
|
|
|
private XZYByteArray _blocks;
|
|
private XZYNibbleArray _data;
|
|
private XZYNibbleArray _blockLight;
|
|
private XZYNibbleArray _skyLight;
|
|
private ZXByteArray _heightMap;
|
|
|
|
private TagNodeList _tileEntities;
|
|
|
|
private BlockLight _lightManager;
|
|
private BlockFluid _fluidManager;
|
|
private BlockTileEntities _tileEntityManager;
|
|
|
|
private bool _dirty = false;
|
|
private bool _autoLight = true;
|
|
private bool _autoFluid = false;
|
|
|
|
public delegate AlphaBlockCollection NeighborLookupHandler (int relx, int rely, int relz);
|
|
|
|
public event NeighborLookupHandler ResolveNeighbor
|
|
{
|
|
add
|
|
{
|
|
_lightManager.ResolveNeighbor += delegate(int relx, int rely, int relz) {
|
|
return value(relx, rely, relz);
|
|
};
|
|
_fluidManager.ResolveNeighbor += delegate(int relx, int rely, int relz)
|
|
{
|
|
return value(relx, rely, relz);
|
|
};
|
|
}
|
|
|
|
remove
|
|
{
|
|
_lightManager = new BlockLight(this);
|
|
_fluidManager = new BlockFluid(this);
|
|
}
|
|
}
|
|
|
|
public event BlockCoordinateHandler TranslateCoordinates
|
|
{
|
|
add { _tileEntityManager.TranslateCoordinates += value; }
|
|
remove { _tileEntityManager.TranslateCoordinates -= value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets a value indicating whether changes to blocks will trigger automatic lighting updates.
|
|
/// </summary>
|
|
/// <remarks>Automatic updates to lighting may spill into neighboring <see cref="AlphaBlockCollection"/> objects, if they can
|
|
/// be resolved.</remarks>
|
|
public bool AutoLight
|
|
{
|
|
get { return _autoLight; }
|
|
set { _autoLight = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets a value indicating whether changes to blocks will trigger automatic fluid updates.
|
|
/// </summary>
|
|
/// <remarks>Automatic updates to fluid may cascade through neighboring <see cref="AlphaBlockCollection"/> objects and beyond,
|
|
/// if they can be resolved.</remarks>
|
|
public bool AutoFluid
|
|
{
|
|
get { return _autoFluid; }
|
|
set { _autoFluid = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets a value indicating whether this <see cref="AlphaBlockCollection"/> needs to be saved.
|
|
/// </summary>
|
|
/// <remarks>If this <see cref="AlphaBlockCollection"/> is backed by a reference conainer type, set this property to false
|
|
/// to prevent any modifications from being saved. The next update will set this property true again, however.</remarks>
|
|
public bool IsDirty
|
|
{
|
|
get { return _dirty; }
|
|
set { _dirty = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a new <see cref="AlphaBlockCollection"/> overlay on top of Alpha-specific units of data.
|
|
/// </summary>
|
|
/// <param name="blocks">An array of Block IDs.</param>
|
|
/// <param name="data">An array of data nibbles.</param>
|
|
/// <param name="blockLight">An array of block light nibbles.</param>
|
|
/// <param name="skyLight">An array of sky light nibbles.</param>
|
|
/// <param name="heightMap">An array of height map values.</param>
|
|
/// <param name="tileEntities">A list of tile entities corresponding to blocks in this collection.</param>
|
|
public AlphaBlockCollection (
|
|
XZYByteArray blocks,
|
|
XZYNibbleArray data,
|
|
XZYNibbleArray blockLight,
|
|
XZYNibbleArray skyLight,
|
|
ZXByteArray heightMap,
|
|
TagNodeList tileEntities)
|
|
{
|
|
_blocks = blocks;
|
|
_data = data;
|
|
_blockLight = blockLight;
|
|
_skyLight = skyLight;
|
|
_heightMap = heightMap;
|
|
_tileEntities = tileEntities;
|
|
|
|
_xdim = _blocks.XDim;
|
|
_ydim = _blocks.YDim;
|
|
_zdim = _blocks.ZDim;
|
|
|
|
_lightManager = new BlockLight(this);
|
|
_fluidManager = new BlockFluid(this);
|
|
_tileEntityManager = new BlockTileEntities(_blocks, _tileEntities);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a new <see cref="AlphaBlock"/> object from local coordinates relative to this collection.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of block.</param>
|
|
/// <param name="y">Local Y-coordinate of block.</param>
|
|
/// <param name="z">Local Z-coordiante of block.</param>
|
|
/// <returns>A new <see cref="AlphaBlock"/> object representing context-independent data of a single block.</returns>
|
|
/// <remarks>Context-independent data excludes data such as lighting. <see cref="AlphaBlock"/> object actually contain a copy
|
|
/// of the data they represent, so changes to the <see cref="AlphaBlock"/> will not affect this container, and vice-versa.</remarks>
|
|
public AlphaBlock GetBlock (int x, int y, int z)
|
|
{
|
|
return new AlphaBlock(this, x, y, z);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a new <see cref="AlphaBlockRef"/> object from local coordaintes relative to this collection.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of block.</param>
|
|
/// <param name="y">Local Y-coordinate of block.</param>
|
|
/// <param name="z">Local Z-coordinate of block.</param>
|
|
/// <returns>A new <see cref="AlphaBlockRef"/> object representing context-dependent data of a single block.</returns>
|
|
/// <remarks>Context-depdendent data includes all data associated with this block. Since a <see cref="AlphaBlockRef"/> represents
|
|
/// a view of a block within this container, any updates to data in the container will be reflected in the <see cref="AlphaBlockRef"/>,
|
|
/// and vice-versa for updates to the <see cref="AlphaBlockRef"/>.</remarks>
|
|
public AlphaBlockRef GetBlockRef (int x, int y, int z)
|
|
{
|
|
return new AlphaBlockRef(this, _blocks.GetIndex(x, y, z));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates a block in this collection with values from a <see cref="AlphaBlock"/> object.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a block.</param>
|
|
/// <param name="y">Local Y-coordinate of a block.</param>
|
|
/// <param name="z">Local Z-coordinate of a block.</param>
|
|
/// <param name="block">A <see cref="AlphaBlock"/> object to copy block data from.</param>
|
|
public void SetBlock (int x, int y, int z, AlphaBlock block)
|
|
{
|
|
SetID(x, y, z, block.ID);
|
|
SetData(x, y, z, block.Data);
|
|
|
|
SetTileEntity(x, y, z, block.GetTileEntity().Copy());
|
|
}
|
|
|
|
#region IBlockCollection Members
|
|
|
|
/// <summary>
|
|
/// Gets the length of this collection's X-dimension.
|
|
/// </summary>
|
|
public int XDim
|
|
{
|
|
get { return _xdim; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the length of this collection's Y-dimension.
|
|
/// </summary>
|
|
public int YDim
|
|
{
|
|
get { return _ydim; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the length of this collection's Z-dimension.
|
|
/// </summary>
|
|
public int ZDim
|
|
{
|
|
get { return _zdim; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns an object compatible with the <see cref="IBlock"/> interface from local coordinates relative to this collection.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a block.</param>
|
|
/// <param name="y">Local Y-coordinate of a block.</param>
|
|
/// <param name="z">Local Z-coordinate of a block.</param>
|
|
/// <returns>An <see cref="IBlock"/>-compatible object.</returns>
|
|
/// <seealso cref="AlphaBlock"/>
|
|
IBlock IBlockCollection.GetBlock (int x, int y, int z)
|
|
{
|
|
return GetBlock(x, y, z);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a reference object compatible with the <see cref="IBlock"/> interface from local coordinates relative to this collection.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a block.</param>
|
|
/// <param name="y">Local Y-coordinate of a block.</param>
|
|
/// <param name="z">Local Z-coordinate of a block.</param>
|
|
/// <returns>An <see cref="IBlock"/>-compatible reference object.</returns>
|
|
/// <seealso cref="AlphaBlockRef"/>
|
|
IBlock IBlockCollection.GetBlockRef (int x, int y, int z)
|
|
{
|
|
return GetBlockRef(x, y, z);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates a block in this collection with values from an <see cref="IBlock"/> object.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a block.</param>
|
|
/// <param name="y">Local Y-coordinate of a block.</param>
|
|
/// <param name="z">Local Z-coordinate of a block.</param>
|
|
/// <param name="block">An <see cref="IBlock"/> object to copy block data from.</param>
|
|
public void SetBlock (int x, int y, int z, IBlock block)
|
|
{
|
|
SetID(x, y, z, block.ID);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets information on the type of a block at the given local coordinates.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a block.</param>
|
|
/// <param name="y">Local Y-coordinate of a block.</param>
|
|
/// <param name="z">Local Z-coordinate of a block.</param>
|
|
/// <returns>A <see cref="BlockInfo"/> object containing information of a block's type.</returns>
|
|
public BlockInfo GetInfo (int x, int y, int z)
|
|
{
|
|
return BlockInfo.BlockTable[_blocks[x, y, z]];
|
|
}
|
|
|
|
internal BlockInfo GetInfo (int index)
|
|
{
|
|
return BlockInfo.BlockTable[_blocks[index]];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the ID (type) of a block at the given local coordinates.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a block.</param>
|
|
/// <param name="y">Local Y-coordinate of a block.</param>
|
|
/// <param name="z">Local Z-coordinate of a block.</param>
|
|
/// <returns>The ID (type) of the specified block.</returns>
|
|
public int GetID (int x, int y, int z)
|
|
{
|
|
return _blocks[x, y, z];
|
|
}
|
|
|
|
internal int GetID (int index)
|
|
{
|
|
return _blocks[index];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the ID (type) of a block at the given local coordinates, maintaining consistency of data.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a block.</param>
|
|
/// <param name="y">Local Y-coordinate of a block.</param>
|
|
/// <param name="z">Local Z-coordinate of a block.</param>
|
|
/// <param name="id">The new ID of the block.</param>
|
|
/// <remarks>Depending on the options set for this <see cref="AlphaBlockCollection"/>, this method can be very
|
|
/// heavy-handed in the amount of work it does to maintain consistency of tile entities, lighting, fluid, etc.
|
|
/// for the affected block and possibly many other indirectly-affected blocks in the collection or neighboring
|
|
/// collections. If many SetID calls are expected to be made, some of this auto-reconciliation behavior should
|
|
/// be disabled, and the data should be rebuilt at the <see cref="AlphaBlockCollection"/>-level at the end.</remarks>
|
|
public void SetID (int x, int y, int z, int id)
|
|
{
|
|
int oldid = _blocks[x, y, z];
|
|
if (oldid == id) {
|
|
return;
|
|
}
|
|
|
|
// Update value
|
|
|
|
_blocks[x, y, z] = (byte)id;
|
|
|
|
// Update tile entities
|
|
|
|
BlockInfo info1 = BlockInfo.BlockTable[oldid];
|
|
BlockInfo info2 = BlockInfo.BlockTable[id];
|
|
|
|
BlockInfoEx einfo1 = info1 as BlockInfoEx;
|
|
BlockInfoEx einfo2 = info2 as BlockInfoEx;
|
|
|
|
if (einfo1 != einfo2) {
|
|
if (einfo1 != null) {
|
|
ClearTileEntity(x, y, z);
|
|
}
|
|
|
|
if (einfo2 != null) {
|
|
CreateTileEntity(x, y, z);
|
|
}
|
|
}
|
|
|
|
// Light consistency
|
|
|
|
if (_autoLight) {
|
|
if (info1.ObscuresLight != info2.ObscuresLight) {
|
|
_lightManager.UpdateHeightMap(x, y, z);
|
|
}
|
|
|
|
if (info1.Luminance != info2.Luminance || info1.Opacity != info2.Opacity || info1.TransmitsLight != info2.TransmitsLight) {
|
|
UpdateBlockLight(x, y, z);
|
|
}
|
|
|
|
if (info1.Opacity != info2.Opacity || info1.TransmitsLight != info2.TransmitsLight) {
|
|
UpdateSkyLight(x, y, z);
|
|
}
|
|
}
|
|
|
|
// Fluid consistency
|
|
|
|
if (_autoFluid) {
|
|
if (info1.State == BlockState.FLUID || info2.State == BlockState.FLUID) {
|
|
UpdateFluid(x, y, z);
|
|
}
|
|
}
|
|
|
|
_dirty = true;
|
|
}
|
|
|
|
internal void SetID (int index, int id)
|
|
{
|
|
int x, y, z;
|
|
_blocks.GetMultiIndex(index, out x, out y, out z);
|
|
|
|
SetID(x, y, z, id);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a count of all blocks in this <see cref="AlphaBlockCollection"/> with the given ID (type).
|
|
/// </summary>
|
|
/// <param name="id">The ID of blocks to count.</param>
|
|
/// <returns>A count of all matching blocks.</returns>
|
|
public int CountByID (int id)
|
|
{
|
|
int c = 0;
|
|
for (int i = 0; i < _blocks.Length; i++) {
|
|
if (_blocks[i] == id) {
|
|
c++;
|
|
}
|
|
}
|
|
|
|
return c;
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
#region IDataBlockContainer Members
|
|
|
|
/// <summary>
|
|
/// Returns an object compatible with the <see cref="IDataBlock"/> interface from local coordinates relative to this collection.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a block.</param>
|
|
/// <param name="y">Local Y-coordinate of a block.</param>
|
|
/// <param name="z">Local Z-coordinate of a block.</param>
|
|
/// <returns>An <see cref="IDataBlock"/>-compatible object.</returns>
|
|
/// <seealso cref="AlphaBlock"/>
|
|
IDataBlock IDataBlockCollection.GetBlock (int x, int y, int z)
|
|
{
|
|
return GetBlock(x, y, z);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a reference object compatible with the <see cref="IDataBlock"/> interface from local coordinates relative to this collection.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a block.</param>
|
|
/// <param name="y">Local Y-coordinate of a block.</param>
|
|
/// <param name="z">Local Z-coordinate of a block.</param>
|
|
/// <returns>An <see cref="IDataBlock"/>-compatible reference object.</returns>
|
|
/// <seealso cref="AlphaBlockRef"/>
|
|
IDataBlock IDataBlockCollection.GetBlockRef (int x, int y, int z)
|
|
{
|
|
return GetBlockRef(x, y, z);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates a block in this collection with values from an <see cref="IDataBlock"/> object.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a block.</param>
|
|
/// <param name="y">Local Y-coordinate of a block.</param>
|
|
/// <param name="z">Local Z-coordinate of a block.</param>
|
|
/// <param name="block">An <see cref="IDataBlock"/> object to copy block data from.</param>
|
|
public void SetBlock (int x, int y, int z, IDataBlock block)
|
|
{
|
|
SetID(x, y, z, block.ID);
|
|
SetData(x, y, z, block.Data);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the data value of a block at the given local coordinates.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a block.</param>
|
|
/// <param name="y">Local Y-coordinate of a block.</param>
|
|
/// <param name="z">Local Z-coordinate of a block.</param>
|
|
/// <returns>The data value of the specified block.</returns>
|
|
public int GetData (int x, int y, int z)
|
|
{
|
|
return _data[x, y, z];
|
|
}
|
|
|
|
internal int GetData (int index)
|
|
{
|
|
return _data[index];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the data value of a block at the given local coordinates.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a block.</param>
|
|
/// <param name="y">Local Y-coordinate of a block.</param>
|
|
/// <param name="z">Local Z-coordinate of a block.</param>
|
|
/// <param name="data">The new data value of the block.</param>
|
|
public void SetData (int x, int y, int z, int data)
|
|
{
|
|
if (_data[x, y, z] != data) {
|
|
_data[x, y, z] = (byte)data;
|
|
_dirty = true;
|
|
}
|
|
|
|
/*if (BlockManager.EnforceDataLimits && BlockInfo.BlockTable[_blocks[index]] != null) {
|
|
if (!BlockInfo.BlockTable[_blocks[index]].TestData(data)) {
|
|
return false;
|
|
}
|
|
}*/
|
|
}
|
|
|
|
internal void SetData (int index, int data)
|
|
{
|
|
if (_data[index] != data) {
|
|
_data[index] = (byte)data;
|
|
_dirty = true;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a count of all blocks in this <see cref="AlphaBlockCollection"/> matching the given ID (type) and data value.
|
|
/// </summary>
|
|
/// <param name="id">The ID of blocks to count.</param>
|
|
/// <param name="data">The data value of blocks to count.</param>
|
|
/// <returns>A count of all matching blocks.</returns>
|
|
public int CountByData (int id, int data)
|
|
{
|
|
int c = 0;
|
|
for (int i = 0; i < _blocks.Length; i++) {
|
|
if (_blocks[i] == id && _data[i] == data) {
|
|
c++;
|
|
}
|
|
}
|
|
|
|
return c;
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
#region ILitBlockCollection Members
|
|
|
|
/// <summary>
|
|
/// Not Implemented.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a block.</param>
|
|
/// <param name="y">Local Y-coordinate of a block.</param>
|
|
/// <param name="z">Local Z-coordinate of a block.</param>
|
|
/// <returns>An <see cref="ILitBlock"/>-compatible object.</returns>
|
|
/// <seealso cref="AlphaBlock"/>
|
|
ILitBlock ILitBlockCollection.GetBlock (int x, int y, int z)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a reference object compatible with the <see cref="ILitBlock"/> interface from local coordinates relative to this collection.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a block.</param>
|
|
/// <param name="y">Local Y-coordinate of a block.</param>
|
|
/// <param name="z">Local Z-coordinate of a block.</param>
|
|
/// <returns>An <see cref="ILitBlock"/>-compatible reference object.</returns>
|
|
/// <seealso cref="AlphaBlockRef"/>
|
|
ILitBlock ILitBlockCollection.GetBlockRef (int x, int y, int z)
|
|
{
|
|
return GetBlockRef(x, y, z);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates a block in this collection with values from an <see cref="ILitBlock"/> object.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a block.</param>
|
|
/// <param name="y">Local Y-coordinate of a block.</param>
|
|
/// <param name="z">Local Z-coordinate of a block.</param>
|
|
/// <param name="block">An <see cref="ILitBlock"/> object to copy block data from.</param>
|
|
public void SetBlock (int x, int y, int z, ILitBlock block)
|
|
{
|
|
SetID(x, y, z, block.ID);
|
|
SetBlockLight(x, y, z, block.BlockLight);
|
|
SetSkyLight(x, y, z, block.SkyLight);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the block-source light value of a block at the given local coordinates.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a block.</param>
|
|
/// <param name="y">Local Y-coordinate of a block.</param>
|
|
/// <param name="z">Local Z-coordinate of a block.</param>
|
|
/// <returns>The block-source light value of the specified block.</returns>
|
|
public int GetBlockLight (int x, int y, int z)
|
|
{
|
|
return _blockLight[x, y, z];
|
|
}
|
|
|
|
internal int GetBlockLight (int index)
|
|
{
|
|
return _blockLight[index];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the sky-source light value of a block at the given local coordinates.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a block.</param>
|
|
/// <param name="y">Local Y-coordinate of a block.</param>
|
|
/// <param name="z">Local Z-coordinate of a block.</param>
|
|
/// <returns>The sky-source light value of the specified block.</returns>
|
|
public int GetSkyLight (int x, int y, int z)
|
|
{
|
|
return _skyLight[x, y, z];
|
|
}
|
|
|
|
internal int GetSkyLight (int index)
|
|
{
|
|
return _skyLight[index];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the blocks-source light value of a block at the given local coordinates.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a block.</param>
|
|
/// <param name="y">Local Y-coordinate of a block.</param>
|
|
/// <param name="z">Local Z-coordinate of a block.</param>
|
|
/// <param name="light">The new block-source light value of the block.</param>
|
|
public void SetBlockLight (int x, int y, int z, int light)
|
|
{
|
|
if (_blockLight[x, y, z] != light) {
|
|
_blockLight[x, y, z] = (byte)light;
|
|
_dirty = true;
|
|
}
|
|
}
|
|
|
|
internal void SetBlockLight (int index, int light)
|
|
{
|
|
if (_blockLight[index] != light) {
|
|
_blockLight[index] = (byte)light;
|
|
_dirty = true;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the sky-source light value of a block at the given local coordinates.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a block.</param>
|
|
/// <param name="y">Local Y-coordinate of a block.</param>
|
|
/// <param name="z">Local Z-coordinate of a block.</param>
|
|
/// <param name="light">The new sky-source light value of the block.</param>
|
|
public void SetSkyLight (int x, int y, int z, int light)
|
|
{
|
|
if (_skyLight[x, y, z] != light) {
|
|
_skyLight[x, y, z] = (byte)light;
|
|
_dirty = true;
|
|
}
|
|
}
|
|
|
|
internal void SetSkyLight (int index, int light)
|
|
{
|
|
if (_skyLight[index] != light) {
|
|
_skyLight[index] = (byte)light;
|
|
_dirty = true;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the lowest Y-coordinate of a block at which sky-source light remains unfiltered.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a map location.</param>
|
|
/// <param name="z">Local Z-coordinate of a map location.</param>
|
|
/// <returns>The height-map value of a map location for calculating sky-source lighting.</returns>
|
|
public int GetHeight (int x, int z)
|
|
{
|
|
return _heightMap[x, z];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the lowest Y-coordinate of a block at which sky-source light remains unfiltered.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a map location.</param>
|
|
/// <param name="z">Local Z-coordinate of a map location.</param>
|
|
/// <param name="height">The new height-map value of the given map location.</param>
|
|
public void SetHeight (int x, int z, int height)
|
|
{
|
|
_heightMap[x, z] = (byte)height;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates the block-source lighting of a block at the given local coordinates to maintain light consistency.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a block.</param>
|
|
/// <param name="y">Local Y-coordinate of a block.</param>
|
|
/// <param name="z">Local Z-coordinate of a block.</param>
|
|
/// <remarks><para>The lighting of the block will be updated to be consistent with the lighting in neighboring blocks.
|
|
/// If the block is itself a light source, many nearby blocks may be updated to maintain consistent lighting. These
|
|
/// updates may also touch neighboring <see cref="AlphaBlockCollection"/> objects, if they can be resolved.</para>
|
|
/// <para>This function assumes that the entire <see cref="AlphaBlockCollection"/> and neighboring <see cref="AlphaBlockCollection"/>s
|
|
/// already have consistent lighting, with the exception of the block being updated. If this assumption is violated,
|
|
/// lighting may fail to converge correctly.</para></remarks>
|
|
public void UpdateBlockLight (int x, int y, int z)
|
|
{
|
|
_lightManager.UpdateBlockLight(x, y, z);
|
|
_dirty = true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates the sky-source lighting of a block at the given local coordinates to maintain light consistency.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a block.</param>
|
|
/// <param name="y">Local Y-coordinate of a block.</param>
|
|
/// <param name="z">Local Z-coordinate of a block.</param>
|
|
/// <remarks><para>The lighting of the block will be updated to be consistent with the lighting in neighboring blocks.
|
|
/// If the block is itself a light source, many nearby blocks may be updated to maintain consistent lighting. These
|
|
/// updates may also touch neighboring <see cref="AlphaBlockCollection"/> objects, if they can be resolved.</para>
|
|
/// <para>This function assumes that the entire <see cref="AlphaBlockCollection"/> and neighboring <see cref="AlphaBlockCollection"/>s
|
|
/// already have consistent lighting, with the exception of the block being updated. If this assumption is violated,
|
|
/// lighting may fail to converge correctly.</para></remarks>
|
|
public void UpdateSkyLight (int x, int y, int z)
|
|
{
|
|
_lightManager.UpdateBlockSkyLight(x, y, z);
|
|
_dirty = true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resets the block-source light value to 0 for all blocks in this <see cref="AlphaBlockCollection"/>.
|
|
/// </summary>
|
|
public void ResetBlockLight ()
|
|
{
|
|
_blockLight.Clear();
|
|
_dirty = true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resets the sky-source light value to 0 for all blocks in this <see cref="AlphaBlockCollection"/>.
|
|
/// </summary>
|
|
public void ResetSkyLight ()
|
|
{
|
|
_skyLight.Clear();
|
|
_dirty = true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reconstructs the block-source lighting for all blocks in this <see cref="AlphaBlockCollection"/>.
|
|
/// </summary>
|
|
/// <remarks><para>This function should only be called after the lighting has been reset in this <see cref="AlphaBlockCollection"/>
|
|
/// and all neighboring <see cref="AlphaBlockCollection"/>s, or lighting may fail to converge correctly.
|
|
/// This function cannot reset the lighting on its own, due to interactions between <see cref="AlphaBlockCollection"/>s.</para>
|
|
/// <para>If many light source or block opacity values will be modified in this <see cref="AlphaBlockCollection"/>, it may
|
|
/// be preferable to avoid explicit or implicit calls to <see cref="UpdateBlockLight"/> and call this function once when
|
|
/// modifications are complete.</para></remarks>
|
|
/// /<seealso cref="ResetBlockLight"/>
|
|
public void RebuildBlockLight ()
|
|
{
|
|
_lightManager.RebuildBlockLight();
|
|
_dirty = true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reconstructs the sky-source lighting for all blocks in this <see cref="AlphaBlockCollection"/>.
|
|
/// </summary>
|
|
/// <remarks><para>This function should only be called after the lighting has been reset in this <see cref="AlphaBlockCollection"/>
|
|
/// and all neighboring <see cref="AlphaBlockCollection"/>s, or lighting may fail to converge correctly.
|
|
/// This function cannot reset the lighting on its own, due to interactions between <see cref="AlphaBlockCollection"/>s.</para>
|
|
/// <para>If many light source or block opacity values will be modified in this <see cref="AlphaBlockCollection"/>, it may
|
|
/// be preferable to avoid explicit or implicit calls to <see cref="UpdateSkyLight"/> and call this function once when
|
|
/// modifications are complete.</para></remarks>
|
|
/// <seealso cref="ResetSkyLight"/>
|
|
public void RebuildSkyLight ()
|
|
{
|
|
_lightManager.RebuildBlockSkyLight();
|
|
_dirty = true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reconstructs the height-map for this <see cref="AlphaBlockCollection"/>.
|
|
/// </summary>
|
|
public void RebuildHeightMap ()
|
|
{
|
|
_lightManager.RebuildHeightMap();
|
|
_dirty = true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reconciles any block-source lighting inconsistencies between this <see cref="AlphaBlockCollection"/> and any of its neighbors.
|
|
/// </summary>
|
|
/// <remarks>It will be necessary to call this function if an <see cref="AlphaBlockCollection"/> is reset and rebuilt, but
|
|
/// some of its neighbors are not. A rebuilt <see cref="AlphaBlockCollection"/> will spill lighting updates into its neighbors,
|
|
/// but will not see lighting that should be propagated back from its neighbors.</remarks>
|
|
/// <seealso cref="RebuildBlockLight"/>
|
|
public void StitchBlockLight ()
|
|
{
|
|
_lightManager.StitchBlockLight();
|
|
_dirty = true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reconciles any sky-source lighting inconsistencies between this <see cref="AlphaBlockCollection"/> and any of its neighbors.
|
|
/// </summary>
|
|
/// <remarks>It will be necessary to call this function if an <see cref="AlphaBlockCollection"/> is reset and rebuilt, but
|
|
/// some of its neighbors are not. A rebuilt <see cref="AlphaBlockCollection"/> will spill lighting updates into its neighbors,
|
|
/// but will not see lighting that should be propagated back from its neighbors.</remarks>
|
|
/// <seealso cref="RebuildSkyLight"/>
|
|
public void StitchSkyLight ()
|
|
{
|
|
_lightManager.StitchBlockSkyLight();
|
|
_dirty = true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reconciles any block-source lighting inconsistencies between this <see cref="AlphaBlockCollection"/> and another <see cref="IBoundedLitBlockCollection"/> on a given edge.
|
|
/// </summary>
|
|
/// <param name="blockset">An <see cref="IBoundedLitBlockCollection"/>-compatible object with the same dimensions as this <see cref="AlphaBlockCollection"/>.</param>
|
|
/// <param name="edge">The edge that <paramref name="blockset"/> is a neighbor on.</param>
|
|
/// <remarks>It will be necessary to call this function if an <see cref="AlphaBlockCollection"/> is reset and rebuilt, but
|
|
/// some of its neighbors are not. A rebuilt <see cref="AlphaBlockCollection"/> will spill lighting updates into its neighbors,
|
|
/// but will not see lighting that should be propagated back from its neighbors.</remarks>
|
|
/// <seealso cref="RebuildBlockLight"/>
|
|
public void StitchBlockLight (IBoundedLitBlockCollection blockset, BlockCollectionEdge edge)
|
|
{
|
|
_lightManager.StitchBlockLight(blockset, edge);
|
|
_dirty = true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reconciles any sky-source lighting inconsistencies between this <see cref="AlphaBlockCollection"/> and another <see cref="IBoundedLitBlockCollection"/> on a given edge.
|
|
/// </summary>
|
|
/// <param name="blockset">An <see cref="IBoundedLitBlockCollection"/>-compatible object with the same dimensions as this <see cref="AlphaBlockCollection"/>.</param>
|
|
/// <param name="edge">The edge that <paramref name="blockset"/> is a neighbor on.</param>
|
|
/// <remarks>It will be necessary to call this function if an <see cref="AlphaBlockCollection"/> is reset and rebuilt, but
|
|
/// some of its neighbors are not. A rebuilt <see cref="AlphaBlockCollection"/> will spill lighting updates into its neighbors,
|
|
/// but will not see lighting that should be propagated back from its neighbors.</remarks>
|
|
/// <seealso cref="RebuildSkyLight"/>
|
|
public void StitchSkyLight (IBoundedLitBlockCollection blockset, BlockCollectionEdge edge)
|
|
{
|
|
_lightManager.StitchBlockSkyLight(blockset, edge);
|
|
_dirty = true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
#region IPropertyBlockCollection Members
|
|
|
|
/// <summary>
|
|
/// Returns an object compatible with the <see cref="IPropertyBlock"/> interface from local coordinates relative to this collection.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a block.</param>
|
|
/// <param name="y">Local Y-coordinate of a block.</param>
|
|
/// <param name="z">Local Z-coordinate of a block.</param>
|
|
/// <returns>An <see cref="IPropertyBlock"/>-compatible object.</returns>
|
|
/// <seealso cref="AlphaBlock"/>
|
|
IPropertyBlock IPropertyBlockCollection.GetBlock (int x, int y, int z)
|
|
{
|
|
return GetBlock(x, y, z);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a reference object compatible with the <see cref="IPropertyBlock"/> interface from local coordinates relative to this collection.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a block.</param>
|
|
/// <param name="y">Local Y-coordinate of a block.</param>
|
|
/// <param name="z">Local Z-coordinate of a block.</param>
|
|
/// <returns>An <see cref="IPropertyBlock"/>-compatible reference object.</returns>
|
|
/// <seealso cref="AlphaBlockRef"/>
|
|
IPropertyBlock IPropertyBlockCollection.GetBlockRef (int x, int y, int z)
|
|
{
|
|
return GetBlockRef(x, y, z);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates a block in this collection with values from an <see cref="IPropertyBlock"/> object.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a block.</param>
|
|
/// <param name="y">Local Y-coordinate of a block.</param>
|
|
/// <param name="z">Local Z-coordinate of a block.</param>
|
|
/// <param name="block">An <see cref="IPropertyBlock"/> object to copy block data from.</param>
|
|
public void SetBlock (int x, int y, int z, IPropertyBlock block)
|
|
{
|
|
SetID(x, y, z, block.ID);
|
|
SetTileEntity(x, y, z, block.GetTileEntity().Copy());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a <see cref="TileEntity"/> record for a block at the given local coordinates, if one exists.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a block.</param>
|
|
/// <param name="y">Local Y-coordinate of a block.</param>
|
|
/// <param name="z">Local Z-coordinate of a block.</param>
|
|
/// <returns>A <see cref="TileEntity"/> for the given block, or null if the <see cref="TileEntity"/> is missing or the block type does not use a <see cref="TileEntity"/>.</returns>
|
|
public TileEntity GetTileEntity (int x, int y, int z)
|
|
{
|
|
return _tileEntityManager.GetTileEntity(x, y, z);
|
|
}
|
|
|
|
internal TileEntity GetTileEntity (int index)
|
|
{
|
|
int x, y, z;
|
|
_blocks.GetMultiIndex(index, out x, out y, out z);
|
|
|
|
return _tileEntityManager.GetTileEntity(x, y, z);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets a <see cref="TileEntity"/> record for a block at the given local coordinates.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a block.</param>
|
|
/// <param name="y">Local Y-coordinate of a block.</param>
|
|
/// <param name="z">Local Z-coordinate of a block.</param>
|
|
/// <param name="te">The <see cref="TileEntity"/> to add to the given block.</param>
|
|
/// <exception cref="ArgumentException">Thrown when the <see cref="TileEntity"/> being passed is of the wrong type for the given block.</exception>
|
|
/// <exception cref="InvalidOperationException">Thrown when the given block is of a type that does not support a <see cref="TileEntity"/> record.</exception>
|
|
public void SetTileEntity (int x, int y, int z, TileEntity te)
|
|
{
|
|
_tileEntityManager.SetTileEntity(x, y, z, te);
|
|
_dirty = true;
|
|
}
|
|
|
|
internal void SetTileEntity (int index, TileEntity te)
|
|
{
|
|
int x, y, z;
|
|
_blocks.GetMultiIndex(index, out x, out y, out z);
|
|
|
|
_tileEntityManager.SetTileEntity(x, y, z, te);
|
|
_dirty = true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a default <see cref="TileEntity"/> record suitable for the block at the given local coordinates.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a block.</param>
|
|
/// <param name="y">Local Y-coordinate of a block.</param>
|
|
/// <param name="z">Local Z-coordinate of a block.</param>
|
|
/// <exception cref="InvalidOperationException">Thrown when the given block is of a type that does not support a <see cref="TileEntity"/> record.</exception>
|
|
/// <exception cref="UnknownTileEntityException">Thrown when the block type requests a <see cref="TileEntity"/> that has not been registered with the <see cref="TileEntityFactory"/>.</exception>
|
|
public void CreateTileEntity (int x, int y, int z)
|
|
{
|
|
_tileEntityManager.CreateTileEntity(x, y, z);
|
|
_dirty = true;
|
|
}
|
|
|
|
internal void CreateTileEntity (int index)
|
|
{
|
|
int x, y, z;
|
|
_blocks.GetMultiIndex(index, out x, out y, out z);
|
|
|
|
_tileEntityManager.CreateTileEntity(x, y, z);
|
|
_dirty = true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clears any <see cref="TileEntity"/> record set for a block at the givne local coordinates, if one exists.
|
|
/// </summary>
|
|
/// <param name="x">Local X-coordinate of a block.</param>
|
|
/// <param name="y">Local Y-coordinate of a block.</param>
|
|
/// <param name="z">Local Z-coordinate of a block.</param>
|
|
public void ClearTileEntity (int x, int y, int z)
|
|
{
|
|
_tileEntityManager.ClearTileEntity(x, y, z);
|
|
_dirty = true;
|
|
}
|
|
|
|
internal void ClearTileEntity (int index)
|
|
{
|
|
int x, y, z;
|
|
_blocks.GetMultiIndex(index, out x, out y, out z);
|
|
|
|
_tileEntityManager.ClearTileEntity(x, y, z);
|
|
_dirty = true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
public void ResetFluid ()
|
|
{
|
|
_fluidManager.ResetWater(_blocks, _data);
|
|
_fluidManager.ResetLava(_blocks, _data);
|
|
_dirty = true;
|
|
}
|
|
|
|
public void RebuildFluid ()
|
|
{
|
|
_fluidManager.RebuildWater();
|
|
_fluidManager.RebuildLava();
|
|
_dirty = true;
|
|
}
|
|
|
|
public void UpdateFluid (int x, int y, int z)
|
|
{
|
|
bool autofluid = _autoFluid;
|
|
_autoFluid = false;
|
|
|
|
int blocktype = _blocks[x, y, z];
|
|
|
|
if (blocktype == BlockType.WATER || blocktype == BlockType.STATIONARY_WATER) {
|
|
_fluidManager.UpdateWater(x, y, z);
|
|
_dirty = true;
|
|
}
|
|
else if (blocktype == BlockType.LAVA || blocktype == BlockType.STATIONARY_LAVA) {
|
|
_fluidManager.UpdateLava(x, y, z);
|
|
_dirty = true;
|
|
}
|
|
|
|
_autoFluid = autofluid;
|
|
}
|
|
|
|
|
|
/*#region IEnumerable<AlphaBlockRef> Members
|
|
|
|
public IEnumerator<AlphaBlockRef> GetEnumerator ()
|
|
{
|
|
return new AlphaBlockEnumerator(this);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IEnumerable Members
|
|
|
|
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator ()
|
|
{
|
|
return new AlphaBlockEnumerator(this);
|
|
}
|
|
|
|
#endregion
|
|
|
|
public class AlphaBlockEnumerator : IEnumerator<AlphaBlockRef>
|
|
{
|
|
private AlphaBlockCollection _collection;
|
|
private int _index;
|
|
private int _size;
|
|
|
|
public AlphaBlockEnumerator (AlphaBlockCollection collection)
|
|
{
|
|
_collection = collection;
|
|
_index = -1;
|
|
_size = collection.XDim * collection.YDim * collection.ZDim;
|
|
}
|
|
|
|
#region IEnumerator<Entity> Members
|
|
|
|
public AlphaBlockRef Current
|
|
{
|
|
get
|
|
{
|
|
if (_index == -1 || _index == _size) {
|
|
throw new InvalidOperationException();
|
|
}
|
|
return new AlphaBlockRef(_collection, _index);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IDisposable Members
|
|
|
|
public void Dispose () { }
|
|
|
|
#endregion
|
|
|
|
#region IEnumerator Members
|
|
|
|
object System.Collections.IEnumerator.Current
|
|
{
|
|
get { return Current; }
|
|
}
|
|
|
|
public bool MoveNext ()
|
|
{
|
|
if (++_index == _size) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public void Reset ()
|
|
{
|
|
_index = -1;
|
|
}
|
|
|
|
#endregion
|
|
}*/
|
|
}
|
|
}
|