net.minecraft.server.BlockStairs Maven / Gradle / Ivy

Go to download
package net.minecraft.server;

import com.google.common.base.Predicate;

import java.util.Arrays;
import java.util.List;
import java.util.Random;

public class BlockStairs extends Block {

  public static final BlockStateDirection FACING = BlockStateDirection.of("facing", EnumDirection.EnumDirectionLimit.HORIZONTAL);
  public static final BlockStateEnum HALF = BlockStateEnum.of("half", EnumHalf.class);
  public static final BlockStateEnum SHAPE = BlockStateEnum.of("shape", EnumStairShape.class);
  private static final int[][] O = new int[][]{{4, 5}, {5, 7}, {6, 7}, {4, 6}, {0, 1}, {1, 3}, {2, 3}, {0, 2}};
  private final Block P;
  private final IBlockData Q;
  private boolean R;
  private int S;

  protected BlockStairs(IBlockData iblockdata) {
    super(iblockdata.getBlock().material);
    this.j(this.blockStateList.getBlockData().set(BlockStairs.FACING, EnumDirection.NORTH).set(BlockStairs.HALF, EnumHalf.BOTTOM).set(BlockStairs.SHAPE, EnumStairShape.STRAIGHT));
    this.P = iblockdata.getBlock();
    this.Q = iblockdata;
    this.c(this.P.strength);
    this.b(this.P.durability / 3.0F);
    this.a(this.P.stepSound);
    this.e(255);
    this.a(CreativeModeTab.b);
  }

  public static boolean c(Block block) {
    return block instanceof BlockStairs;
  }

  public static boolean a(IBlockAccess iblockaccess, BlockPosition blockposition, IBlockData iblockdata) {
    IBlockData iblockdata1 = iblockaccess.getType(blockposition);
    Block block = iblockdata1.getBlock();

    return c(block) && iblockdata1.get(BlockStairs.HALF) == iblockdata.get(BlockStairs.HALF) && iblockdata1.get(BlockStairs.FACING) == iblockdata.get(BlockStairs.FACING);
  }

  public void updateShape(IBlockAccess iblockaccess, BlockPosition blockposition) {
    if (this.R) {
      this.a(0.5F * (float) (this.S % 2), 0.5F * (float) (this.S / 4 % 2), 0.5F * (float) (this.S / 2 % 2), 0.5F + 0.5F * (float) (this.S % 2), 0.5F + 0.5F * (float) (this.S / 4 % 2), 0.5F + 0.5F * (float) (this.S / 2 % 2));
    } else {
      this.a(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
    }

  }

  public boolean c() {
    return false;
  }

  public boolean d() {
    return false;
  }

  public void e(IBlockAccess iblockaccess, BlockPosition blockposition) {
    if (iblockaccess.getType(blockposition).get(BlockStairs.HALF) == EnumHalf.TOP) {
      this.a(0.0F, 0.5F, 0.0F, 1.0F, 1.0F, 1.0F);
    } else {
      this.a(0.0F, 0.0F, 0.0F, 1.0F, 0.5F, 1.0F);
    }

  }

  public int f(IBlockAccess iblockaccess, BlockPosition blockposition) {
    IBlockData iblockdata = iblockaccess.getType(blockposition);
    EnumDirection enumdirection = iblockdata.get(BlockStairs.FACING);
    EnumHalf blockstairs_enumhalf = iblockdata.get(BlockStairs.HALF);
    boolean flag = blockstairs_enumhalf == EnumHalf.TOP;
    IBlockData iblockdata1;
    Block block;
    EnumDirection enumdirection1;

    if (enumdirection == EnumDirection.EAST) {
      iblockdata1 = iblockaccess.getType(blockposition.east());
      block = iblockdata1.getBlock();
      if (c(block) && blockstairs_enumhalf == iblockdata1.get(BlockStairs.HALF)) {
        enumdirection1 = iblockdata1.get(BlockStairs.FACING);
        if (enumdirection1 == EnumDirection.NORTH && !a(iblockaccess, blockposition.south(), iblockdata)) {
          return flag ? 1 : 2;
        }

        if (enumdirection1 == EnumDirection.SOUTH && !a(iblockaccess, blockposition.north(), iblockdata)) {
          return flag ? 2 : 1;
        }
      }
    } else if (enumdirection == EnumDirection.WEST) {
      iblockdata1 = iblockaccess.getType(blockposition.west());
      block = iblockdata1.getBlock();
      if (c(block) && blockstairs_enumhalf == iblockdata1.get(BlockStairs.HALF)) {
        enumdirection1 = iblockdata1.get(BlockStairs.FACING);
        if (enumdirection1 == EnumDirection.NORTH && !a(iblockaccess, blockposition.south(), iblockdata)) {
          return flag ? 2 : 1;
        }

        if (enumdirection1 == EnumDirection.SOUTH && !a(iblockaccess, blockposition.north(), iblockdata)) {
          return flag ? 1 : 2;
        }
      }
    } else if (enumdirection == EnumDirection.SOUTH) {
      iblockdata1 = iblockaccess.getType(blockposition.south());
      block = iblockdata1.getBlock();
      if (c(block) && blockstairs_enumhalf == iblockdata1.get(BlockStairs.HALF)) {
        enumdirection1 = iblockdata1.get(BlockStairs.FACING);
        if (enumdirection1 == EnumDirection.WEST && !a(iblockaccess, blockposition.east(), iblockdata)) {
          return flag ? 2 : 1;
        }

        if (enumdirection1 == EnumDirection.EAST && !a(iblockaccess, blockposition.west(), iblockdata)) {
          return flag ? 1 : 2;
        }
      }
    } else if (enumdirection == EnumDirection.NORTH) {
      iblockdata1 = iblockaccess.getType(blockposition.north());
      block = iblockdata1.getBlock();
      if (c(block) && blockstairs_enumhalf == iblockdata1.get(BlockStairs.HALF)) {
        enumdirection1 = iblockdata1.get(BlockStairs.FACING);
        if (enumdirection1 == EnumDirection.WEST && !a(iblockaccess, blockposition.east(), iblockdata)) {
          return flag ? 1 : 2;
        }

        if (enumdirection1 == EnumDirection.EAST && !a(iblockaccess, blockposition.west(), iblockdata)) {
          return flag ? 2 : 1;
        }
      }
    }

    return 0;
  }

  public int g(IBlockAccess iblockaccess, BlockPosition blockposition) {
    IBlockData iblockdata = iblockaccess.getType(blockposition);
    EnumDirection enumdirection = iblockdata.get(BlockStairs.FACING);
    EnumHalf blockstairs_enumhalf = iblockdata.get(BlockStairs.HALF);
    boolean flag = blockstairs_enumhalf == EnumHalf.TOP;
    IBlockData iblockdata1;
    Block block;
    EnumDirection enumdirection1;

    if (enumdirection == EnumDirection.EAST) {
      iblockdata1 = iblockaccess.getType(blockposition.west());
      block = iblockdata1.getBlock();
      if (c(block) && blockstairs_enumhalf == iblockdata1.get(BlockStairs.HALF)) {
        enumdirection1 = iblockdata1.get(BlockStairs.FACING);
        if (enumdirection1 == EnumDirection.NORTH && !a(iblockaccess, blockposition.north(), iblockdata)) {
          return flag ? 1 : 2;
        }

        if (enumdirection1 == EnumDirection.SOUTH && !a(iblockaccess, blockposition.south(), iblockdata)) {
          return flag ? 2 : 1;
        }
      }
    } else if (enumdirection == EnumDirection.WEST) {
      iblockdata1 = iblockaccess.getType(blockposition.east());
      block = iblockdata1.getBlock();
      if (c(block) && blockstairs_enumhalf == iblockdata1.get(BlockStairs.HALF)) {
        enumdirection1 = iblockdata1.get(BlockStairs.FACING);
        if (enumdirection1 == EnumDirection.NORTH && !a(iblockaccess, blockposition.north(), iblockdata)) {
          return flag ? 2 : 1;
        }

        if (enumdirection1 == EnumDirection.SOUTH && !a(iblockaccess, blockposition.south(), iblockdata)) {
          return flag ? 1 : 2;
        }
      }
    } else if (enumdirection == EnumDirection.SOUTH) {
      iblockdata1 = iblockaccess.getType(blockposition.north());
      block = iblockdata1.getBlock();
      if (c(block) && blockstairs_enumhalf == iblockdata1.get(BlockStairs.HALF)) {
        enumdirection1 = iblockdata1.get(BlockStairs.FACING);
        if (enumdirection1 == EnumDirection.WEST && !a(iblockaccess, blockposition.west(), iblockdata)) {
          return flag ? 2 : 1;
        }

        if (enumdirection1 == EnumDirection.EAST && !a(iblockaccess, blockposition.east(), iblockdata)) {
          return flag ? 1 : 2;
        }
      }
    } else if (enumdirection == EnumDirection.NORTH) {
      iblockdata1 = iblockaccess.getType(blockposition.south());
      block = iblockdata1.getBlock();
      if (c(block) && blockstairs_enumhalf == iblockdata1.get(BlockStairs.HALF)) {
        enumdirection1 = iblockdata1.get(BlockStairs.FACING);
        if (enumdirection1 == EnumDirection.WEST && !a(iblockaccess, blockposition.west(), iblockdata)) {
          return flag ? 1 : 2;
        }

        if (enumdirection1 == EnumDirection.EAST && !a(iblockaccess, blockposition.east(), iblockdata)) {
          return flag ? 2 : 1;
        }
      }
    }

    return 0;
  }

  public boolean h(IBlockAccess iblockaccess, BlockPosition blockposition) {
    IBlockData iblockdata = iblockaccess.getType(blockposition);
    EnumDirection enumdirection = iblockdata.get(BlockStairs.FACING);
    EnumHalf blockstairs_enumhalf = iblockdata.get(BlockStairs.HALF);
    boolean flag = blockstairs_enumhalf == EnumHalf.TOP;
    float f = 0.5F;
    float f1 = 1.0F;

    if (flag) {
      f = 0.0F;
      f1 = 0.5F;
    }

    float f2 = 0.0F;
    float f3 = 1.0F;
    float f4 = 0.0F;
    float f5 = 0.5F;
    boolean flag1 = true;
    IBlockData iblockdata1;
    Block block;
    EnumDirection enumdirection1;

    if (enumdirection == EnumDirection.EAST) {
      f2 = 0.5F;
      f5 = 1.0F;
      iblockdata1 = iblockaccess.getType(blockposition.east());
      block = iblockdata1.getBlock();
      if (c(block) && blockstairs_enumhalf == iblockdata1.get(BlockStairs.HALF)) {
        enumdirection1 = iblockdata1.get(BlockStairs.FACING);
        if (enumdirection1 == EnumDirection.NORTH && !a(iblockaccess, blockposition.south(), iblockdata)) {
          f5 = 0.5F;
          flag1 = false;
        } else if (enumdirection1 == EnumDirection.SOUTH && !a(iblockaccess, blockposition.north(), iblockdata)) {
          f4 = 0.5F;
          flag1 = false;
        }
      }
    } else if (enumdirection == EnumDirection.WEST) {
      f3 = 0.5F;
      f5 = 1.0F;
      iblockdata1 = iblockaccess.getType(blockposition.west());
      block = iblockdata1.getBlock();
      if (c(block) && blockstairs_enumhalf == iblockdata1.get(BlockStairs.HALF)) {
        enumdirection1 = iblockdata1.get(BlockStairs.FACING);
        if (enumdirection1 == EnumDirection.NORTH && !a(iblockaccess, blockposition.south(), iblockdata)) {
          f5 = 0.5F;
          flag1 = false;
        } else if (enumdirection1 == EnumDirection.SOUTH && !a(iblockaccess, blockposition.north(), iblockdata)) {
          f4 = 0.5F;
          flag1 = false;
        }
      }
    } else if (enumdirection == EnumDirection.SOUTH) {
      f4 = 0.5F;
      f5 = 1.0F;
      iblockdata1 = iblockaccess.getType(blockposition.south());
      block = iblockdata1.getBlock();
      if (c(block) && blockstairs_enumhalf == iblockdata1.get(BlockStairs.HALF)) {
        enumdirection1 = iblockdata1.get(BlockStairs.FACING);
        if (enumdirection1 == EnumDirection.WEST && !a(iblockaccess, blockposition.east(), iblockdata)) {
          f3 = 0.5F;
          flag1 = false;
        } else if (enumdirection1 == EnumDirection.EAST && !a(iblockaccess, blockposition.west(), iblockdata)) {
          f2 = 0.5F;
          flag1 = false;
        }
      }
    } else if (enumdirection == EnumDirection.NORTH) {
      iblockdata1 = iblockaccess.getType(blockposition.north());
      block = iblockdata1.getBlock();
      if (c(block) && blockstairs_enumhalf == iblockdata1.get(BlockStairs.HALF)) {
        enumdirection1 = iblockdata1.get(BlockStairs.FACING);
        if (enumdirection1 == EnumDirection.WEST && !a(iblockaccess, blockposition.east(), iblockdata)) {
          f3 = 0.5F;
          flag1 = false;
        } else if (enumdirection1 == EnumDirection.EAST && !a(iblockaccess, blockposition.west(), iblockdata)) {
          f2 = 0.5F;
          flag1 = false;
        }
      }
    }

    this.a(f2, f, f4, f3, f1, f5);
    return flag1;
  }

  public boolean i(IBlockAccess iblockaccess, BlockPosition blockposition) {
    IBlockData iblockdata = iblockaccess.getType(blockposition);
    EnumDirection enumdirection = iblockdata.get(BlockStairs.FACING);
    EnumHalf blockstairs_enumhalf = iblockdata.get(BlockStairs.HALF);
    boolean flag = blockstairs_enumhalf == EnumHalf.TOP;
    float f = 0.5F;
    float f1 = 1.0F;

    if (flag) {
      f = 0.0F;
      f1 = 0.5F;
    }

    float f2 = 0.0F;
    float f3 = 0.5F;
    float f4 = 0.5F;
    float f5 = 1.0F;
    boolean flag1 = false;
    IBlockData iblockdata1;
    Block block;
    EnumDirection enumdirection1;

    if (enumdirection == EnumDirection.EAST) {
      iblockdata1 = iblockaccess.getType(blockposition.west());
      block = iblockdata1.getBlock();
      if (c(block) && blockstairs_enumhalf == iblockdata1.get(BlockStairs.HALF)) {
        enumdirection1 = iblockdata1.get(BlockStairs.FACING);
        if (enumdirection1 == EnumDirection.NORTH && !a(iblockaccess, blockposition.north(), iblockdata)) {
          f4 = 0.0F;
          f5 = 0.5F;
          flag1 = true;
        } else if (enumdirection1 == EnumDirection.SOUTH && !a(iblockaccess, blockposition.south(), iblockdata)) {
          f4 = 0.5F;
          f5 = 1.0F;
          flag1 = true;
        }
      }
    } else if (enumdirection == EnumDirection.WEST) {
      iblockdata1 = iblockaccess.getType(blockposition.east());
      block = iblockdata1.getBlock();
      if (c(block) && blockstairs_enumhalf == iblockdata1.get(BlockStairs.HALF)) {
        f2 = 0.5F;
        f3 = 1.0F;
        enumdirection1 = iblockdata1.get(BlockStairs.FACING);
        if (enumdirection1 == EnumDirection.NORTH && !a(iblockaccess, blockposition.north(), iblockdata)) {
          f4 = 0.0F;
          f5 = 0.5F;
          flag1 = true;
        } else if (enumdirection1 == EnumDirection.SOUTH && !a(iblockaccess, blockposition.south(), iblockdata)) {
          f4 = 0.5F;
          f5 = 1.0F;
          flag1 = true;
        }
      }
    } else if (enumdirection == EnumDirection.SOUTH) {
      iblockdata1 = iblockaccess.getType(blockposition.north());
      block = iblockdata1.getBlock();
      if (c(block) && blockstairs_enumhalf == iblockdata1.get(BlockStairs.HALF)) {
        f4 = 0.0F;
        f5 = 0.5F;
        enumdirection1 = iblockdata1.get(BlockStairs.FACING);
        if (enumdirection1 == EnumDirection.WEST && !a(iblockaccess, blockposition.west(), iblockdata)) {
          flag1 = true;
        } else if (enumdirection1 == EnumDirection.EAST && !a(iblockaccess, blockposition.east(), iblockdata)) {
          f2 = 0.5F;
          f3 = 1.0F;
          flag1 = true;
        }
      }
    } else if (enumdirection == EnumDirection.NORTH) {
      iblockdata1 = iblockaccess.getType(blockposition.south());
      block = iblockdata1.getBlock();
      if (c(block) && blockstairs_enumhalf == iblockdata1.get(BlockStairs.HALF)) {
        enumdirection1 = iblockdata1.get(BlockStairs.FACING);
        if (enumdirection1 == EnumDirection.WEST && !a(iblockaccess, blockposition.west(), iblockdata)) {
          flag1 = true;
        } else if (enumdirection1 == EnumDirection.EAST && !a(iblockaccess, blockposition.east(), iblockdata)) {
          f2 = 0.5F;
          f3 = 1.0F;
          flag1 = true;
        }
      }
    }

    if (flag1) {
      this.a(f2, f, f4, f3, f1, f5);
    }

    return flag1;
  }

  public void a(World world, BlockPosition blockposition, IBlockData iblockdata, AxisAlignedBB axisalignedbb, List list, Entity entity) {
    this.e(world, blockposition);
    super.a(world, blockposition, iblockdata, axisalignedbb, list, entity);
    boolean flag = this.h(world, blockposition);

    super.a(world, blockposition, iblockdata, axisalignedbb, list, entity);
    if (flag && this.i(world, blockposition)) {
      super.a(world, blockposition, iblockdata, axisalignedbb, list, entity);
    }

    this.a(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
  }

  public void attack(World world, BlockPosition blockposition, EntityHuman entityhuman) {
    this.P.attack(world, blockposition, entityhuman);
  }

  public void postBreak(World world, BlockPosition blockposition, IBlockData iblockdata) {
    this.P.postBreak(world, blockposition, iblockdata);
  }

  public float a(Entity entity) {
    return this.P.a(entity);
  }

  public int a(World world) {
    return this.P.a(world);
  }

  public Vec3D a(World world, BlockPosition blockposition, Entity entity, Vec3D vec3d) {
    return this.P.a(world, blockposition, entity, vec3d);
  }

  public boolean A() {
    return this.P.A();
  }

  public boolean a(IBlockData iblockdata, boolean flag) {
    return this.P.a(iblockdata, flag);
  }

  public boolean canPlace(World world, BlockPosition blockposition) {
    return this.P.canPlace(world, blockposition);
  }

  public void onPlace(World world, BlockPosition blockposition, IBlockData iblockdata) {
    this.doPhysics(world, blockposition, this.Q, Blocks.AIR);
    this.P.onPlace(world, blockposition, this.Q);
  }

  public void remove(World world, BlockPosition blockposition, IBlockData iblockdata) {
    this.P.remove(world, blockposition, this.Q);
  }

  public void a(World world, BlockPosition blockposition, Entity entity) {
    this.P.a(world, blockposition, entity);
  }

  public void b(World world, BlockPosition blockposition, IBlockData iblockdata, Random random) {
    this.P.b(world, blockposition, iblockdata, random);
  }

  public boolean interact(World world, BlockPosition blockposition, IBlockData iblockdata, EntityHuman entityhuman, EnumDirection enumdirection, float f, float f1, float f2) {
    return this.P.interact(world, blockposition, this.Q, entityhuman, EnumDirection.DOWN, 0.0F, 0.0F, 0.0F);
  }

  public void wasExploded(World world, BlockPosition blockposition, Explosion explosion) {
    this.P.wasExploded(world, blockposition, explosion);
  }

  public MaterialMapColor g(IBlockData iblockdata) {
    return this.P.g(this.Q);
  }

  public IBlockData getPlacedState(World world, BlockPosition blockposition, EnumDirection enumdirection, float f, float f1, float f2, int i, EntityLiving entityliving) {
    IBlockData iblockdata = super.getPlacedState(world, blockposition, enumdirection, f, f1, f2, i, entityliving);

    iblockdata = iblockdata.set(BlockStairs.FACING, entityliving.getDirection()).set(BlockStairs.SHAPE, EnumStairShape.STRAIGHT);
    return enumdirection != EnumDirection.DOWN && (enumdirection == EnumDirection.UP || (double) f1 <= 0.5D) ? iblockdata.set(BlockStairs.HALF, EnumHalf.BOTTOM) : iblockdata.set(BlockStairs.HALF, EnumHalf.TOP);
  }

  public MovingObjectPosition a(World world, BlockPosition blockposition, Vec3D vec3d, Vec3D vec3d1) {
    MovingObjectPosition[] amovingobjectposition = new MovingObjectPosition[8];
    IBlockData iblockdata = world.getType(blockposition);
    int i = iblockdata.get(BlockStairs.FACING).b();
    boolean flag = iblockdata.get(BlockStairs.HALF) == EnumHalf.TOP;
    int[] aint = BlockStairs.O[i + (flag ? 4 : 0)];

    this.R = true;

    for (int j = 0; j < 8; ++j) {
      this.S = j;
      if (Arrays.binarySearch(aint, j) < 0) {
        amovingobjectposition[j] = super.a(world, blockposition, vec3d, vec3d1);
      }
    }

    int[] aint1 = aint;
    int k = aint.length;

    for (int l = 0; l < k; ++l) {
      int i1 = aint1[l];

      amovingobjectposition[i1] = null;
    }

    MovingObjectPosition movingobjectposition = null;
    double d0 = 0.0D;
    MovingObjectPosition[] amovingobjectposition1 = amovingobjectposition;
    int j1 = amovingobjectposition.length;

    for (int k1 = 0; k1 < j1; ++k1) {
      MovingObjectPosition movingobjectposition1 = amovingobjectposition1[k1];

      if (movingobjectposition1 != null) {
        double d1 = movingobjectposition1.pos.distanceSquared(vec3d1);

        if (d1 > d0) {
          movingobjectposition = movingobjectposition1;
          d0 = d1;
        }
      }
    }

    return movingobjectposition;
  }

  public IBlockData fromLegacyData(int i) {
    IBlockData iblockdata = this.getBlockData().set(BlockStairs.HALF, (i & 4) > 0 ? EnumHalf.TOP : EnumHalf.BOTTOM);

    iblockdata = iblockdata.set(BlockStairs.FACING, EnumDirection.fromType1(5 - (i & 3)));
    return iblockdata;
  }

  public int toLegacyData(IBlockData iblockdata) {
    int i = 0;

    if (iblockdata.get(BlockStairs.HALF) == EnumHalf.TOP) {
      i |= 4;
    }

    i |= 5 - iblockdata.get(BlockStairs.FACING).a();
    return i;
  }

  public IBlockData updateState(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
    if (this.h(iblockaccess, blockposition)) {
      switch (this.g(iblockaccess, blockposition)) {
        case 0:
          iblockdata = iblockdata.set(BlockStairs.SHAPE, EnumStairShape.STRAIGHT);
          break;

        case 1:
          iblockdata = iblockdata.set(BlockStairs.SHAPE, EnumStairShape.INNER_RIGHT);
          break;

        case 2:
          iblockdata = iblockdata.set(BlockStairs.SHAPE, EnumStairShape.INNER_LEFT);
      }
    } else {
      switch (this.f(iblockaccess, blockposition)) {
        case 0:
          iblockdata = iblockdata.set(BlockStairs.SHAPE, EnumStairShape.STRAIGHT);
          break;

        case 1:
          iblockdata = iblockdata.set(BlockStairs.SHAPE, EnumStairShape.OUTER_RIGHT);
          break;

        case 2:
          iblockdata = iblockdata.set(BlockStairs.SHAPE, EnumStairShape.OUTER_LEFT);
      }
    }

    return iblockdata;
  }

  protected BlockStateList getStateList() {
    return new BlockStateList(this, BlockStairs.FACING, BlockStairs.HALF, BlockStairs.SHAPE);
  }

  public enum EnumStairShape implements INamable {

    STRAIGHT("straight"), INNER_LEFT("inner_left"), INNER_RIGHT("inner_right"), OUTER_LEFT("outer_left"), OUTER_RIGHT("outer_right");

    private final String f;

    EnumStairShape(String s) {
      this.f = s;
    }

    public String toString() {
      return this.f;
    }

    public String getName() {
      return this.f;
    }
  }

  public enum EnumHalf implements INamable {

    TOP("top"), BOTTOM("bottom");

    private final String c;

    EnumHalf(String s) {
      this.c = s;
    }

    public String toString() {
      return this.c;
    }

    public String getName() {
      return this.c;
    }
  }
}