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; }