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

Go to download
package net.minecraft.server;

import org.bukkit.craftbukkit.event.CraftEventFactory;

import java.util.Iterator;
import java.util.Random;

public class BlockVine extends Block {

  public static final BlockStateBoolean UP = BlockStateBoolean.of("up");
  public static final BlockStateBoolean NORTH = BlockStateBoolean.of("north");
  public static final BlockStateBoolean EAST = BlockStateBoolean.of("east");
  public static final BlockStateBoolean SOUTH = BlockStateBoolean.of("south");
  public static final BlockStateBoolean WEST = BlockStateBoolean.of("west");
  public static final BlockStateBoolean[] Q = new BlockStateBoolean[]{BlockVine.UP, BlockVine.NORTH, BlockVine.SOUTH, BlockVine.WEST, BlockVine.EAST};

  public BlockVine() {
    super(Material.REPLACEABLE_PLANT);
    this.j(this.blockStateList.getBlockData().set(BlockVine.UP, Boolean.FALSE).set(BlockVine.NORTH, Boolean.FALSE).set(BlockVine.EAST, Boolean.FALSE).set(BlockVine.SOUTH, Boolean.FALSE).set(BlockVine.WEST, Boolean.FALSE));
    this.a(true);
    this.a(CreativeModeTab.c);
  }

  public static BlockStateBoolean getDirection(EnumDirection enumdirection) {
    switch (BlockVine.SyntheticClass_1.a[enumdirection.ordinal()]) {
      case 1:
        return BlockVine.UP;

      case 2:
        return BlockVine.NORTH;

      case 3:
        return BlockVine.SOUTH;

      case 4:
        return BlockVine.EAST;

      case 5:
        return BlockVine.WEST;

      default:
        throw new IllegalArgumentException(enumdirection + " is an invalid choice");
    }
  }

  public static int d(IBlockData iblockdata) {
    int i = 0;
    BlockStateBoolean[] ablockstateboolean = BlockVine.Q;
    int j = ablockstateboolean.length;

    for (BlockStateBoolean blockstateboolean : ablockstateboolean) {
      if (iblockdata.get(blockstateboolean)) {
        ++i;
      }
    }

    return i;
  }

  public IBlockData updateState(IBlockData iblockdata, IBlockAccess iblockaccess, BlockPosition blockposition) {
    return iblockdata.set(BlockVine.UP, iblockaccess.getType(blockposition.up()).getBlock().u());
  }

  public void j() {
    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 boolean a(World world, BlockPosition blockposition) {
    return true;
  }

  public void updateShape(IBlockAccess iblockaccess, BlockPosition blockposition) {
    float f = 0.0625F;
    float f1 = 1.0F;
    float f2 = 1.0F;
    float f3 = 1.0F;
    float f4 = 0.0F;
    float f5 = 0.0F;
    float f6 = 0.0F;
    boolean flag = false;

    if (iblockaccess.getType(blockposition).get(BlockVine.WEST)) {
      f4 = 0.0625F;
      f1 = 0.0F;
      f2 = 0.0F;
      f5 = 1.0F;
      f3 = 0.0F;
      f6 = 1.0F;
      flag = true;
    }

    if (iblockaccess.getType(blockposition).get(BlockVine.EAST)) {
      f1 = Math.min(f1, 0.9375F);
      f4 = 1.0F;
      f2 = 0.0F;
      f5 = 1.0F;
      f3 = 0.0F;
      f6 = 1.0F;
      flag = true;
    }

    if (iblockaccess.getType(blockposition).get(BlockVine.NORTH)) {
      f6 = Math.max(f6, 0.0625F);
      f3 = 0.0F;
      f1 = 0.0F;
      f4 = 1.0F;
      f2 = 0.0F;
      f5 = 1.0F;
      flag = true;
    }

    if (iblockaccess.getType(blockposition).get(BlockVine.SOUTH)) {
      f3 = Math.min(f3, 0.9375F);
      f6 = 1.0F;
      f1 = 0.0F;
      f4 = 1.0F;
      f2 = 0.0F;
      f5 = 1.0F;
      flag = true;
    }

    if (!flag && this.c(iblockaccess.getType(blockposition.up()).getBlock())) {
      f2 = 0.9375F;
      f5 = 1.0F;
      f1 = 0.0F;
      f4 = 1.0F;
      f3 = 0.0F;
      f6 = 1.0F;
    }

    this.a(f1, f2, f3, f4, f5, f6);
  }

  public AxisAlignedBB a(World world, BlockPosition blockposition, IBlockData iblockdata) {
    return null;
  }

  public boolean canPlace(World world, BlockPosition blockposition, EnumDirection enumdirection) {
    switch (BlockVine.SyntheticClass_1.a[enumdirection.ordinal()]) {
      case 1:
        return this.c(world.getType(blockposition.up()).getBlock());

      case 2:
      case 3:
      case 4:
      case 5:
        return this.c(world.getType(blockposition.shift(enumdirection.opposite())).getBlock());

      default:
        return false;
    }
  }

  private boolean c(Block block) {
    return block.d() && block.material.isSolid();
  }

  private boolean e(World world, BlockPosition blockposition, IBlockData iblockdata) {
    IBlockData iblockdata1 = iblockdata;

    for (EnumDirection enumdirection : EnumDirection.EnumDirectionLimit.HORIZONTAL) {
      BlockStateBoolean blockstateboolean = getDirection(enumdirection);

      if (iblockdata.get(blockstateboolean) && !this.c(world.getType(blockposition.shift(enumdirection)).getBlock())) {
        IBlockData iblockdata2 = world.getType(blockposition.up());

        if (iblockdata2.getBlock() != this || !iblockdata2.get(blockstateboolean)) {
          iblockdata = iblockdata.set(blockstateboolean, Boolean.FALSE);
        }
      }
    }

    if (d(iblockdata) == 0) {
      return false;
    } else {
      if (iblockdata1 != iblockdata) {
        world.setTypeAndData(blockposition, iblockdata, 2);
      }

      return true;
    }
  }

  public void doPhysics(World world, BlockPosition pos, IBlockData iblockdata, Block block) {
    if (!world.isClientSide && !this.e(world, pos, iblockdata)) {
      this.b(world, pos, iblockdata, 0);
      world.setAir(pos);
    }

  }

  public void b(World world, BlockPosition pos, IBlockData iblockdata, Random random) {
    if (!world.isClientSide) {
      if (world.random.nextInt(4) == 0) {
        byte b0 = 4;
        int i = 5;
        boolean flag = false;

        label188:
        for (int j = -b0; j <= b0; ++j) {
          for (int k = -b0; k <= b0; ++k) {
            for (int l = -1; l <= 1; ++l) {
              if (world.getType(pos.a(j, l, k)).getBlock() == this) {
                --i;
                if (i <= 0) {
                  flag = true;
                  break label188;
                }
              }
            }
          }
        }

        EnumDirection enumdirection = EnumDirection.a(random);
        BlockPosition blockposition1 = pos.up();
        EnumDirection enumdirection1;

        if (enumdirection == EnumDirection.UP && pos.getY() < 255 && world.isEmpty(blockposition1)) {
          if (!flag) {
            IBlockData iblockdata1 = iblockdata;

            for (EnumDirection enumDirection : EnumDirection.EnumDirectionLimit.HORIZONTAL) {
              enumdirection1 = enumDirection;
              if (random.nextBoolean() || !this.c(world.getType(blockposition1.shift(enumdirection1)).getBlock())) {
                iblockdata1 = iblockdata1.set(getDirection(enumdirection1), Boolean.FALSE);
              }
            }

            if (iblockdata1.get(BlockVine.NORTH) || iblockdata1.get(BlockVine.EAST) || iblockdata1.get(BlockVine.SOUTH) || iblockdata1.get(BlockVine.WEST)) {
              // CraftBukkit start - Call BlockSpreadEvent
              // world.setTypeAndData(blockposition1, iblockdata1, 2);
              org.bukkit.block.Block source = world.getWorld().getBlockAt(pos.getX(), pos.getY(), pos.getZ());
              org.bukkit.block.Block block = world.getWorld().getBlockAt(blockposition1.getX(), blockposition1.getY(), blockposition1.getZ());
              CraftEventFactory.handleBlockSpreadEvent(block, source, this, toLegacyData(iblockdata1));
              // CraftBukkit end
            }

          }
        } else {
          BlockPosition blockposition2;

          if (enumdirection.k().c() && !iblockdata.get(getDirection(enumdirection))) {
            if (!flag) {
              blockposition2 = pos.shift(enumdirection);
              Block block = world.getType(blockposition2).getBlock();

              if (block.material == Material.AIR) {
                enumdirection1 = enumdirection.e();
                EnumDirection enumdirection2 = enumdirection.f();
                boolean flag1 = iblockdata.get(getDirection(enumdirection1));
                boolean flag2 = iblockdata.get(getDirection(enumdirection2));
                BlockPosition blockposition3 = blockposition2.shift(enumdirection1);
                BlockPosition blockposition4 = blockposition2.shift(enumdirection2);

                // CraftBukkit start - Call BlockSpreadEvent
                org.bukkit.block.Block source = world.getWorld().getBlockAt(pos.getX(), pos.getY(), pos.getZ());
                org.bukkit.block.Block bukkitBlock = world.getWorld().getBlockAt(blockposition2.getX(), blockposition2.getY(), blockposition2.getZ());

                if (flag1 && this.c(world.getType(blockposition3).getBlock())) {
                  // world.setTypeAndData(blockposition2, this.getBlockData().set(a(enumdirection1), Boolean.valueOf(true)), 2);
                  CraftEventFactory.handleBlockSpreadEvent(bukkitBlock, source, this, toLegacyData(this.getBlockData().set(getDirection(enumdirection1), Boolean.TRUE)));
                } else if (flag2 && this.c(world.getType(blockposition4).getBlock())) {
                  // world.setTypeAndData(blockposition2, this.getBlockData().set(a(enumdirection2), Boolean.valueOf(true)), 2);
                  CraftEventFactory.handleBlockSpreadEvent(bukkitBlock, source, this, toLegacyData(this.getBlockData().set(getDirection(enumdirection2), Boolean.TRUE)));
                } else if (flag1 && world.isEmpty(blockposition3) && this.c(world.getType(pos.shift(enumdirection1)).getBlock())) {
                  // world.setTypeAndData(blockposition3, this.getBlockData().set(a(enumdirection.opposite()), Boolean.valueOf(true)), 2);
                  bukkitBlock = world.getWorld().getBlockAt(blockposition3.getX(), blockposition3.getY(), blockposition3.getZ());
                  CraftEventFactory.handleBlockSpreadEvent(bukkitBlock, source, this, toLegacyData(this.getBlockData().set(getDirection(enumdirection.opposite()), Boolean.TRUE)));
                } else if (flag2 && world.isEmpty(blockposition4) && this.c(world.getType(pos.shift(enumdirection2)).getBlock())) {
                  // world.setTypeAndData(blockposition4, this.getBlockData().set(a(enumdirection.opposite()), Boolean.valueOf(true)), 2);
                  bukkitBlock = world.getWorld().getBlockAt(blockposition4.getX(), blockposition4.getY(), blockposition4.getZ());
                  CraftEventFactory.handleBlockSpreadEvent(bukkitBlock, source, this, toLegacyData(this.getBlockData().set(getDirection(enumdirection.opposite()), Boolean.TRUE)));
                } else if (this.c(world.getType(blockposition2.up()).getBlock())) {
                  // world.setTypeAndData(blockposition2, this.getBlockData(), 2);
                  CraftEventFactory.handleBlockSpreadEvent(bukkitBlock, source, this, toLegacyData(this.getBlockData()));
                }
                // CraftBukkit end
              } else if (block.material.k() && block.d()) {
                world.setTypeAndData(pos, iblockdata.set(getDirection(enumdirection), Boolean.TRUE), 2);
              }

            }
          } else {
            if (pos.getY() > 1) {
              blockposition2 = pos.down();
              IBlockData iblockdata2 = world.getType(blockposition2);
              Block block1 = iblockdata2.getBlock();
              IBlockData iblockdata3;
              Iterator iterator1;
              EnumDirection enumdirection3;

              if (block1.material == Material.AIR) {
                iblockdata3 = iblockdata;
                iterator1 = EnumDirection.EnumDirectionLimit.HORIZONTAL.iterator();

                while (iterator1.hasNext()) {
                  enumdirection3 = (EnumDirection) iterator1.next();
                  if (random.nextBoolean()) {
                    iblockdata3 = iblockdata3.set(getDirection(enumdirection3), Boolean.FALSE);
                  }
                }

                if (iblockdata3.get(BlockVine.NORTH) || iblockdata3.get(BlockVine.EAST) || iblockdata3.get(BlockVine.SOUTH) || iblockdata3.get(BlockVine.WEST)) {
                  // CraftBukkit start - Call BlockSpreadEvent
                  // world.setTypeAndData(blockposition2, iblockdata3, 2);
                  org.bukkit.block.Block source = world.getWorld().getBlockAt(pos.getX(), pos.getY(), pos.getZ());
                  org.bukkit.block.Block bukkitBlock = world.getWorld().getBlockAt(blockposition2.getX(), blockposition2.getY(), blockposition2.getZ());
                  CraftEventFactory.handleBlockSpreadEvent(bukkitBlock, source, this, toLegacyData(iblockdata3));
                  // CraftBukkit end
                }
              } else if (block1 == this) {
                iblockdata3 = iblockdata2;
                iterator1 = EnumDirection.EnumDirectionLimit.HORIZONTAL.iterator();

                while (iterator1.hasNext()) {
                  enumdirection3 = (EnumDirection) iterator1.next();
                  BlockStateBoolean blockstateboolean = getDirection(enumdirection3);

                  if (random.nextBoolean() && iblockdata.get(blockstateboolean)) {
                    iblockdata3 = iblockdata3.set(blockstateboolean, Boolean.TRUE);
                  }
                }

                if (iblockdata3.get(BlockVine.NORTH) || iblockdata3.get(BlockVine.EAST) || iblockdata3.get(BlockVine.SOUTH) || iblockdata3.get(BlockVine.WEST)) {
                  world.setTypeAndData(blockposition2, iblockdata3, 2);
                }
              }
            }

          }
        }
      }
    }
  }

  public IBlockData getPlacedState(World world, BlockPosition blockposition, EnumDirection enumdirection, float f, float f1, float f2, int i, EntityLiving entityliving) {
    IBlockData iblockdata = this.getBlockData().set(BlockVine.UP, Boolean.FALSE).set(BlockVine.NORTH, Boolean.FALSE).set(BlockVine.EAST, Boolean.FALSE).set(BlockVine.SOUTH, Boolean.FALSE).set(BlockVine.WEST, Boolean.FALSE);

    return enumdirection.k().c() ? iblockdata.set(getDirection(enumdirection.opposite()), Boolean.TRUE) : iblockdata;
  }

  public Item getDropType(IBlockData iblockdata, Random random, int i) {
    return null;
  }

  public int a(Random random) {
    return 0;
  }

  public void a(World world, EntityHuman entityhuman, BlockPosition blockposition, IBlockData iblockdata, TileEntity tileentity) {
    if (!world.isClientSide && entityhuman.bZ() != null && entityhuman.bZ().getItem() == Items.SHEARS) {
      entityhuman.b(StatisticList.MINE_BLOCK_COUNT[Block.getId(this)]);
      a(world, blockposition, new ItemStack(Blocks.VINE, 1, 0));
    } else {
      super.a(world, entityhuman, blockposition, iblockdata, tileentity);
    }

  }

  public IBlockData fromLegacyData(int i) {
    return this.getBlockData().set(BlockVine.SOUTH, (i & 1) > 0).set(BlockVine.WEST, (i & 2) > 0).set(BlockVine.NORTH, (i & 4) > 0).set(BlockVine.EAST, (i & 8) > 0);
  }

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

    if (iblockdata.get(BlockVine.SOUTH)) {
      i |= 1;
    }

    if (iblockdata.get(BlockVine.WEST)) {
      i |= 2;
    }

    if (iblockdata.get(BlockVine.NORTH)) {
      i |= 4;
    }

    if (iblockdata.get(BlockVine.EAST)) {
      i |= 8;
    }

    return i;
  }

  protected BlockStateList getStateList() {
    return new BlockStateList(this, BlockVine.UP, BlockVine.NORTH, BlockVine.EAST, BlockVine.SOUTH, BlockVine.WEST);
  }

  static class SyntheticClass_1 {

    static final int[] a = new int[EnumDirection.values().length];

    static {
      try {
        BlockVine.SyntheticClass_1.a[EnumDirection.UP.ordinal()] = 1;
      } catch (NoSuchFieldError ignored) {
      }

      try {
        BlockVine.SyntheticClass_1.a[EnumDirection.NORTH.ordinal()] = 2;
      } catch (NoSuchFieldError ignored) {
      }

      try {
        BlockVine.SyntheticClass_1.a[EnumDirection.SOUTH.ordinal()] = 3;
      } catch (NoSuchFieldError ignored) {
      }

      try {
        BlockVine.SyntheticClass_1.a[EnumDirection.EAST.ordinal()] = 4;
      } catch (NoSuchFieldError ignored) {
      }

      try {
        BlockVine.SyntheticClass_1.a[EnumDirection.WEST.ordinal()] = 5;
      } catch (NoSuchFieldError ignored) {
      }

    }
  }
}