internal SingleContainerInterface(World.WorldManager world, InterfaceType interfaceType, UniversalCoords coords, sbyte slotCount)
: base(world, interfaceType, slotCount)
{
Coords = coords;
Load();
}
public SingleContainerInterface(World.WorldManager world, UniversalCoords coords, sbyte slotCount)
: base(world, InterfaceType.Chest, slotCount)
{
Coords = coords;
Load();
}
public void ForNSEW(UniversalCoords coords, ForEachBlock predicate)
{
predicate(UniversalCoords.FromWorld(coords.WorldX - 1, coords.WorldY, coords.WorldZ));
predicate(UniversalCoords.FromWorld(coords.WorldX + 1, coords.WorldY, coords.WorldZ));
predicate(UniversalCoords.FromWorld(coords.WorldX, coords.WorldY, coords.WorldZ - 1));
predicate(UniversalCoords.FromWorld(coords.WorldX, coords.WorldY, coords.WorldZ + 1));
}
/// <summary>
/// Opens the Workbench and specifies where items should be dropped if exiting the workbench with items still in it.
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="z"></param>
public virtual void Open(UniversalCoords coords)
{
_useProvidedDropCoordinates = true;
_DropCoords = coords;
this.Open();
}
/// <summary>
/// Creates a Large Chest interface for the two chests specified (North or East chest, and South or West chest)
/// </summary>
/// <param name="world"></param>
/// <param name="neChest">The North or East chest coordinates</param>
/// <param name="swChest">The South or West chest coordinates</param>
public LargeChestInterface(World.WorldManager world, UniversalCoords neChest, UniversalCoords swChest)
: base(world, InterfaceType.Chest, 54)
{
NEChest = neChest;
SWChest = swChest;
Load();
}
public static void StopBurning(WorldManager world, UniversalCoords coords)
{
string id = String.Format("{0}-{1},{2},{3}", world.Name, coords.WorldX, coords.WorldY, coords.WorldZ);
lock (_staticLock)
{
if (_furnaceInstances.ContainsKey(id))
_furnaceInstances[id].StopBurning();
}
}
public void ForAdjacent(UniversalCoords coords, ForEachBlock predicate)
{
predicate(UniversalCoords.FromWorld(coords.WorldX - 1, coords.WorldY, coords.WorldZ));
predicate(UniversalCoords.FromWorld(coords.WorldX + 1, coords.WorldY, coords.WorldZ));
predicate(UniversalCoords.FromWorld(coords.WorldX, coords.WorldY, coords.WorldZ - 1));
predicate(UniversalCoords.FromWorld(coords.WorldX, coords.WorldY, coords.WorldZ + 1));
if (coords.BlockY > 0)
predicate(UniversalCoords.FromWorld(coords.WorldX, coords.WorldY - 1, coords.WorldZ));
if (coords.BlockY < 127)
predicate(UniversalCoords.FromWorld(coords.WorldX, coords.WorldY + 1, coords.WorldZ));
}
protected override double BlockPathWeight(UniversalCoords coords)
{
if (this.World.GetBlockId(coords.WorldX, coords.WorldY - 1, coords.WorldZ) == (byte)BlockData.Blocks.Grass)
{
return 10.0;
}
else
{
return this.World.GetBlockLightBrightness(coords) - 0.5; // stay out of lower half of brightness spectrum
}
}
public unsafe byte this[UniversalCoords coords]
{
get
{
fixed (byte* types = Types)
return types[coords.BlockPackedCoords];
}
set
{
fixed (byte* types = Types)
types[coords.BlockPackedCoords] = value;
}
}
public Chunk this[UniversalCoords coords]
{
get
{
Chunk chunk;
Chunks.TryGetValue(coords.ChunkPackedCoords, out chunk);
return chunk;
}
private set
{
Chunks.AddOrUpdate(coords.ChunkPackedCoords, value, (key, oldValue) => value);
}
}
public static void Destroy(WorldManager world, UniversalCoords coords)
{
PersistentContainer container = Instance(world, coords);
if (container == null)
return;
Chunk chunk = world.GetChunk(coords);
if (chunk == null)
return;
PersistentContainer unused;
container.Destroy();
chunk.Containers.TryRemove(container.Coords.BlockPackedCoords, out unused);
if (container is LargeChestContainer)
chunk.Containers.TryRemove((container as LargeChestContainer).SecondCoords.BlockPackedCoords, out unused);
}
public static void Close(PersistentContainerInterface containerInterface, UniversalCoords coords)
{
PersistentContainer container = Instance(containerInterface.World, coords);
if (container == null)
return;
container.RemoveInterface(containerInterface);
Chunk chunk = container.World.GetChunk(coords);
if (chunk == null)
return;
PersistentContainer unused;
if (container is LargeChestContainer && container.IsUnused())
{
chunk.Containers.TryRemove(container.Coords.BlockPackedCoords, out unused);
chunk.Containers.TryRemove((container as LargeChestContainer).SecondCoords.BlockPackedCoords, out unused);
} else if (container is SmallChestContainer && container.IsUnused())
chunk.Containers.TryRemove(container.Coords.BlockPackedCoords, out unused);
}
public static UniversalCoords[] GetDoubleChestCoords(WorldManager world, UniversalCoords coords)
{
Chunk chunk = world.GetChunk(coords);
if (chunk == null || !IsDoubleChest(chunk, coords))
return null;
// Is this chest the "North or East", or the "South or West"
BlockData.Blocks[] nsewBlocks = new BlockData.Blocks[4];
UniversalCoords[] nsewBlockPositions = new UniversalCoords[4];
int nsewCount = 0;
byte? blockId;
chunk.ForNSEW(coords, uc =>
{
blockId = world.GetBlockId(uc) ?? 0;
nsewBlocks[nsewCount] = (BlockData.Blocks)blockId;
nsewBlockPositions[nsewCount] = uc;
nsewCount++;
});
UniversalCoords firstCoords;
UniversalCoords secondCoords;
if ((byte)nsewBlocks[0] == (byte)BlockData.Blocks.Chest) // North
{
firstCoords = nsewBlockPositions[0];
secondCoords = coords;
}
else if ((byte)nsewBlocks[2] == (byte)BlockData.Blocks.Chest) // East
{
firstCoords = nsewBlockPositions[2];
secondCoords = coords;
}
else if ((byte)nsewBlocks[1] == (byte)BlockData.Blocks.Chest) // South
{
firstCoords = coords;
secondCoords = nsewBlockPositions[1];
}
else// if ((byte)nsewBlocks[3] == (byte)BlockData.Blocks.Chest) // West
{
firstCoords = coords;
secondCoords = nsewBlockPositions[3];
}
return new UniversalCoords[] { firstCoords, secondCoords };
}
public void GrowCactus(UniversalCoords coords)
{
if (GetType(coords) == BlockData.Blocks.Cactus)
return;
if (GetType(UniversalCoords.FromWorld(coords.WorldX, coords.WorldY - 3, coords.WorldZ)) == BlockData.Blocks.Cactus)
return;
if (!IsNSEWTo(coords, (byte)BlockData.Blocks.Air))
return;
if (World.Server.Rand.Next(60) == 0)
{
SetType(coords, BlockData.Blocks.Cactus);
}
}
public static Chunk Load(UniversalCoords coords, WorldManager world)
{
string path = world.Folder + "/x" + coords.ChunkX + "_z" + coords.ChunkZ + ".gz";
if (!CanLoad(path))
return null;
Stream zip = null;
Chunk chunk = new Chunk(world, coords);
try
{
zip = new DeflateStream(File.Open(path, FileMode.Open), CompressionMode.Decompress);
int version = zip.ReadByte();
switch(version)
{
/* When there's a new mod you do:
case 1:
{
* dosomething
* goto case 0;
}*/
case 0:
{
chunk.LightToRecalculate = Convert.ToBoolean(zip.ReadByte());
chunk.HeightMap = new byte[16,16];
int height;
chunk.MaxHeight = 0;
for (int x = 0; x < 16; ++x)
{
for (int z = 0; z < 16; ++z)
{
height = chunk.HeightMap[x, z] = (byte) zip.ReadByte();
if (chunk.MaxHeight < height)
chunk.MaxHeight = height;
}
}
chunk.LoadAllBlocks(zip);
break;
}
}
}
catch (Exception ex)
{
world.Logger.Log(ex);
return null;
}
if (zip != null)
zip.Dispose();
(BlockHelper.Instance((byte) BlockData.Blocks.Sign_Post) as BlockSignBase).LoadSignsFromDisk(chunk, world.SignsFolder);
return chunk;
}
public FurnaceInterface(World.WorldManager world, UniversalCoords coords)
: base(world, InterfaceType.Furnace, coords, 3)
{
}
public FurnaceInstance(WorldManager world, UniversalCoords coords)
{
this.World = world;
Coords = coords;
}
private static void RemoveFurnaceInterface(UniversalCoords coords, FurnaceInterface furnace)
{
string id = String.Format("{0}-{1},{2},{3}", furnace.World.Name, coords.WorldX, coords.WorldY, coords.WorldZ);
lock (_staticLock)
{
if (_furnaceInstances.ContainsKey(id))
{
_furnaceInstances[id].Remove(furnace);
}
}
}
/// <summary>
/// Adds the FurnaceInterface to a FurnaceInstance, then returns the FurnaceInstance it is added to.
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="z"></param>
/// <param name="furnace"></param>
/// <returns>The FurnaceInstance that the FurnaceInterface was added to</returns>
private static FurnaceInstance AddFurnaceInterface(UniversalCoords coords, FurnaceInterface furnace)
{
string id = String.Format("{0}-{1},{2},{3}", furnace.World.Name, coords.WorldX, coords.WorldY, coords.WorldZ);
lock (_staticLock)
{
FurnaceInstance furnaceInstance;
if (!_furnaceInstances.ContainsKey(id))
{
furnaceInstance = new FurnaceInstance(furnace.World, coords);
_furnaceInstances[id] = furnaceInstance;
}
else
{
furnaceInstance = _furnaceInstances[id];
}
furnaceInstance.Add(furnace);
return furnaceInstance;
}
}
public DispenserInterface(World.WorldManager world, UniversalCoords coords)
: base(world, InterfaceType.Dispenser, coords, 9)
{
}
public SmallChestInterface(World.WorldManager world, UniversalCoords coords)
: base(world, InterfaceType.Chest, coords, 27)
{
}
internal Chunk(WorldManager world, UniversalCoords coords)
: base(world, coords)
{
LightToRecalculate = true;
}
public override void OnSetType(UniversalCoords coords, BlockData.Blocks value)
{
base.OnSetType(coords, value);
byte blockId = (byte)value;
if (GrowableBlocks.ContainsKey(coords.BlockPackedCoords))
{
short unused;
if (!BlockHelper.IsGrowable(blockId))
{
GrowableBlocks.TryRemove(coords.BlockPackedCoords, out unused);
}
else
{
StructBlock block = new StructBlock(coords, blockId, GetData(coords), World);
if (!(BlockHelper.Instance(blockId) as IBlockGrowable).CanGrow(block, this))
{
GrowableBlocks.TryRemove(coords.BlockPackedCoords, out unused);
}
}
}
else
{
if (BlockHelper.IsGrowable(blockId))
{
StructBlock block = new StructBlock(coords, blockId, GetData(coords), World);
if ((BlockHelper.Instance(blockId) as IBlockGrowable).CanGrow(block, this))
{
GrowableBlocks.TryAdd(coords.BlockPackedCoords, coords.BlockPackedCoords);
}
}
}
}
public bool IsAdjacentTo(UniversalCoords coords, byte block)
{
bool retval = false;
ForAdjacent(coords, delegate(UniversalCoords uc)
{
retval = retval || World.GetBlockId(uc) == block;
});
return retval;
}
public bool IsNSEWTo(UniversalCoords coords, byte block)
{
bool retval = false;
ForNSEW(coords, delegate(UniversalCoords uc)
{
if (World.GetBlockId(uc) == block)
retval = true;
});
return retval;
}
internal void Update(UniversalCoords coords, bool updateClients = true)
{
Chunk chunk = GetChunk(coords);
if (chunk == null)
return;
if (updateClients)
chunk.BlockNeedsUpdate(coords.BlockX, coords.BlockY, coords.BlockZ);
UpdatePhysics(coords);
chunk.ForAdjacent(coords, uc => UpdatePhysics(uc));
}
public void RecalculateHeight(UniversalCoords coords)
{
RecalculateHeight(coords.BlockX, coords.BlockZ);
}
private RayTraceHitBlock DoRayTraceBlock(UniversalCoords coords, Vector3 rayStart, Vector3 rayEnd)
{
Chunk chunk = GetChunk(coords);
if (chunk == null)
return null;
byte blockType = (byte)chunk.GetType(coords); // only get the block type first to save time
if (blockType > 0)
{
byte blockData = chunk.GetData(coords);
StructBlock block = new StructBlock(coords, (byte)blockType, (byte)blockData, this);
BlockBase blockClass = BlockHelper.Instance(block.Type);
RayTraceHitBlock blockRayTrace = blockClass.RayTraceIntersection(block, rayStart, rayEnd);
if (blockRayTrace != null)
{
return blockRayTrace;
}
}
return null;
}
private void GrowDirt(UniversalCoords coords)
{
if (coords.WorldY >= 127 || IsAir(UniversalCoords.FromWorld(coords.WorldX, coords.WorldY + 1, coords.WorldZ)))
return;
if (World.Server.Rand.Next(30) != 0)
{
SetType(coords, BlockData.Blocks.Dirt);
}
}
public AbsWorldCoords(UniversalCoords coords)
{
X = coords.WorldX;
Y = coords.WorldY;
Z = coords.WorldZ;
}
