package net.minecraft.world.level.block;

import net.minecraft.world.level.block.state.AbstractStateHolder;
import com.google.common.collect.Maps;
import com.google.common.collect.ImmutableMap;
import net.minecraft.world.level.block.state.properties.BlockStateProperties;
import net.minecraft.world.level.block.state.StateDefinition;
import net.minecraft.core.particles.ParticleOptions;
import net.minecraft.core.particles.DustParticleOptions;
import java.util.Random;
import net.minecraft.util.Mth;
import javax.annotation.Nullable;
import java.util.EnumSet;
import java.util.List;
import com.google.common.collect.Lists;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.LevelReader;
import java.util.Iterator;
import net.minecraft.core.Vec3i;
import net.minecraft.world.level.LevelAccessor;
import net.minecraft.world.item.BlockPlaceContext;
import net.minecraft.world.phys.shapes.CollisionContext;
import net.minecraft.world.level.BlockGetter;
import net.minecraft.world.level.block.state.properties.Property;
import net.minecraft.world.level.block.state.BlockState;
import com.google.common.collect.Sets;
import net.minecraft.core.BlockPos;
import java.util.Set;
import net.minecraft.world.phys.shapes.VoxelShape;
import net.minecraft.core.Direction;
import java.util.Map;
import net.minecraft.world.level.block.state.properties.IntegerProperty;
import net.minecraft.world.level.block.state.properties.RedstoneSide;
import net.minecraft.world.level.block.state.properties.EnumProperty;

public class RedStoneWireBlock extends Block {
    public static final EnumProperty<RedstoneSide> NORTH;
    public static final EnumProperty<RedstoneSide> EAST;
    public static final EnumProperty<RedstoneSide> SOUTH;
    public static final EnumProperty<RedstoneSide> WEST;
    public static final IntegerProperty POWER;
    public static final Map<Direction, EnumProperty<RedstoneSide>> PROPERTY_BY_DIRECTION;
    protected static final VoxelShape[] SHAPE_BY_INDEX;
    private boolean shouldSignal;
    private final Set<BlockPos> toUpdate;
    
    public RedStoneWireBlock(final Properties c) {
        super(c);
        this.shouldSignal = true;
        this.toUpdate = Sets.newHashSet();
        this.registerDefaultState(((((((AbstractStateHolder<O, BlockState>)this.stateDefinition.any()).setValue(RedStoneWireBlock.NORTH, RedstoneSide.NONE)).setValue(RedStoneWireBlock.EAST, RedstoneSide.NONE)).setValue(RedStoneWireBlock.SOUTH, RedstoneSide.NONE)).setValue(RedStoneWireBlock.WEST, RedstoneSide.NONE)).<Comparable, Integer>setValue((Property<Comparable>)RedStoneWireBlock.POWER, 0));
    }
    
    @Override
    public VoxelShape getShape(final BlockState byj, final BlockGetter bjg, final BlockPos fk, final CollisionContext cvq) {
        return RedStoneWireBlock.SHAPE_BY_INDEX[getAABBIndex(byj)];
    }
    
    private static int getAABBIndex(final BlockState byj) {
        int integer2 = 0;
        final boolean boolean3 = byj.<RedstoneSide>getValue(RedStoneWireBlock.NORTH) != RedstoneSide.NONE;
        final boolean boolean4 = byj.<RedstoneSide>getValue(RedStoneWireBlock.EAST) != RedstoneSide.NONE;
        final boolean boolean5 = byj.<RedstoneSide>getValue(RedStoneWireBlock.SOUTH) != RedstoneSide.NONE;
        final boolean boolean6 = byj.<RedstoneSide>getValue(RedStoneWireBlock.WEST) != RedstoneSide.NONE;
        if (boolean3 || (boolean5 && !boolean3 && !boolean4 && !boolean6)) {
            integer2 |= 1 << Direction.NORTH.get2DDataValue();
        }
        if (boolean4 || (boolean6 && !boolean3 && !boolean4 && !boolean5)) {
            integer2 |= 1 << Direction.EAST.get2DDataValue();
        }
        if (boolean5 || (boolean3 && !boolean4 && !boolean5 && !boolean6)) {
            integer2 |= 1 << Direction.SOUTH.get2DDataValue();
        }
        if (boolean6 || (boolean4 && !boolean3 && !boolean5 && !boolean6)) {
            integer2 |= 1 << Direction.WEST.get2DDataValue();
        }
        return integer2;
    }
    
    @Override
    public BlockState getStateForPlacement(final BlockPlaceContext bcq) {
        final BlockGetter bjg3 = bcq.getLevel();
        final BlockPos fk4 = bcq.getClickedPos();
        return (((((AbstractStateHolder<O, BlockState>)this.defaultBlockState()).setValue(RedStoneWireBlock.WEST, this.getConnectingSide(bjg3, fk4, Direction.WEST))).setValue(RedStoneWireBlock.EAST, this.getConnectingSide(bjg3, fk4, Direction.EAST))).setValue(RedStoneWireBlock.NORTH, this.getConnectingSide(bjg3, fk4, Direction.NORTH))).<RedstoneSide, RedstoneSide>setValue(RedStoneWireBlock.SOUTH, this.getConnectingSide(bjg3, fk4, Direction.SOUTH));
    }
    
    @Override
    public BlockState updateShape(final BlockState byj1, final Direction fp, final BlockState byj3, final LevelAccessor bjx, final BlockPos fk5, final BlockPos fk6) {
        if (fp == Direction.DOWN) {
            return byj1;
        }
        if (fp == Direction.UP) {
            return (((((AbstractStateHolder<O, BlockState>)byj1).setValue(RedStoneWireBlock.WEST, this.getConnectingSide(bjx, fk5, Direction.WEST))).setValue(RedStoneWireBlock.EAST, this.getConnectingSide(bjx, fk5, Direction.EAST))).setValue(RedStoneWireBlock.NORTH, this.getConnectingSide(bjx, fk5, Direction.NORTH))).<RedstoneSide, RedstoneSide>setValue(RedStoneWireBlock.SOUTH, this.getConnectingSide(bjx, fk5, Direction.SOUTH));
        }
        return ((AbstractStateHolder<O, BlockState>)byj1).<RedstoneSide, RedstoneSide>setValue(RedStoneWireBlock.PROPERTY_BY_DIRECTION.get(fp), this.getConnectingSide(bjx, fk5, fp));
    }
    
    @Override
    public void updateIndirectNeighbourShapes(final BlockState byj, final LevelAccessor bjx, final BlockPos fk, final int integer) {
        try (final BlockPos.PooledMutableBlockPos b6 = BlockPos.PooledMutableBlockPos.acquire()) {
            for (final Direction fp9 : Direction.Plane.HORIZONTAL) {
                final RedstoneSide bzo10 = byj.<RedstoneSide>getValue(RedStoneWireBlock.PROPERTY_BY_DIRECTION.get(fp9));
                if (bzo10 != RedstoneSide.NONE && bjx.getBlockState(b6.set((Vec3i)fk).move(fp9)).getBlock() != this) {
                    b6.move(Direction.DOWN);
                    final BlockState byj2 = bjx.getBlockState(b6);
                    if (byj2.getBlock() != Blocks.OBSERVER) {
                        final BlockPos fk2 = b6.relative(fp9.getOpposite());
                        final BlockState byj3 = byj2.updateShape(fp9.getOpposite(), bjx.getBlockState(fk2), bjx, b6, fk2);
                        Block.updateOrDestroy(byj2, byj3, bjx, b6, integer);
                    }
                    b6.set((Vec3i)fk).move(fp9).move(Direction.UP);
                    final BlockState byj4 = bjx.getBlockState(b6);
                    if (byj4.getBlock() == Blocks.OBSERVER) {
                        continue;
                    }
                    final BlockPos fk3 = b6.relative(fp9.getOpposite());
                    final BlockState byj5 = byj4.updateShape(fp9.getOpposite(), bjx.getBlockState(fk3), bjx, b6, fk3);
                    Block.updateOrDestroy(byj4, byj5, bjx, b6, integer);
                }
            }
        }
    }
    
    private RedstoneSide getConnectingSide(final BlockGetter bjg, final BlockPos fk, final Direction fp) {
        final BlockPos fk2 = fk.relative(fp);
        final BlockState byj6 = bjg.getBlockState(fk2);
        final BlockPos fk3 = fk.above();
        final BlockState byj7 = bjg.getBlockState(fk3);
        if (!byj7.isRedstoneConductor(bjg, fk3)) {
            final boolean boolean9 = byj6.isFaceSturdy(bjg, fk2, Direction.UP) || byj6.getBlock() == Blocks.HOPPER;
            if (boolean9 && shouldConnectTo(bjg.getBlockState(fk2.above()))) {
                if (byj6.isCollisionShapeFullBlock(bjg, fk2)) {
                    return RedstoneSide.UP;
                }
                return RedstoneSide.SIDE;
            }
        }
        if (shouldConnectTo(byj6, fp) || (!byj6.isRedstoneConductor(bjg, fk2) && shouldConnectTo(bjg.getBlockState(fk2.below())))) {
            return RedstoneSide.SIDE;
        }
        return RedstoneSide.NONE;
    }
    
    @Override
    public boolean canSurvive(final BlockState byj, final LevelReader bjz, final BlockPos fk) {
        final BlockPos fk2 = fk.below();
        final BlockState byj2 = bjz.getBlockState(fk2);
        return byj2.isFaceSturdy(bjz, fk2, Direction.UP) || byj2.getBlock() == Blocks.HOPPER;
    }
    
    private BlockState updatePowerStrength(final Level bjw, final BlockPos fk, BlockState byj) {
        byj = this.updatePowerStrengthImpl(bjw, fk, byj);
        final List<BlockPos> list5 = Lists.newArrayList(this.toUpdate);
        this.toUpdate.clear();
        for (final BlockPos fk2 : list5) {
            bjw.updateNeighborsAt(fk2, this);
        }
        return byj;
    }
    
    private BlockState updatePowerStrengthImpl(final Level bjw, final BlockPos fk, BlockState byj) {
        final BlockState byj2 = byj;
        final int integer6 = byj2.<Integer>getValue((Property<Integer>)RedStoneWireBlock.POWER);
        this.shouldSignal = false;
        final int integer7 = bjw.getBestNeighborSignal(fk);
        this.shouldSignal = true;
        int integer8 = 0;
        if (integer7 < 15) {
            for (final Direction fp10 : Direction.Plane.HORIZONTAL) {
                final BlockPos fk2 = fk.relative(fp10);
                final BlockState byj3 = bjw.getBlockState(fk2);
                integer8 = this.checkTarget(integer8, byj3);
                final BlockPos fk3 = fk.above();
                if (byj3.isRedstoneConductor(bjw, fk2) && !bjw.getBlockState(fk3).isRedstoneConductor(bjw, fk3)) {
                    integer8 = this.checkTarget(integer8, bjw.getBlockState(fk2.above()));
                }
                else {
                    if (byj3.isRedstoneConductor(bjw, fk2)) {
                        continue;
                    }
                    integer8 = this.checkTarget(integer8, bjw.getBlockState(fk2.below()));
                }
            }
        }
        int integer9 = integer8 - 1;
        if (integer7 > integer9) {
            integer9 = integer7;
        }
        if (integer6 != integer9) {
            byj = ((AbstractStateHolder<O, BlockState>)byj).<Comparable, Integer>setValue((Property<Comparable>)RedStoneWireBlock.POWER, integer9);
            if (bjw.getBlockState(fk) == byj2) {
                bjw.setBlock(fk, byj, 2);
            }
            this.toUpdate.add(fk);
            for (final Direction fp11 : Direction.values()) {
                this.toUpdate.add(fk.relative(fp11));
            }
        }
        return byj;
    }
    
    private void checkCornerChangeAt(final Level bjw, final BlockPos fk) {
        if (bjw.getBlockState(fk).getBlock() != this) {
            return;
        }
        bjw.updateNeighborsAt(fk, this);
        for (final Direction fp7 : Direction.values()) {
            bjw.updateNeighborsAt(fk.relative(fp7), this);
        }
    }
    
    @Override
    public void onPlace(final BlockState byj1, final Level bjw, final BlockPos fk, final BlockState byj4, final boolean boolean5) {
        if (byj4.getBlock() == byj1.getBlock() || bjw.isClientSide) {
            return;
        }
        this.updatePowerStrength(bjw, fk, byj1);
        for (final Direction fp8 : Direction.Plane.VERTICAL) {
            bjw.updateNeighborsAt(fk.relative(fp8), this);
        }
        for (final Direction fp8 : Direction.Plane.HORIZONTAL) {
            this.checkCornerChangeAt(bjw, fk.relative(fp8));
        }
        for (final Direction fp8 : Direction.Plane.HORIZONTAL) {
            final BlockPos fk2 = fk.relative(fp8);
            if (bjw.getBlockState(fk2).isRedstoneConductor(bjw, fk2)) {
                this.checkCornerChangeAt(bjw, fk2.above());
            }
            else {
                this.checkCornerChangeAt(bjw, fk2.below());
            }
        }
    }
    
    @Override
    public void onRemove(final BlockState byj1, final Level bjw, final BlockPos fk, final BlockState byj4, final boolean boolean5) {
        if (boolean5 || byj1.getBlock() == byj4.getBlock()) {
            return;
        }
        super.onRemove(byj1, bjw, fk, byj4, boolean5);
        if (bjw.isClientSide) {
            return;
        }
        for (final Direction fp10 : Direction.values()) {
            bjw.updateNeighborsAt(fk.relative(fp10), this);
        }
        this.updatePowerStrength(bjw, fk, byj1);
        for (final Direction fp11 : Direction.Plane.HORIZONTAL) {
            this.checkCornerChangeAt(bjw, fk.relative(fp11));
        }
        for (final Direction fp11 : Direction.Plane.HORIZONTAL) {
            final BlockPos fk2 = fk.relative(fp11);
            if (bjw.getBlockState(fk2).isRedstoneConductor(bjw, fk2)) {
                this.checkCornerChangeAt(bjw, fk2.above());
            }
            else {
                this.checkCornerChangeAt(bjw, fk2.below());
            }
        }
    }
    
    private int checkTarget(final int integer, final BlockState byj) {
        if (byj.getBlock() != this) {
            return integer;
        }
        final int integer2 = byj.<Integer>getValue((Property<Integer>)RedStoneWireBlock.POWER);
        if (integer2 > integer) {
            return integer2;
        }
        return integer;
    }
    
    @Override
    public void neighborChanged(final BlockState byj, final Level bjw, final BlockPos fk3, final Block bph, final BlockPos fk5, final boolean boolean6) {
        if (bjw.isClientSide) {
            return;
        }
        if (byj.canSurvive(bjw, fk3)) {
            this.updatePowerStrength(bjw, fk3, byj);
        }
        else {
            Block.dropResources(byj, bjw, fk3);
            bjw.removeBlock(fk3, false);
        }
    }
    
    @Override
    public int getDirectSignal(final BlockState byj, final BlockGetter bjg, final BlockPos fk, final Direction fp) {
        if (!this.shouldSignal) {
            return 0;
        }
        return byj.getSignal(bjg, fk, fp);
    }
    
    @Override
    public int getSignal(final BlockState byj, final BlockGetter bjg, final BlockPos fk, final Direction fp) {
        if (!this.shouldSignal) {
            return 0;
        }
        final int integer6 = byj.<Integer>getValue((Property<Integer>)RedStoneWireBlock.POWER);
        if (integer6 == 0) {
            return 0;
        }
        if (fp == Direction.UP) {
            return integer6;
        }
        final EnumSet<Direction> enumSet7 = EnumSet.<Direction>noneOf(Direction.class);
        for (final Direction fp2 : Direction.Plane.HORIZONTAL) {
            if (this.isPowerSourceAt(bjg, fk, fp2)) {
                enumSet7.add(fp2);
            }
        }
        if (fp.getAxis().isHorizontal() && enumSet7.isEmpty()) {
            return integer6;
        }
        if (enumSet7.contains(fp) && !enumSet7.contains(fp.getCounterClockWise()) && !enumSet7.contains(fp.getClockWise())) {
            return integer6;
        }
        return 0;
    }
    
    private boolean isPowerSourceAt(final BlockGetter bjg, final BlockPos fk, final Direction fp) {
        final BlockPos fk2 = fk.relative(fp);
        final BlockState byj6 = bjg.getBlockState(fk2);
        final boolean boolean7 = byj6.isRedstoneConductor(bjg, fk2);
        final BlockPos fk3 = fk.above();
        final boolean boolean8 = bjg.getBlockState(fk3).isRedstoneConductor(bjg, fk3);
        return (!boolean8 && boolean7 && shouldConnectTo(bjg, fk2.above())) || shouldConnectTo(byj6, fp) || (byj6.getBlock() == Blocks.REPEATER && byj6.<Boolean>getValue((Property<Boolean>)DiodeBlock.POWERED) && byj6.<Comparable>getValue((Property<Comparable>)DiodeBlock.FACING) == fp) || (!boolean7 && shouldConnectTo(bjg, fk2.below()));
    }
    
    protected static boolean shouldConnectTo(final BlockGetter bjg, final BlockPos fk) {
        return shouldConnectTo(bjg.getBlockState(fk));
    }
    
    protected static boolean shouldConnectTo(final BlockState byj) {
        return shouldConnectTo(byj, null);
    }
    
    protected static boolean shouldConnectTo(final BlockState byj, @Nullable final Direction fp) {
        final Block bph3 = byj.getBlock();
        if (bph3 == Blocks.REDSTONE_WIRE) {
            return true;
        }
        if (byj.getBlock() == Blocks.REPEATER) {
            final Direction fp2 = byj.<Direction>getValue((Property<Direction>)RepeaterBlock.FACING);
            return fp2 == fp || fp2.getOpposite() == fp;
        }
        if (Blocks.OBSERVER == byj.getBlock()) {
            return fp == byj.<Direction>getValue((Property<Direction>)ObserverBlock.FACING);
        }
        return byj.isSignalSource() && fp != null;
    }
    
    @Override
    public boolean isSignalSource(final BlockState byj) {
        return this.shouldSignal;
    }
    
    public static int getColorForData(final int integer) {
        final float float2 = integer / 15.0f;
        float float3 = float2 * 0.6f + 0.4f;
        if (integer == 0) {
            float3 = 0.3f;
        }
        float float4 = float2 * float2 * 0.7f - 0.5f;
        float float5 = float2 * float2 * 0.6f - 0.7f;
        if (float4 < 0.0f) {
            float4 = 0.0f;
        }
        if (float5 < 0.0f) {
            float5 = 0.0f;
        }
        final int integer2 = Mth.clamp((int)(float3 * 255.0f), 0, 255);
        final int integer3 = Mth.clamp((int)(float4 * 255.0f), 0, 255);
        final int integer4 = Mth.clamp((int)(float5 * 255.0f), 0, 255);
        return 0xFF000000 | integer2 << 16 | integer3 << 8 | integer4;
    }
    
    @Override
    public void animateTick(final BlockState byj, final Level bjw, final BlockPos fk, final Random random) {
        final int integer6 = byj.<Integer>getValue((Property<Integer>)RedStoneWireBlock.POWER);
        if (integer6 == 0) {
            return;
        }
        final double double7 = fk.getX() + 0.5 + (random.nextFloat() - 0.5) * 0.2;
        final double double8 = fk.getY() + 0.0625f;
        final double double9 = fk.getZ() + 0.5 + (random.nextFloat() - 0.5) * 0.2;
        final float float13 = integer6 / 15.0f;
        final float float14 = float13 * 0.6f + 0.4f;
        final float float15 = Math.max(0.0f, float13 * float13 * 0.7f - 0.5f);
        final float float16 = Math.max(0.0f, float13 * float13 * 0.6f - 0.7f);
        bjw.addParticle(new DustParticleOptions(float14, float15, float16, 1.0f), double7, double8, double9, 0.0, 0.0, 0.0);
    }
    
    @Override
    public BlockState rotate(final BlockState byj, final Rotation btu) {
        switch (btu) {
            case CLOCKWISE_180: {
                return (((((AbstractStateHolder<O, BlockState>)byj).setValue(RedStoneWireBlock.NORTH, (Comparable)byj.<V>getValue((Property<V>)RedStoneWireBlock.SOUTH))).setValue(RedStoneWireBlock.EAST, (Comparable)byj.<V>getValue((Property<V>)RedStoneWireBlock.WEST))).setValue(RedStoneWireBlock.SOUTH, (Comparable)byj.<V>getValue((Property<V>)RedStoneWireBlock.NORTH))).<RedstoneSide, Comparable>setValue(RedStoneWireBlock.WEST, (Comparable)byj.<V>getValue((Property<V>)RedStoneWireBlock.EAST));
            }
            case COUNTERCLOCKWISE_90: {
                return (((((AbstractStateHolder<O, BlockState>)byj).setValue(RedStoneWireBlock.NORTH, (Comparable)byj.<V>getValue((Property<V>)RedStoneWireBlock.EAST))).setValue(RedStoneWireBlock.EAST, (Comparable)byj.<V>getValue((Property<V>)RedStoneWireBlock.SOUTH))).setValue(RedStoneWireBlock.SOUTH, (Comparable)byj.<V>getValue((Property<V>)RedStoneWireBlock.WEST))).<RedstoneSide, Comparable>setValue(RedStoneWireBlock.WEST, (Comparable)byj.<V>getValue((Property<V>)RedStoneWireBlock.NORTH));
            }
            case CLOCKWISE_90: {
                return (((((AbstractStateHolder<O, BlockState>)byj).setValue(RedStoneWireBlock.NORTH, (Comparable)byj.<V>getValue((Property<V>)RedStoneWireBlock.WEST))).setValue(RedStoneWireBlock.EAST, (Comparable)byj.<V>getValue((Property<V>)RedStoneWireBlock.NORTH))).setValue(RedStoneWireBlock.SOUTH, (Comparable)byj.<V>getValue((Property<V>)RedStoneWireBlock.EAST))).<RedstoneSide, Comparable>setValue(RedStoneWireBlock.WEST, (Comparable)byj.<V>getValue((Property<V>)RedStoneWireBlock.SOUTH));
            }
            default: {
                return byj;
            }
        }
    }
    
    @Override
    public BlockState mirror(final BlockState byj, final Mirror bsu) {
        switch (bsu) {
            case LEFT_RIGHT: {
                return (((AbstractStateHolder<O, BlockState>)byj).setValue(RedStoneWireBlock.NORTH, (Comparable)byj.<V>getValue((Property<V>)RedStoneWireBlock.SOUTH))).<RedstoneSide, Comparable>setValue(RedStoneWireBlock.SOUTH, (Comparable)byj.<V>getValue((Property<V>)RedStoneWireBlock.NORTH));
            }
            case FRONT_BACK: {
                return (((AbstractStateHolder<O, BlockState>)byj).setValue(RedStoneWireBlock.EAST, (Comparable)byj.<V>getValue((Property<V>)RedStoneWireBlock.WEST))).<RedstoneSide, Comparable>setValue(RedStoneWireBlock.WEST, (Comparable)byj.<V>getValue((Property<V>)RedStoneWireBlock.EAST));
            }
            default: {
                return super.mirror(byj, bsu);
            }
        }
    }
    
    @Override
    protected void createBlockStateDefinition(final StateDefinition.Builder<Block, BlockState> a) {
        a.add(RedStoneWireBlock.NORTH, RedStoneWireBlock.EAST, RedStoneWireBlock.SOUTH, RedStoneWireBlock.WEST, RedStoneWireBlock.POWER);
    }
    
    static {
        NORTH = BlockStateProperties.NORTH_REDSTONE;
        EAST = BlockStateProperties.EAST_REDSTONE;
        SOUTH = BlockStateProperties.SOUTH_REDSTONE;
        WEST = BlockStateProperties.WEST_REDSTONE;
        POWER = BlockStateProperties.POWER;
        PROPERTY_BY_DIRECTION = Maps.<Direction, Object>newEnumMap(ImmutableMap.<Direction, EnumProperty<RedstoneSide>>of(Direction.NORTH, RedStoneWireBlock.NORTH, Direction.EAST, RedStoneWireBlock.EAST, Direction.SOUTH, RedStoneWireBlock.SOUTH, Direction.WEST, RedStoneWireBlock.WEST));
        SHAPE_BY_INDEX = new VoxelShape[] { Block.box(3.0, 0.0, 3.0, 13.0, 1.0, 13.0), Block.box(3.0, 0.0, 3.0, 13.0, 1.0, 16.0), Block.box(0.0, 0.0, 3.0, 13.0, 1.0, 13.0), Block.box(0.0, 0.0, 3.0, 13.0, 1.0, 16.0), Block.box(3.0, 0.0, 0.0, 13.0, 1.0, 13.0), Block.box(3.0, 0.0, 0.0, 13.0, 1.0, 16.0), Block.box(0.0, 0.0, 0.0, 13.0, 1.0, 13.0), Block.box(0.0, 0.0, 0.0, 13.0, 1.0, 16.0), Block.box(3.0, 0.0, 3.0, 16.0, 1.0, 13.0), Block.box(3.0, 0.0, 3.0, 16.0, 1.0, 16.0), Block.box(0.0, 0.0, 3.0, 16.0, 1.0, 13.0), Block.box(0.0, 0.0, 3.0, 16.0, 1.0, 16.0), Block.box(3.0, 0.0, 0.0, 16.0, 1.0, 13.0), Block.box(3.0, 0.0, 0.0, 16.0, 1.0, 16.0), Block.box(0.0, 0.0, 0.0, 16.0, 1.0, 13.0), Block.box(0.0, 0.0, 0.0, 16.0, 1.0, 16.0) };
    }
}
