public class BlockDeployableStructureRebirth : Block
{
    public ulong TickRate = 20UL;
    public int iteration = 0;
    public Vector3i blockPos;
    public byte blockRotation = 1;
    public string structureType = "";

    public override bool CanPlaceBlockAt(WorldBase _world, int _clrIdx, Vector3i _blockPos, BlockValue _blockValue, bool _bOmitCollideCheck = false)
    {
        //Log.Out("BlockDeployableStructureRebirth-CanPlaceBlockAt START");
        if (GameManager.Instance.IsEditMode())
        {
            //Log.Out("BlockDeployableStructureRebirth-CanPlaceBlockAt 1");
            return true;
        }

        bool bCanPlaceBlock = base.CanPlaceBlockAt(_world, _clrIdx, _blockPos, _blockValue, _bOmitCollideCheck);

        if (this.Properties.Values.ContainsKey("Structure"))
        {
            this.structureType = this.Properties.Values["Structure"];
        }

        if (this.structureType == "TempDefense")
        {
            //Log.Out("BlockDeployableStructureRebirth-CanPlaceBlockAt 2");
            if (RebirthUtilities.overlapsWithOtherBlocks(_world, _blockPos, 3, 3))
            {
                return false;
            }
        }

        bool hasLandClaim = false;

        if (!(bCanPlaceBlock && !hasLandClaim))
        {
            //Log.Out("BlockDeployableStructureRebirth-CanPlaceBlockAt 3");
            return false;
        }

        return true;
    }

    public override void LateInit()
    {
        base.LateInit();
    }

    public override void OnBlockAdded(WorldBase _world, Chunk _chunk, Vector3i _blockPos, BlockValue _blockValue)
    {
        //Log.Out("BlockDeployableStructureRebirth-OnBlockAdded START");
        base.OnBlockAdded(_world, _chunk, _blockPos, _blockValue);

        if (!SingletonMonoBehaviour<ConnectionManager>.Instance.IsServer) return;
        if (GameManager.Instance.IsEditMode()) return;

        //Log.Out("BlockDeployableStructureRebirth-OnBlockAdded rotation: " + _blockValue.rotation);

        _blockValue.meta = 0;
        iteration = 0;

        if (this.Properties.Values.ContainsKey("Structure"))
        {
            this.structureType = this.Properties.Values["Structure"];
        }

        _world.GetWBT().AddScheduledBlockUpdate(_chunk.ClrIdx, _blockPos, this.blockID, 20UL);
    }

    public override bool UpdateTick(WorldBase _world, int _clrIdx, Vector3i _blockPos, BlockValue _blockValue, bool _bRandomTick, ulong _ticksIfLoaded, GameRandom _rnd)
    {
        if (!SingletonMonoBehaviour<ConnectionManager>.Instance.IsServer)
        {
            return false;
        }

        //Log.Out("BlockDeployableStructureRebirth-UpdateTick START");

        byte rotationNew = 0;
        TileEntitySecure tileEntitySecure;

        if (structureType == "MineShaft")
        {
            if (iteration == 0) // CREATE THE HOLE
            {
                BlockValue blockValue;

                // DEFAULT ROTATION IS 1
                if (_blockValue.rotation == 24)
                {
                    _blockValue.rotation = 0;
                }
                if (_blockValue.rotation == 25)
                {
                    _blockValue.rotation = 1;
                }
                if (_blockValue.rotation == 26)
                {
                    _blockValue.rotation = 2;
                }
                if (_blockValue.rotation == 27)
                {
                    _blockValue.rotation = 3;
                }

                //Log.Out("BlockDeployableStructureRebirth-UpdateTick 0");

                blockPos = _blockPos;
                blockRotation = _blockValue.rotation;

                int posX = blockPos.x;
                int posY = blockPos.y;
                int posZ = blockPos.z;

                Chunk chunk = (Chunk)_world.GetChunkFromWorldPos(blockPos);

                // SHAFT BLOCKS

                RebirthUtilities.ReplaceBlocks("FuriousRamsayAir", blockRotation, 0, blockPos.x, blockPos.y + 3, blockPos.z,
                                                    3, 3, 0,
                                                    _world, chunk
                                                    );

                RebirthUtilities.ReplaceBlocks("FuriousRamsayAir", blockRotation, 0, blockPos.x, blockPos.y, blockPos.z,
                                                    1, 3, 1,
                                                    _world, chunk
                                                    );

                RebirthUtilities.ReplaceBlocks("woodShapes:cube", blockRotation, 0, blockPos.x, blockPos.y - 1, blockPos.z,
                                                    10, 1, 0,
                                                    _world, chunk
                                                    );

                RebirthUtilities.ReplaceBlocks("FuriousRamsayAir", blockRotation, 0, blockPos.x, blockPos.y - 1, blockPos.z,
                                                    9, 2, 1,
                                                    _world, chunk
                                                    );

                DynamicMeshManager.ChunkChanged(blockPos, -1, _blockValue.type);

                iteration++;

                _world.GetWBT().AddScheduledBlockUpdate(_clrIdx, blockPos, this.blockID, this.TickRate);

            }
            else if (iteration == 1)
            {
                //Log.Out("BlockDeployableStructureRebirth-UpdateTick 1");

                BlockValue blockValue;

                int posX = blockPos.x;
                int posY = blockPos.y;
                int posZ = blockPos.z;

                Chunk chunk = (Chunk)_world.GetChunkFromWorldPos(blockPos);

                RebirthUtilities.ReplaceBlocks("woodShapes:cube", blockRotation, 0, blockPos.x, blockPos.y - 1, blockPos.z,
                                                    10, 2, 1,
                                                    _world, chunk
                                                    );

                blockValue = Block.GetBlockValue("woodShapes:cube", true);
                posX = blockPos.x + 2;
                posY = blockPos.y - 1;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 2;
                posY = blockPos.y - 1;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 2;
                posY = blockPos.y - 1;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                DynamicMeshManager.ChunkChanged(blockPos, -1, _blockValue.type);

                iteration++;

                _world.GetWBT().AddScheduledBlockUpdate(_clrIdx, blockPos, this.blockID, this.TickRate);
            }
            else if (iteration == 2)
            {
                //Log.Out("BlockDeployableStructureRebirth-UpdateTick 2");

                BlockValue blockValue;

                int posX = blockPos.x;
                int posY = blockPos.y;
                int posZ = blockPos.z;

                Chunk chunk = (Chunk)_world.GetChunkFromWorldPos(blockPos);

                blockValue = Block.GetBlockValue("woodShapes:barsCorner", true);

                blockValue.rotation = 0;
                posX = blockPos.x + 1;
                posY = blockPos.y;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 1;
                posX = blockPos.x - 1;
                posY = blockPos.y;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 2;
                posX = blockPos.x - 1;
                posY = blockPos.y;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 3;
                posX = blockPos.x + 1;
                posY = blockPos.y;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 0;
                posX = blockPos.x + 1;
                posY = blockPos.y + 1;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 1;
                posX = blockPos.x - 1;
                posY = blockPos.y + 1;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 0;
                posX = blockPos.x + 1;
                posY = blockPos.y + 1;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 2;
                posX = blockPos.x - 1;
                posY = blockPos.y + 1;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 3;
                posX = blockPos.x + 1;
                posY = blockPos.y + 1;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("woodHatch", true);
                blockValue.rotation = 3;
                posX = blockPos.x + 1;
                posY = blockPos.y;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("woodShapes:bars", true);

                blockValue.rotation = 0;
                posX = blockPos.x;
                posY = blockPos.y;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 0;
                posX = blockPos.x;
                posY = blockPos.y + 1;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 1;
                posX = blockPos.x - 1;
                posY = blockPos.y + 1;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 2;
                posX = blockPos.x;
                posY = blockPos.y;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 2;
                posX = blockPos.x;
                posY = blockPos.y + 1;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("woodShapes:cube", true);
                blockValue.rotation = 0;

                posX = blockPos.x - 1;
                posY = blockPos.y;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 1;
                posY = blockPos.y + 2;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x;
                posY = blockPos.y + 2;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x - 1;
                posY = blockPos.y + 2;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x - 1;
                posY = blockPos.y + 2;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x - 1;
                posY = blockPos.y + 2;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x;
                posY = blockPos.y + 2;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 1;
                posY = blockPos.y + 2;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 1;
                posY = blockPos.y + 2;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x;
                posY = blockPos.y + 2;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("woodShapes:ladderSquare", true);
                blockValue.rotation = 1;
                posX = blockPos.x + 2;
                posY = blockPos.y + 2;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 0;
                posX = blockPos.x;
                posY = blockPos.y + 2;
                posZ = blockPos.z + 2;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 3;
                posX = blockPos.x - 2;
                posY = blockPos.y + 2;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 2;
                posX = blockPos.x;
                posY = blockPos.y + 2;
                posZ = blockPos.z - 2;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("wallTorchLightPlayer", true);
                blockValue.rotation = 1;
                posX = blockPos.x + 2;
                posY = blockPos.y + 2;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 1;
                posX = blockPos.x + 2;
                posY = blockPos.y + 2;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                DynamicMeshManager.ChunkChanged(blockPos, -1, _blockValue.type);

                iteration++;

                _world.GetWBT().AddScheduledBlockUpdate(_clrIdx, blockPos, this.blockID, this.TickRate);
            }
            else if (iteration == 3)
            {
                //Log.Out("BlockDeployableStructureRebirth-UpdateTick 3");

                BlockValue blockValue;

                int posX = blockPos.x;
                int posY = blockPos.y;
                int posZ = blockPos.z;

                Chunk chunk = (Chunk)_world.GetChunkFromWorldPos(blockPos);

                RebirthUtilities.ReplaceBlocks("FuriousRamsayAir", blockRotation, 0, blockPos.x, blockPos.y - 1, blockPos.z,
                                                    9, 1, 0,
                                                    _world, chunk
                                                    );
                RebirthUtilities.ReplaceBlocks("FuriousRamsayAir", blockRotation, 0, blockPos.x, blockPos.y - 7, blockPos.z,
                                                    3, 5, 2,
                                                    _world, chunk
                                                    );

                blockValue = Block.GetBlockValue("FuriousRamsayAir", true);
                blockValue.rotation = 0;

                posX = blockPos.x + 1;
                posY = blockPos.y - 8;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 1;
                posY = blockPos.y - 9;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                DynamicMeshManager.ChunkChanged(blockPos, -1, _blockValue.type);

                iteration++;

                _world.GetWBT().AddScheduledBlockUpdate(_clrIdx, blockPos, this.blockID, this.TickRate);
            }
            else if (iteration == 4)
            {
                //Log.Out("BlockDeployableStructureRebirth-UpdateTick 4");

                BlockValue blockValue;

                int posX = blockPos.x;
                int posY = blockPos.y;
                int posZ = blockPos.z;

                Chunk chunk = (Chunk)_world.GetChunkFromWorldPos(blockPos);

                blockValue = Block.GetBlockValue("woodShapes:cube", true);
                blockValue.rotation = 0;
                posX = blockPos.x;
                posY = blockPos.y - 10;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 1;
                posY = blockPos.y - 10;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 2;
                posY = blockPos.y - 10;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 2;
                posY = blockPos.y - 10;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 2;
                posY = blockPos.y - 10;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("wallTorchLightPlayer", true);
                blockValue.rotation = 1;
                posX = blockPos.x + 2;
                posY = blockPos.y - 8;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 0;
                posX = blockPos.x + 1;
                posY = blockPos.y - 8;
                posZ = blockPos.z + 2;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 3;
                posX = blockPos.x - 2;
                posY = blockPos.y - 8;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 2;
                posX = blockPos.x - 1;
                posY = blockPos.y - 8;
                posZ = blockPos.z - 2;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("woodHatch", true);
                blockValue.rotation = 3;
                posX = blockPos.x + 1;
                posY = blockPos.y - 9;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                RebirthUtilities.ReplaceBlocks("woodShapes:ladderSquare", blockRotation, 1, blockPos.x, blockPos.y - 1, blockPos.z,
                                                    8, 1, 0,
                                                    _world, chunk
                                                    );

                blockValue = Block.GetBlockValue("woodShapes:ladderSquare", true);
                blockValue.rotation = 1;
                posX = blockPos.x;
                posY = blockPos.y;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                DynamicMeshManager.ChunkChanged(blockPos, -1, _blockValue.type);

                iteration++;
            }
        }
        if (structureType == "MineShaftCobble")
        {
            if (iteration == 0) // CREATE THE HOLE
            {
                BlockValue blockValue;

                // DEFAULT ROTATION IS 1
                if (_blockValue.rotation == 24)
                {
                    _blockValue.rotation = 0;
                }
                if (_blockValue.rotation == 25)
                {
                    _blockValue.rotation = 1;
                }
                if (_blockValue.rotation == 26)
                {
                    _blockValue.rotation = 2;
                }
                if (_blockValue.rotation == 27)
                {
                    _blockValue.rotation = 3;
                }

                //Log.Out("BlockDeployableStructureRebirth-UpdateTick 0");

                blockPos = _blockPos;
                blockRotation = _blockValue.rotation;

                int posX = blockPos.x;
                int posY = blockPos.y;
                int posZ = blockPos.z;

                Chunk chunk = (Chunk)_world.GetChunkFromWorldPos(blockPos);

                // SHAFT BLOCKS

                RebirthUtilities.ReplaceBlocks("FuriousRamsayAir", blockRotation, 0, blockPos.x, blockPos.y + 3, blockPos.z,
                                                    3, 3, 0,
                                                    _world, chunk
                                                    );

                RebirthUtilities.ReplaceBlocks("FuriousRamsayAir", blockRotation, 0, blockPos.x, blockPos.y, blockPos.z,
                                                    1, 3, 1,
                                                    _world, chunk
                                                    );

                RebirthUtilities.ReplaceBlocks("cobblestoneShapes:cube", blockRotation, 0, blockPos.x, blockPos.y - 1, blockPos.z,
                                                    10, 1, 0,
                                                    _world, chunk
                                                    );

                RebirthUtilities.ReplaceBlocks("FuriousRamsayAir", blockRotation, 0, blockPos.x, blockPos.y - 1, blockPos.z,
                                                    9, 2, 1,
                                                    _world, chunk
                                                    );

                DynamicMeshManager.ChunkChanged(blockPos, -1, _blockValue.type);

                iteration++;

                _world.GetWBT().AddScheduledBlockUpdate(_clrIdx, blockPos, this.blockID, this.TickRate);

            }
            else if (iteration == 1)
            {
                //Log.Out("BlockDeployableStructureRebirth-UpdateTick 1");

                BlockValue blockValue;

                int posX = blockPos.x;
                int posY = blockPos.y;
                int posZ = blockPos.z;

                Chunk chunk = (Chunk)_world.GetChunkFromWorldPos(blockPos);

                RebirthUtilities.ReplaceBlocks("cobblestoneShapes:cube", blockRotation, 0, blockPos.x, blockPos.y - 1, blockPos.z,
                                                    10, 2, 1,
                                                    _world, chunk
                                                    );

                blockValue = Block.GetBlockValue("cobblestoneShapes:cube", true);
                posX = blockPos.x + 2;
                posY = blockPos.y - 1;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 2;
                posY = blockPos.y - 1;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 2;
                posY = blockPos.y - 1;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                DynamicMeshManager.ChunkChanged(blockPos, -1, _blockValue.type);

                iteration++;

                _world.GetWBT().AddScheduledBlockUpdate(_clrIdx, blockPos, this.blockID, this.TickRate);
            }
            else if (iteration == 2)
            {
                //Log.Out("BlockDeployableStructureRebirth-UpdateTick 2");

                BlockValue blockValue;

                int posX = blockPos.x;
                int posY = blockPos.y;
                int posZ = blockPos.z;

                Chunk chunk = (Chunk)_world.GetChunkFromWorldPos(blockPos);

                blockValue = Block.GetBlockValue("cobblestoneShapes:barsCorner", true);

                blockValue.rotation = 0;
                posX = blockPos.x + 1;
                posY = blockPos.y;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 1;
                posX = blockPos.x - 1;
                posY = blockPos.y;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 2;
                posX = blockPos.x - 1;
                posY = blockPos.y;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 3;
                posX = blockPos.x + 1;
                posY = blockPos.y;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 0;
                posX = blockPos.x + 1;
                posY = blockPos.y + 1;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 1;
                posX = blockPos.x - 1;
                posY = blockPos.y + 1;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 0;
                posX = blockPos.x + 1;
                posY = blockPos.y + 1;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 2;
                posX = blockPos.x - 1;
                posY = blockPos.y + 1;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 3;
                posX = blockPos.x + 1;
                posY = blockPos.y + 1;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("ironHatchWhite", true);
                blockValue.rotation = 3;
                posX = blockPos.x + 1;
                posY = blockPos.y;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("cobblestoneShapes:bars", true);

                blockValue.rotation = 0;
                posX = blockPos.x;
                posY = blockPos.y;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 0;
                posX = blockPos.x;
                posY = blockPos.y + 1;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 1;
                posX = blockPos.x - 1;
                posY = blockPos.y + 1;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 2;
                posX = blockPos.x;
                posY = blockPos.y;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 2;
                posX = blockPos.x;
                posY = blockPos.y + 1;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("cobblestoneShapes:cube", true);
                blockValue.rotation = 0;

                posX = blockPos.x - 1;
                posY = blockPos.y;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 1;
                posY = blockPos.y + 2;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x;
                posY = blockPos.y + 2;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x - 1;
                posY = blockPos.y + 2;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x - 1;
                posY = blockPos.y + 2;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x - 1;
                posY = blockPos.y + 2;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x;
                posY = blockPos.y + 2;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 1;
                posY = blockPos.y + 2;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 1;
                posY = blockPos.y + 2;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x;
                posY = blockPos.y + 2;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("woodShapes:ladderSquare", true);
                blockValue.rotation = 1;
                posX = blockPos.x + 2;
                posY = blockPos.y + 2;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 0;
                posX = blockPos.x;
                posY = blockPos.y + 2;
                posZ = blockPos.z + 2;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 3;
                posX = blockPos.x - 2;
                posY = blockPos.y + 2;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 2;
                posX = blockPos.x;
                posY = blockPos.y + 2;
                posZ = blockPos.z - 2;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("wallTorchLightPlayer", true);
                blockValue.rotation = 1;
                posX = blockPos.x + 2;
                posY = blockPos.y + 2;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 1;
                posX = blockPos.x + 2;
                posY = blockPos.y + 2;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                DynamicMeshManager.ChunkChanged(blockPos, -1, _blockValue.type);

                iteration++;

                _world.GetWBT().AddScheduledBlockUpdate(_clrIdx, blockPos, this.blockID, this.TickRate);
            }
            else if (iteration == 3)
            {
                //Log.Out("BlockDeployableStructureRebirth-UpdateTick 3");

                BlockValue blockValue;

                int posX = blockPos.x;
                int posY = blockPos.y;
                int posZ = blockPos.z;

                Chunk chunk = (Chunk)_world.GetChunkFromWorldPos(blockPos);

                RebirthUtilities.ReplaceBlocks("FuriousRamsayAir", blockRotation, 0, blockPos.x, blockPos.y - 1, blockPos.z,
                                                    9, 1, 0,
                                                    _world, chunk
                                                    );
                RebirthUtilities.ReplaceBlocks("FuriousRamsayAir", blockRotation, 0, blockPos.x, blockPos.y - 7, blockPos.z,
                                                    3, 5, 2,
                                                    _world, chunk
                                                    );

                blockValue = Block.GetBlockValue("FuriousRamsayAir", true);
                blockValue.rotation = 0;

                posX = blockPos.x + 1;
                posY = blockPos.y - 8;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 1;
                posY = blockPos.y - 9;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                DynamicMeshManager.ChunkChanged(blockPos, -1, _blockValue.type);

                iteration++;

                _world.GetWBT().AddScheduledBlockUpdate(_clrIdx, blockPos, this.blockID, this.TickRate);
            }
            else if (iteration == 4)
            {
                //Log.Out("BlockDeployableStructureRebirth-UpdateTick 4");

                BlockValue blockValue;

                int posX = blockPos.x;
                int posY = blockPos.y;
                int posZ = blockPos.z;

                Chunk chunk = (Chunk)_world.GetChunkFromWorldPos(blockPos);

                blockValue = Block.GetBlockValue("cobblestoneShapes:cube", true);
                blockValue.rotation = 0;
                posX = blockPos.x;
                posY = blockPos.y - 10;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 1;
                posY = blockPos.y - 10;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 2;
                posY = blockPos.y - 10;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 2;
                posY = blockPos.y - 10;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 2;
                posY = blockPos.y - 10;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("wallTorchLightPlayer", true);
                blockValue.rotation = 1;
                posX = blockPos.x + 2;
                posY = blockPos.y - 8;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 0;
                posX = blockPos.x + 1;
                posY = blockPos.y - 8;
                posZ = blockPos.z + 2;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 3;
                posX = blockPos.x - 2;
                posY = blockPos.y - 8;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 2;
                posX = blockPos.x - 1;
                posY = blockPos.y - 8;
                posZ = blockPos.z - 2;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("ironHatchWhite", true);
                blockValue.rotation = 3;
                posX = blockPos.x + 1;
                posY = blockPos.y - 9;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                RebirthUtilities.ReplaceBlocks("woodShapes:ladderSquare", blockRotation, 1, blockPos.x, blockPos.y - 1, blockPos.z,
                                                    8, 1, 0,
                                                    _world, chunk
                                                    );

                blockValue = Block.GetBlockValue("woodShapes:ladderSquare", true);
                blockValue.rotation = 1;
                posX = blockPos.x;
                posY = blockPos.y;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                DynamicMeshManager.ChunkChanged(blockPos, -1, _blockValue.type);

                iteration++;
            }
        }
        else if (structureType == "MineShaftExtension")
        {
            if (iteration == 0) // CREATE THE HOLE
            {
                BlockValue blockValue;

                // DEFAULT ROTATION IS 1
                if (_blockValue.rotation == 24)
                {
                    _blockValue.rotation = 0;
                }
                if (_blockValue.rotation == 25)
                {
                    _blockValue.rotation = 1;
                }
                if (_blockValue.rotation == 26)
                {
                    _blockValue.rotation = 2;
                }
                if (_blockValue.rotation == 27)
                {
                    _blockValue.rotation = 3;
                }

                //Log.Out("BlockDeployableStructureRebirth-UpdateTick 0");

                blockPos = _blockPos;
                blockRotation = _blockValue.rotation;

                int posX = blockPos.x;
                int posY = blockPos.y;
                int posZ = blockPos.z;

                Chunk chunk = (Chunk)_world.GetChunkFromWorldPos(blockPos);

                // SHAFT BLOCKS

                RebirthUtilities.ReplaceBlocks("woodShapes:cube", blockRotation, 0, blockPos.x, blockPos.y - 1, blockPos.z,
                                                    10, 1, 0,
                                                    _world, chunk
                                                    );

                RebirthUtilities.ReplaceBlocks("FuriousRamsayAir", blockRotation, 0, blockPos.x, blockPos.y - 1, blockPos.z,
                                                    9, 2, 1,
                                                    _world, chunk
                                                    );

                DynamicMeshManager.ChunkChanged(blockPos, -1, _blockValue.type);

                iteration++;

                _world.GetWBT().AddScheduledBlockUpdate(_clrIdx, blockPos, this.blockID, this.TickRate);

            }
            else if (iteration == 1)
            {
                //Log.Out("BlockDeployableStructureRebirth-UpdateTick 1");

                BlockValue blockValue;

                int posX = blockPos.x;
                int posY = blockPos.y;
                int posZ = blockPos.z;

                Chunk chunk = (Chunk)_world.GetChunkFromWorldPos(blockPos);

                RebirthUtilities.ReplaceBlocks("woodShapes:cube", blockRotation, 0, blockPos.x, blockPos.y - 1, blockPos.z,
                                                    10, 2, 1,
                                                    _world, chunk
                                                    );

                DynamicMeshManager.ChunkChanged(blockPos, -1, _blockValue.type);

                iteration++;

                _world.GetWBT().AddScheduledBlockUpdate(_clrIdx, blockPos, this.blockID, this.TickRate);
            }
            else if (iteration == 2)
            {
                //Log.Out("BlockDeployableStructureRebirth-UpdateTick 2");

                BlockValue blockValue;

                int posX = blockPos.x;
                int posY = blockPos.y;
                int posZ = blockPos.z;

                Chunk chunk = (Chunk)_world.GetChunkFromWorldPos(blockPos);

                blockValue = Block.GetBlockValue("woodShapes:cube", true);
                blockValue.rotation = 0;
                posX = blockPos.x - 1;
                posY = blockPos.y;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                RebirthUtilities.ReplaceBlocks("FuriousRamsayAir", blockRotation, 0, blockPos.x, blockPos.y - 1, blockPos.z,
                                                    9, 1, 0,
                                                    _world, chunk
                                                    );
                RebirthUtilities.ReplaceBlocks("FuriousRamsayAir", blockRotation, 0, blockPos.x, blockPos.y - 7, blockPos.z,
                                                    3, 5, 2,
                                                    _world, chunk
                                                    );

                blockValue = Block.GetBlockValue("FuriousRamsayAir", true);
                blockValue.rotation = 0;

                posX = blockPos.x + 1;
                posY = blockPos.y - 8;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 1;
                posY = blockPos.y - 9;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                DynamicMeshManager.ChunkChanged(blockPos, -1, _blockValue.type);

                iteration++;

                _world.GetWBT().AddScheduledBlockUpdate(_clrIdx, blockPos, this.blockID, this.TickRate);
            }
            else if (iteration == 3)
            {
                //Log.Out("BlockDeployableStructureRebirth-UpdateTick 3");

                BlockValue blockValue;

                int posX = blockPos.x;
                int posY = blockPos.y;
                int posZ = blockPos.z;

                Chunk chunk = (Chunk)_world.GetChunkFromWorldPos(blockPos);

                blockValue = Block.GetBlockValue("woodShapes:cube", true);
                blockValue.rotation = 0;
                posX = blockPos.x;
                posY = blockPos.y - 10;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 1;
                posY = blockPos.y - 10;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 2;
                posY = blockPos.y - 10;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 2;
                posY = blockPos.y - 10;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 2;
                posY = blockPos.y - 10;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("wallTorchLightPlayer", true);
                blockValue.rotation = 1;
                posX = blockPos.x + 2;
                posY = blockPos.y - 8;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 0;
                posX = blockPos.x + 1;
                posY = blockPos.y - 8;
                posZ = blockPos.z + 2;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 3;
                posX = blockPos.x - 2;
                posY = blockPos.y - 8;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 2;
                posX = blockPos.x - 1;
                posY = blockPos.y - 8;
                posZ = blockPos.z - 2;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("woodHatch", true);
                blockValue.rotation = 3;
                posX = blockPos.x + 1;
                posY = blockPos.y - 9;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                RebirthUtilities.ReplaceBlocks("woodShapes:ladderSquare", blockRotation, 1, blockPos.x, blockPos.y - 1, blockPos.z,
                                                    8, 1, 0,
                                                    _world, chunk
                                                    );

                blockValue = Block.GetBlockValue("FuriousRamsayAir", true);
                blockValue.rotation = 0;
                posX = blockPos.x;
                posY = blockPos.y;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                DynamicMeshManager.ChunkChanged(blockPos, -1, _blockValue.type);

                iteration++;
            }
        }
        else if (structureType == "MineShaftExtensionCobble")
        {
            if (iteration == 0) // CREATE THE HOLE
            {
                BlockValue blockValue;

                // DEFAULT ROTATION IS 1
                if (_blockValue.rotation == 24)
                {
                    _blockValue.rotation = 0;
                }
                if (_blockValue.rotation == 25)
                {
                    _blockValue.rotation = 1;
                }
                if (_blockValue.rotation == 26)
                {
                    _blockValue.rotation = 2;
                }
                if (_blockValue.rotation == 27)
                {
                    _blockValue.rotation = 3;
                }

                //Log.Out("BlockDeployableStructureRebirth-UpdateTick 0");

                blockPos = _blockPos;
                blockRotation = _blockValue.rotation;

                int posX = blockPos.x;
                int posY = blockPos.y;
                int posZ = blockPos.z;

                Chunk chunk = (Chunk)_world.GetChunkFromWorldPos(blockPos);

                // SHAFT BLOCKS

                RebirthUtilities.ReplaceBlocks("cobblestoneShapes:cube", blockRotation, 0, blockPos.x, blockPos.y - 1, blockPos.z,
                                                    10, 1, 0,
                                                    _world, chunk
                                                    );

                RebirthUtilities.ReplaceBlocks("FuriousRamsayAir", blockRotation, 0, blockPos.x, blockPos.y - 1, blockPos.z,
                                                    9, 2, 1,
                                                    _world, chunk
                                                    );

                DynamicMeshManager.ChunkChanged(blockPos, -1, _blockValue.type);

                iteration++;

                _world.GetWBT().AddScheduledBlockUpdate(_clrIdx, blockPos, this.blockID, this.TickRate);

            }
            else if (iteration == 1)
            {
                //Log.Out("BlockDeployableStructureRebirth-UpdateTick 1");

                BlockValue blockValue;

                int posX = blockPos.x;
                int posY = blockPos.y;
                int posZ = blockPos.z;

                Chunk chunk = (Chunk)_world.GetChunkFromWorldPos(blockPos);

                RebirthUtilities.ReplaceBlocks("cobblestoneShapes:cube", blockRotation, 0, blockPos.x, blockPos.y - 1, blockPos.z,
                                                    10, 2, 1,
                                                    _world, chunk
                                                    );

                DynamicMeshManager.ChunkChanged(blockPos, -1, _blockValue.type);

                iteration++;

                _world.GetWBT().AddScheduledBlockUpdate(_clrIdx, blockPos, this.blockID, this.TickRate);
            }
            else if (iteration == 2)
            {
                //Log.Out("BlockDeployableStructureRebirth-UpdateTick 2");

                BlockValue blockValue;

                int posX = blockPos.x;
                int posY = blockPos.y;
                int posZ = blockPos.z;

                Chunk chunk = (Chunk)_world.GetChunkFromWorldPos(blockPos);

                blockValue = Block.GetBlockValue("cobblestoneShapes:cube", true);
                blockValue.rotation = 0;
                posX = blockPos.x - 1;
                posY = blockPos.y;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                RebirthUtilities.ReplaceBlocks("FuriousRamsayAir", blockRotation, 0, blockPos.x, blockPos.y - 1, blockPos.z,
                                                    9, 1, 0,
                                                    _world, chunk
                                                    );
                RebirthUtilities.ReplaceBlocks("FuriousRamsayAir", blockRotation, 0, blockPos.x, blockPos.y - 7, blockPos.z,
                                                    3, 5, 2,
                                                    _world, chunk
                                                    );

                blockValue = Block.GetBlockValue("FuriousRamsayAir", true);
                blockValue.rotation = 0;

                posX = blockPos.x + 1;
                posY = blockPos.y - 8;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 1;
                posY = blockPos.y - 9;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                DynamicMeshManager.ChunkChanged(blockPos, -1, _blockValue.type);

                iteration++;

                _world.GetWBT().AddScheduledBlockUpdate(_clrIdx, blockPos, this.blockID, this.TickRate);
            }
            else if (iteration == 3)
            {
                //Log.Out("BlockDeployableStructureRebirth-UpdateTick 3");

                BlockValue blockValue;

                int posX = blockPos.x;
                int posY = blockPos.y;
                int posZ = blockPos.z;

                Chunk chunk = (Chunk)_world.GetChunkFromWorldPos(blockPos);

                blockValue = Block.GetBlockValue("cobblestoneShapes:cube", true);
                blockValue.rotation = 0;
                posX = blockPos.x;
                posY = blockPos.y - 10;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 1;
                posY = blockPos.y - 10;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 2;
                posY = blockPos.y - 10;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 2;
                posY = blockPos.y - 10;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                posX = blockPos.x + 2;
                posY = blockPos.y - 10;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("wallTorchLightPlayer", true);
                blockValue.rotation = 1;
                posX = blockPos.x + 2;
                posY = blockPos.y - 8;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 0;
                posX = blockPos.x + 1;
                posY = blockPos.y - 8;
                posZ = blockPos.z + 2;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 3;
                posX = blockPos.x - 2;
                posY = blockPos.y - 8;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue.rotation = 2;
                posX = blockPos.x - 1;
                posY = blockPos.y - 8;
                posZ = blockPos.z - 2;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("ironHatchWhite", true);
                blockValue.rotation = 3;
                posX = blockPos.x + 1;
                posY = blockPos.y - 9;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                RebirthUtilities.ReplaceBlocks("woodShapes:ladderSquare", blockRotation, 1, blockPos.x, blockPos.y - 1, blockPos.z,
                                                    8, 1, 0,
                                                    _world, chunk
                                                    );

                blockValue = Block.GetBlockValue("FuriousRamsayAir", true);
                blockValue.rotation = 0;
                posX = blockPos.x;
                posY = blockPos.y;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                DynamicMeshManager.ChunkChanged(blockPos, -1, _blockValue.type);

                iteration++;
            }
        }
        else if (structureType == "TempDefense")
        {
            if (iteration == 0)
            {
                BlockValue blockValue;

                // DEFAULT ROTATION IS 1
                if (_blockValue.rotation == 24)
                {
                    _blockValue.rotation = 0;
                }
                if (_blockValue.rotation == 25)
                {
                    _blockValue.rotation = 1;
                }
                if (_blockValue.rotation == 26)
                {
                    _blockValue.rotation = 2;
                }
                if (_blockValue.rotation == 27)
                {
                    _blockValue.rotation = 3;
                }

                //Log.Out("BlockDeployableStructureRebirth-UpdateTick 0");

                blockPos = _blockPos;
                blockRotation = _blockValue.rotation;

                int posX = blockPos.x;
                int posY = blockPos.y;
                int posZ = blockPos.z;

                Chunk chunk = (Chunk)_world.GetChunkFromWorldPos(blockPos);

                // SHAFT BLOCKS

                RebirthUtilities.ReplaceBlocks("FuriousRamsayTemporaryCobblestoneLVL" + iteration + ":cube", blockRotation, 0, blockPos.x, blockPos.y, blockPos.z,
                                                    1, 3, 2,
                                                    _world, chunk
                                                    );

                blockValue = Block.GetBlockValue("FuriousRamsayTemporaryscrapHatch_v3", true);
                blockValue.rotation = 1;
                posX = blockPos.x - 2;
                posY = blockPos.y;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);
                //Log.Out("BlockDeployableStructureRebirth-UpdateTick posX, posY, posZ: " + posX + ", " + posY + ", " + posZ);

                blockValue = Block.GetBlockValue("FuriousRamsayTemporaryscrapHatch_v3", true);
                blockValue.rotation = 0;
                posX = blockPos.x;
                posY = blockPos.y;
                posZ = blockPos.z - 2;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);
                //Log.Out("BlockDeployableStructureRebirth-UpdateTick posX, posY, posZ: " + posX + ", " + posY + ", " + posZ);

                blockValue = Block.GetBlockValue("FuriousRamsayTemporaryscrapHatch_v3", true);
                blockValue.rotation = 3;
                posX = blockPos.x + 2;
                posY = blockPos.y;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);
                //Log.Out("BlockDeployableStructureRebirth-UpdateTick posX, posY, posZ: " + posX + ", " + posY + ", " + posZ);

                blockValue = Block.GetBlockValue("FuriousRamsayTemporaryscrapHatch_v3", true);
                blockValue.rotation = 2;
                posX = blockPos.x;
                posY = blockPos.y;
                posZ = blockPos.z + 2;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);
                //Log.Out("BlockDeployableStructureRebirth-UpdateTick posX, posY, posZ: " + posX + ", " + posY + ", " + posZ);

                DynamicMeshManager.ChunkChanged(blockPos, -1, _blockValue.type);

                iteration++;

                _world.GetWBT().AddScheduledBlockUpdate(_clrIdx, blockPos, this.blockID, this.TickRate);

            }
            else if (iteration == 1)
            {
                //Log.Out("BlockDeployableStructureRebirth-UpdateTick 1");

                BlockValue blockValue;

                int posX = blockPos.x;
                int posY = blockPos.y;
                int posZ = blockPos.z;

                Chunk chunk = (Chunk)_world.GetChunkFromWorldPos(blockPos);

                blockValue = Block.GetBlockValue("FuriousRamsayTemporaryConcreteLVL" + iteration + ":barsCorner", true);
                blockValue.rotation = 2;
                posX = blockPos.x - 2;
                posY = blockPos.y + 1;
                posZ = blockPos.z + 2;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("FuriousRamsayTemporaryConcreteLVL" + iteration + ":barsCorner", true);
                blockValue.rotation = 1;
                posX = blockPos.x - 2;
                posY = blockPos.y + 1;
                posZ = blockPos.z - 2;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("FuriousRamsayTemporaryConcreteLVL" + iteration + ":barsCorner", true);
                blockValue.rotation = 0;
                posX = blockPos.x + 2;
                posY = blockPos.y + 1;
                posZ = blockPos.z - 2;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("FuriousRamsayTemporaryConcreteLVL" + iteration + ":barsCorner", true);
                blockValue.rotation = 3;
                posX = blockPos.x + 2;
                posY = blockPos.y + 1;
                posZ = blockPos.z + 2;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                DynamicMeshManager.ChunkChanged(blockPos, -1, _blockValue.type);

                iteration++;

                _world.GetWBT().AddScheduledBlockUpdate(_clrIdx, blockPos, this.blockID, this.TickRate);
            }
            else if (iteration == 2)
            {
                //Log.Out("BlockDeployableStructureRebirth-UpdateTick 2");

                BlockValue blockValue;

                int posX = blockPos.x;
                int posY = blockPos.y;
                int posZ = blockPos.z;

                Chunk chunk = (Chunk)_world.GetChunkFromWorldPos(blockPos);

                RebirthUtilities.ReplaceBlocks("FuriousRamsayTemporaryCobblestoneLVL" + iteration + ":cube", blockRotation, 0, blockPos.x, blockPos.y + 2, blockPos.z,
                                                    1, 3, 2,
                                                    _world, chunk
                                                    );

                DynamicMeshManager.ChunkChanged(blockPos, -1, _blockValue.type);

                iteration++;

                _world.GetWBT().AddScheduledBlockUpdate(_clrIdx, blockPos, this.blockID, this.TickRate);
            }
            else if (iteration == 3)
            {
                //Log.Out("BlockDeployableStructureRebirth-UpdateTick 3");

                BlockValue blockValue;

                int posX = blockPos.x;
                int posY = blockPos.y;
                int posZ = blockPos.z;

                Chunk chunk = (Chunk)_world.GetChunkFromWorldPos(blockPos);

                blockValue = Block.GetBlockValue("FuriousRamsayTemporaryCobblestoneLVL" + iteration + ":bars", true);
                blockValue.rotation = 10;
                posX = blockPos.x + 1;
                posY = blockPos.y + 2;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("FuriousRamsayTemporaryCobblestoneLVL" + iteration + ":bars", true);
                blockValue.rotation = 10;
                posX = blockPos.x + 1;
                posY = blockPos.y + 2;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("FuriousRamsayTemporaryCobblestoneLVL" + iteration + ":bars", true);
                blockValue.rotation = 10;
                posX = blockPos.x + 1;
                posY = blockPos.y + 2;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("FuriousRamsayTemporaryCobblestoneLVL" + iteration + ":bars", true);
                blockValue.rotation = 10;
                posX = blockPos.x;
                posY = blockPos.y + 2;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("FuriousRamsayTemporaryCobblestoneLVL" + iteration + ":bars", true);
                blockValue.rotation = 10;
                posX = blockPos.x;
                posY = blockPos.y + 2;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("FuriousRamsayTemporaryCobblestoneLVL" + iteration + ":bars", true);
                blockValue.rotation = 10;
                posX = blockPos.x;
                posY = blockPos.y + 2;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("FuriousRamsayTemporaryCobblestoneLVL" + iteration + ":bars", true);
                blockValue.rotation = 10;
                posX = blockPos.x - 1;
                posY = blockPos.y + 2;
                posZ = blockPos.z - 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("FuriousRamsayTemporaryCobblestoneLVL" + iteration + ":bars", true);
                blockValue.rotation = 10;
                posX = blockPos.x - 1;
                posY = blockPos.y + 2;
                posZ = blockPos.z;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("FuriousRamsayTemporaryCobblestoneLVL" + iteration + ":bars", true);
                blockValue.rotation = 10;
                posX = blockPos.x - 1;
                posY = blockPos.y + 2;
                posZ = blockPos.z + 1;
                rotationNew = blockValue.rotation;
                RebirthUtilities.ConvertRotatedPosition(1, blockRotation, blockPos.x, blockPos.z, ref posX, ref posZ, ref rotationNew);
                blockValue.rotation = rotationNew;
                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                blockValue = Block.GetBlockValue("FuriousRamsayTemporaryDefenseBlock:billboard", true);
                blockValue.rotation = 8;
                posX = blockPos.x;
                posY = blockPos.y;
                posZ = blockPos.z;

                blockValue = BlockPlaceholderMap.Instance.Replace(blockValue, _world.GetGameRandom(), chunk, posX, posY, posZ, FastTags<TagGroup.Global>.none, false);
                _world.SetBlockRPC(_clrIdx, new Vector3i(posX, posY, posZ), blockValue);

                DynamicMeshManager.ChunkChanged(blockPos, -1, _blockValue.type);

                iteration++;
            }
        }

        return true;
    }


    public override void Init()
    {
        base.Init();
    }

    public override ulong GetTickRate()
    {
        return (ulong)(1 * 20f);
    }
}