@EventHandler
  public void onBlockPlaceEvent(BlockPlaceEvent event) {
    if (!isEnabled()) return;

    if (event.isCancelled()) return;
    try {

      BlockType type = BlockType.Unknown;
      Player player = event.getPlayer();
      Block block = event.getBlock();

      if (event.getBlock().getTypeId() == 0) {
        ForgePermittor.log("tile: " + getValidator().CheckItem(event.getItemInHand()), true);
        if (getValidator().CheckItem(event.getItemInHand()) == ItemType.Container)
          type = BlockType.Container;
      } else {
        ForgePermittor.log("tile: " + getValidator().CheckBlock(event.getBlock()), true);
        type = getValidator().CheckBlock(event.getBlock());
      }

      if (type == BlockType.Container) {
        if (CheckBlockPlaceforContainer(player, block.getRelative(BlockFace.NORTH))
            || CheckBlockPlaceforContainer(player, block.getRelative(BlockFace.SOUTH))
            || CheckBlockPlaceforContainer(player, block.getRelative(BlockFace.WEST))
            || CheckBlockPlaceforContainer(player, block.getRelative(BlockFace.EAST))) {
          event.setCancelled(true);
        }
      }
    } catch (Exception e) {
      ForgePermittor.log(e.toString(), true);
    }
  }
示例#2
0
  /** Check the four sides of the base block to see if there's room for a large chest */
  public static Block findLarge(Block base) {
    // Check all 4 sides for air.
    Block block;

    block = base.getRelative(BlockFace.NORTH);
    if (canBeReplaced(block.getState())
        && (!Config.getInstance().getNoInterfere() || !checkChest(block, Material.CHEST))) {
      return block;
    }

    block = base.getRelative(BlockFace.EAST);
    if (canBeReplaced(block.getState())
        && (!Config.getInstance().getNoInterfere() || !checkChest(block, Material.CHEST))) {
      return block;
    }

    block = base.getRelative(BlockFace.SOUTH);
    if (canBeReplaced(block.getState())
        && (!Config.getInstance().getNoInterfere() || !checkChest(block, Material.CHEST))) {
      return block;
    }

    block = base.getRelative(BlockFace.WEST);
    if (canBeReplaced(block.getState())
        && (!Config.getInstance().getNoInterfere() || !checkChest(block, Material.CHEST))) {
      return block;
    }

    return null;
  }
示例#3
0
 public boolean isDoubleChest() {
   final Block b = loc.getBlock();
   return (isChest(b.getRelative(BlockFace.NORTH))
       || isChest(b.getRelative(BlockFace.SOUTH))
       || isChest(b.getRelative(BlockFace.EAST))
       || isChest(b.getRelative(BlockFace.WEST)));
 }
示例#4
0
  @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
  public void BlockBreakEvent(BlockBreakEvent e) {

    if (e.getBlock().hasMetadata("ce.Ice")) e.setCancelled(true);

    CEventHandler.handleEvent(e.getPlayer(), e, blockBroken);
    if (e.getBlock().hasMetadata("ce.mine")) {
      Block b = e.getBlock();
      b.removeMetadata("ce.mine", Main.plugin);
      Block[] blocks = {
        b.getRelative(0, 1, 0),
        b.getRelative(1, 0, 0),
        b.getRelative(-1, 0, 0),
        b.getRelative(0, 0, 1),
        b.getRelative(0, 0, -1)
      };

      for (Block block : blocks) {
        if (block.hasMetadata("ce.mine.secondary")) {
          String[] s = block.getMetadata("ce.mine.secondary").get(0).asString().split(" ");
          Location loc =
              new Location(
                  e.getPlayer().getWorld(),
                  Integer.parseInt(s[0]),
                  Integer.parseInt(s[1]),
                  Integer.parseInt(s[2]));
          Location blockLoc = b.getLocation();
          if (loc.getBlockX() == blockLoc.getBlockX()
              && loc.getBlockY() == blockLoc.getBlockY()
              && loc.getBlockZ() == blockLoc.getBlockZ())
            block.removeMetadata("ce.mine.secondary", Main.plugin);
        }
      }
    }
  }
示例#5
0
  protected int getDiagonalNeighborCount(
      Block block, MaterialAndData liveMaterial, boolean includeCommands) {
    int liveCount = 0;
    for (BlockFace face : DIAGONAL_FACES) {
      if (liveMaterial.is(block.getRelative(face))) {
        liveCount++;
      }
    }

    if (yRadius > 0) {
      Block upBlock = block.getRelative(BlockFace.UP);
      for (BlockFace face : NEIGHBOR_FACES) {
        if (liveMaterial.is(upBlock.getRelative(face))) {
          liveCount++;
        }
      }

      Block downBlock = block.getRelative(BlockFace.DOWN);
      for (BlockFace face : NEIGHBOR_FACES) {
        if (liveMaterial.is(downBlock.getRelative(face))) {
          liveCount++;
        }
      }
    }
    return liveCount;
  }
示例#6
0
  // RŽcupŽration du Relative et ajout du SignManager dans le Set
  public static boolean registerSign(Location locsign) {
    try {
      locsign.getBlock();
    } catch (Exception e) {
      return false;
    } // VŽrifie sur la locsign est un block

    if (!(locsign.getBlock().getState() instanceof org.bukkit.block.Sign)) return false;

    Block bs = locsign.getBlock();
    org.bukkit.material.Sign signmat = (org.bukkit.material.Sign) bs.getState().getData();
    Location relative = null;

    if (!signmat.isWallSign()) relative = bs.getRelative(BlockFace.DOWN).getLocation();
    else if (signmat.getAttachedFace() == BlockFace.EAST)
      relative = bs.getRelative(BlockFace.EAST).getLocation();
    else if (signmat.getAttachedFace() == BlockFace.WEST)
      relative = bs.getRelative(BlockFace.WEST).getLocation();
    else if (signmat.getAttachedFace() == BlockFace.NORTH)
      relative = bs.getRelative(BlockFace.NORTH).getLocation();
    else if (signmat.getAttachedFace() == BlockFace.SOUTH)
      relative = bs.getRelative(BlockFace.SOUTH).getLocation();

    SignManager sm = new SignManager(locsign, relative);
    sm.RefreshSign();
    return true;
  }
  private void destroyAbove(final Block b) {
    if (b.getTypeId() != PitfallSettings.redstonePitItem) return;

    b.setTypeId(0);
    plugin
        .getServer()
        .getScheduler()
        .scheduleSyncDelayedTask(
            plugin,
            new Runnable() {
              public void run() {
                try {
                  b.setTypeId(PitfallSettings.redstonePitItem);
                } catch (Exception e) {
                }
              }
            },
            PitfallSettings.returnDelay);

    if (PitfallSettings.redstoneTriggerCorner) {
      destroyAbove(b.getRelative(BlockFace.NORTH_EAST));
      destroyAbove(b.getRelative(BlockFace.NORTH_WEST));
      destroyAbove(b.getRelative(BlockFace.SOUTH_EAST));
      destroyAbove(b.getRelative(BlockFace.SOUTH_WEST));
    }
    destroyAbove(b.getRelative(BlockFace.NORTH));
    destroyAbove(b.getRelative(BlockFace.EAST));
    destroyAbove(b.getRelative(BlockFace.WEST));
    destroyAbove(b.getRelative(BlockFace.SOUTH));
  }
示例#8
0
  private boolean isCloseDoor(Location actual) {
    BlockFace[] blockFaces = {BlockFace.EAST, BlockFace.NORTH, BlockFace.WEST, BlockFace.SOUTH};
    actual.setY(actual.getY());
    Block base = actual.getBlock();
    for (BlockFace bf : blockFaces) {
      Block bu = base.getRelative(bf);
      if ((bu.getType() == Material.WOODEN_DOOR)) {
        byte openData = 0x4;
        byte doorData = (byte) (bu.getData());
        if ((doorData & 0x4) == 0x4) {
          doorData = (byte) (doorData & 0x3);
        } else {
          doorData = (byte) (doorData | 0x7);
        }
        bu.setData(doorData);

        if ((bu.getRelative(BlockFace.UP).getType() == Material.WOODEN_DOOR)) {
          doorData = (byte) (bu.getRelative(BlockFace.UP).getData());
          if ((doorData & 0x1) == 1) {
            doorData = 0x9;
          } else {
            doorData = 0x8;
          }
          bu.getRelative(BlockFace.UP).setData(doorData);
        }
        return true;
      }
    }
    return false;
  }
 // return true if block can be broken
 private boolean checkBlockBroken(Block broken) {
   return canBreakBlock(broken.getRelative(BlockFace.UP), broken)
       && canBreakBlock(broken.getRelative(BlockFace.NORTH), broken)
       && canBreakBlock(broken.getRelative(BlockFace.EAST), broken)
       && canBreakBlock(broken.getRelative(BlockFace.SOUTH), broken)
       && canBreakBlock(broken.getRelative(BlockFace.WEST), broken);
 }
示例#10
0
 public static boolean poweringDoor(Block block) {
   return block.getRelative(BlockFace.NORTH).getState().getData() instanceof Openable
       || block.getRelative(BlockFace.SOUTH).getState().getData() instanceof Openable
       || block.getRelative(BlockFace.EAST).getState().getData() instanceof Openable
       || block.getRelative(BlockFace.WEST).getState().getData() instanceof Openable
       || block.getRelative(BlockFace.DOWN).getState().getData() instanceof Openable
       || block.getRelative(BlockFace.UP).getState().getData() instanceof Openable;
 }
 private static Location getAdjacentTrack(final Block center, final BlockFace dir) {
   if (MinecartUtils.isTrack(center.getRelative(dir)))
     return center.getRelative(dir).getLocation();
   if ((center.getRelative(dir).getTypeId() == Material.CHEST.getId())
       && MinecartUtils.isTrack(center.getRelative(dir).getRelative(dir)))
     return center.getRelative(dir).getRelative(dir).getLocation();
   return null;
 }
 private boolean isReversed(BlockFace primary) {
   BlockFace secondary = primary.getOppositeFace();
   if (isSolid(top.getRelative(secondary)) || isSolid(bottom.getRelative(secondary))) {
     return false;
   } else {
     return isSolid(top.getRelative(primary)) || isSolid(bottom.getRelative(primary));
   }
 }
示例#13
0
 /**
  * Returns a list of block locations around the block that are of the type specified by the
  * integer list parameter
  *
  * @param block
  * @param type
  * @return List of block locations around the block that are of the type specified by the integer
  *     list parameter
  */
 public static List<Location> getBlocksNearby(org.bukkit.block.Block block, Set<Material> type) {
   ArrayList<Location> blocks = new ArrayList<Location>();
   for (BlockFace blockFace : relativeBlockFaces) {
     if (type.contains(block.getRelative(blockFace).getType())) {
       blocks.add(block.getRelative(blockFace).getLocation());
     }
   }
   return blocks;
 }
示例#14
0
 /**
  * This method checks a block for shop protection for other chests near or that chest
  *
  * @param block Block to chest, intended to be a chest
  * @param player Player to cross-check for permissions
  * @param plugin currently active PhysicalShop to consider
  * @return true if the player should be blocked
  */
 public static boolean isProtectedChestsAround(
     final Block block, final Player player, final PhysicalShop plugin) {
   for (final BlockFace blockFace : CARDINAL_DIRECTIONS) {
     final Block checkBlock = block.getRelative(blockFace);
     if (checkBlock.getType() == CHEST && !hasAccess(player, checkBlock.getRelative(UP), plugin))
       return true;
   }
   return false;
 }
示例#15
0
 @Override
 public void toPlayer(Player player, Location value) {
   Block block = value.getBlock();
   Block above = block.getRelative(0, 1, 0);
   while (!block.isEmpty() || !above.isEmpty()) {
     block = above;
     above = block.getRelative(0, 1, 0);
   }
   player.teleport(block.getLocation());
 }
示例#16
0
 private static boolean checkBlockIsOnBorderOfSlice(Block block, ArrayList<Block> slice) {
   BlockFace[] faces = {BlockFace.NORTH, BlockFace.EAST, BlockFace.SOUTH, BlockFace.WEST};
   if (slice.contains(block.getRelative(faces[0]))
       && slice.contains(block.getRelative(faces[1]))
       && slice.contains(block.getRelative(faces[2]))
       && slice.contains(block.getRelative(faces[3]))) {
     return false;
   }
   return true;
 }
  @SuppressWarnings("deprecation")
  private boolean signFinder(
      Player player,
      Block block,
      BlockFace[] testBlocks,
      BlockFace[] testFaces,
      final Block lever) {

    Block newBlock;
    BlockFace testFace;

    for (int c = 0; c < 5; c++) {
      if (c == 2) {
        newBlock = block.getRelative(testBlocks[c], 2);
        testFace = testFaces[1];
      } else {
        newBlock = block.getRelative(testBlocks[c]);
        testFace = testFaces[0];
      }
      if (!(newBlock.getState() instanceof Sign)) continue;
      if (((org.bukkit.material.Sign) newBlock.getState().getData()).getFacing() != testFace)
        continue;

      int s = signConverter(player, newBlock);
      if (s > 0) {
        boolean n = s == 1;

        if (n || !enableBL) return n;
        if (lever.getType() != Material.LEVER) return n;
        Lever l = (Lever) lever.getState().getData();
        // if (l.isPowered())
        //	return n;
        l.setPowered(false);
        l.setPowered(true);
        lever.setData(l.getData());
        lever.getWorld().playEffect(lever.getLocation(), Effect.SMOKE, 4);
        Bukkit.getScheduler()
            .scheduleSyncDelayedTask(
                PLUGIN,
                new Runnable() {
                  @Override
                  public void run() {
                    if (lever.getType() != Material.LEVER) return;
                    Lever l = (Lever) lever.getState().getData();
                    if (!l.isPowered()) return;
                    l.setPowered(false);
                    lever.setData(l.getData());
                    lever.getWorld().playEffect(lever.getLocation(), Effect.SMOKE, 4);
                  }
                },
                20L);
      }
    }
    return false;
  }
示例#18
0
  private static void buildTreeLayer2(ArrayList<Block> blocks) {
    ArrayList<Block> branches = new ArrayList<Block>();

    for (Block b : blocks) {
      BlockFace dir = getBuildDirection(b);
      Block handle = b.getRelative(dir);
      handle.setTypeIdAndData(17, (byte) 1, false);
      branches.add(handle);
      switch (dir) {
        case NORTH:
          branches.add(handle.getRelative(-1, 0, 1));
          branches.add(handle.getRelative(-1, 0, -1));
          break;
        case EAST:
          branches.add(handle.getRelative(-1, 0, -1));
          branches.add(handle.getRelative(1, 0, -1));
          break;
        case SOUTH:
          branches.add(handle.getRelative(1, 0, 1));
          branches.add(handle.getRelative(1, 0, -1));
          break;
        case WEST:
          branches.add(handle.getRelative(-1, 0, 1));
          branches.add(handle.getRelative(1, 0, 1));
          break;
      }
    }
    if (!branches.isEmpty()) {
      for (Block branch : branches) {
        branch.setTypeIdAndData(17, (byte) 1, false);
        populateTreeBranch(branch, 2);
      }
    }
  }
示例#19
0
  @EventHandler
  public void onVehicleImpact(CartBlockImpactEvent event) {

    // validate
    if (!event.getBlocks().matches(getMaterial())) return;
    if (!event.getBlocks().hasSign()) return;
    if (event.isMinor()) return;
    if (!(event.getBlocks().matches("cartlift up") || event.getBlocks().matches("cartlift down")))
      return;

    Minecart cart = (Minecart) event.getVehicle();

    // go
    boolean up = event.getBlocks().matches("cartlift up");
    Block destination = event.getBlocks().sign;

    BlockFace face;
    if (up) face = BlockFace.UP;
    else face = BlockFace.DOWN;

    while (true) {

      if (destination.getLocation().getBlockY() <= 0 && !up) return;
      if (destination.getLocation().getBlockY() >= destination.getWorld().getMaxHeight() - 1 && up)
        return;

      destination = destination.getRelative(face);

      if (SignUtil.isSign(destination)
          && event.getBlocks().base.getTypeId()
              == destination.getRelative(BlockFace.UP, 1).getTypeId()) {

        ChangedSign state = BukkitUtil.toChangedSign(destination);
        String testLine = state.getLine(1);

        if (testLine.equalsIgnoreCase("[CartLift Up]")
            || testLine.equalsIgnoreCase("[CartLift Down]")
            || testLine.equalsIgnoreCase("[CartLift]")) {
          destination = destination.getRelative(BlockFace.UP, 2);
          break;
        }
      }
    }

    CartUtils.teleport(
        cart,
        new Location(
            destination.getWorld(),
            destination.getX(),
            destination.getY(),
            destination.getZ(),
            cart.getLocation().getYaw(),
            cart.getLocation().getPitch()));
  }
示例#20
0
文件: Board.java 项目: TZer0/Games
 public void update() {
   for (int k = 0; k < y; k++) {
     for (int i = 0; i < x; i++) {
       for (int j = 0; j < z; j++) {
         startBlock.getRelative(i, k, j).setTypeId(field[k][i][j]);
         if (data != null) {
           startBlock.getRelative(i, k, j).setData((byte) data[k][i][j]);
         }
       }
     }
   }
 }
  // finds a block the player can probably see.  this is how visualizations "cling" to the ground or
  // ceiling
  private static Location getVisibleLocation(World world, int x, int y, int z) {
    Block block = world.getBlockAt(x, y, z);
    BlockFace direction = (isTransparent(block)) ? BlockFace.DOWN : BlockFace.UP;

    while (block.getY() >= 1
        && block.getY() < world.getMaxHeight() - 1
        && (!isTransparent(block.getRelative(BlockFace.UP)) || isTransparent(block))) {
      block = block.getRelative(direction);
    }

    return block.getLocation();
  }
示例#22
0
 @EventHandler(ignoreCancelled = true)
 public void onBlockPistonRetract(BlockPistonRetractEvent event) {
   Block piston = event.getBlock();
   Block extension = piston.getRelative(event.getDirection());
   Block block = extension.getRelative(event.getDirection());
   Deadbolted db = Deadbolt.get(block);
   if (db.isProtected()) {
     // TODO why cant we just cancel
     event.setCancelled(true);
     piston.setData((byte) (piston.getData() ^ 0x8));
     extension.setType(Material.AIR);
   }
 }
示例#23
0
 @SuppressWarnings("deprecation")
 @EventHandler(priority = EventPriority.LOW)
 public void onBlockPistonExtend(BlockPistonExtendEvent event) {
   Map map = Rixor.getRotation().getSlot().getMap();
   for (Block block : event.getBlocks()) {
     BlockState newState = block.getRelative(event.getDirection()).getState();
     newState.setData(new MaterialData(block.getType(), block.getData()));
     BlockChangeEvent change =
         new BlockChangeEvent(
             event, map, null, block.getRelative(event.getDirection()).getState(), newState);
     Rixor.callEvent(change);
   }
 }
 public void onBlockRedstoneChange(BlockRedstoneEvent event) {
   if (PitfallSettings.redstonePitEnabled) {
     Block b = event.getBlock();
     if (event.getOldCurrent() == 0 && event.getNewCurrent() > 0) {
       if (b.getRelative(BlockFace.UP).getTypeId() == PitfallSettings.redstonePitItem) {
         destroyAbove(b.getRelative(BlockFace.UP));
       }
       if (b.getRelative(BlockFace.DOWN).getTypeId() == PitfallSettings.redstonePitItem) {
         destroyBelow(b.getRelative(BlockFace.DOWN), b);
       }
     }
   }
 }
示例#25
0
 @Override
 public void animate(Fight fight, Character attacking, Character defending, ItemStack weapon) {
   if (attacking.getPlayer().isOnline()) {
     Player player = attacking.getPlayer().getPlayer();
     BlockIterator iterator = new BlockIterator(player, 8);
     long delay = 0L;
     int i = 0;
     while (iterator.hasNext()) {
       Block block = iterator.next();
       setShard(block.getRelative(BlockFace.UP, 2).getRelative(BlockFace.DOWN, i), delay);
       float yaw = player.getLocation().getYaw();
       yaw = (yaw + 90) % 360;
       int left = (int) Math.floor((yaw - 90) / 90);
       int right = (int) Math.floor((yaw + 90) / 90);
       BlockFace leftBlockFace = BlockFace.UP;
       switch (left) {
         case 0:
           leftBlockFace = BlockFace.NORTH;
           break;
         case 1:
           leftBlockFace = BlockFace.WEST;
           break;
         case 2:
           leftBlockFace = BlockFace.SOUTH;
           break;
         case 3:
           leftBlockFace = BlockFace.EAST;
           break;
       }
       BlockFace rightBlockFace = BlockFace.UP;
       switch (right) {
         case 0:
           rightBlockFace = BlockFace.NORTH;
           break;
         case 1:
           rightBlockFace = BlockFace.WEST;
           break;
         case 2:
           rightBlockFace = BlockFace.SOUTH;
           break;
         case 3:
           rightBlockFace = BlockFace.EAST;
           break;
       }
       setShard(block.getRelative(leftBlockFace, 2).getRelative(BlockFace.DOWN, i), delay);
       setShard(block.getRelative(rightBlockFace, 2).getRelative(BlockFace.DOWN, i), delay);
       delay += 5L;
       i++;
     }
   }
 }
示例#26
0
  /**
   * Places Blocks of a predetermined type just above the highest Block at each corner of the given
   * Chunk
   *
   * @param chunk The given Chunk
   */
  public static void markCorners(Chunk chunk) {
    // Get the highest Block (should be empty) at the South-West corner
    Block block = chunk.getBlock(0, 127, 0);
    // Move down until a non-empty Block is found
    while (block.getTypeId() == 0) block = block.getRelative(BlockFace.DOWN);
    // Change the empty Block just above the Block found
    block.getRelative(BlockFace.UP).setTypeId(cornerID);

    // Get the highest Block (should be empty) at the South-East corner
    block = chunk.getBlock(0, 127, 15);
    // Move down until a non-empty Block is found
    while (block.getTypeId() == 0) block = block.getRelative(BlockFace.DOWN);
    // Change the empty Block just above the Block found
    block.getRelative(BlockFace.UP).setTypeId(cornerID);

    // Get the highest Block (should be empty) at the North-West corner
    block = chunk.getBlock(15, 127, 0);
    // Move down until a non-empty Block is found
    while (block.getTypeId() == 0) block = block.getRelative(BlockFace.DOWN);
    // Change the empty Block just above the Block found
    block.getRelative(BlockFace.UP).setTypeId(cornerID);

    // Get the highest Block (should be empty) at the North-East corner
    block = chunk.getBlock(15, 127, 15);
    // Move down until a non-empty Block is found
    while (block.getTypeId() == 0) block = block.getRelative(BlockFace.DOWN);
    // Change the empty Block just above the Block found
    block.getRelative(BlockFace.UP).setTypeId(cornerID);
  }
示例#27
0
  public static Block findOtherHalfofChest(Block b) {
    // didn't find one, so find the other half of the chest and check it's faces
    Block[] adjBlocks =
        new Block[] {
          b.getRelative(BlockFace.NORTH),
          b.getRelative(BlockFace.EAST),
          b.getRelative(BlockFace.SOUTH),
          b.getRelative(BlockFace.WEST)
        };
    for (int i = 0; i < adjBlocks.length; i++)
      if (adjBlocks[i].getType() == Material.CHEST) return adjBlocks[i];

    return null;
  }
示例#28
0
  @Override
  public CastResult cast(SpellContext context) {
    Player player = context.<Player>getPlayer();
    Block target = context.<Block>getTarget().get();
    BlockFace direction = getClickedFace(player);
    Block phased = null;

    switch (direction) {
      case NORTH:
        phased = target.getRelative(0, 0, -1);
        break;
      case SOUTH:
        phased = target.getRelative(0, 0, 1);
        break;
      case EAST:
        phased = target.getRelative(1, 0, 0);
        break;
      case WEST:
        phased = target.getRelative(-1, 0, 0);
        break;
      case UP:
        phased = target.getRelative(0, +3, 0);
        break;
      case DOWN:
        phased = target.getRelative(0, -2, 0);
        break;
      default:
        phased = target;
        break;
    }

    if (!BukkitTargetUtils.getTransparent().contains(phased.getType())) {
      player.sendMessage(ChatColor.RED + "You cannot phase through that block");
      return CastResult.FAILURE;
    } else if (BukkitTargetUtils.getTransparent()
        .contains(phased.getRelative(0, -1, 0).getType())) {
      Location loc = phased.getRelative(0, -1, 0).getLocation();
      loc.add(0.5, 0, 0.5);
      loc.setPitch(player.getLocation().getPitch());
      loc.setYaw(player.getLocation().getYaw());
      player.teleport(loc);
      return CastResult.SUCCESS;
    } else if (BukkitTargetUtils.getTransparent().contains(phased.getRelative(0, 1, 0).getType())) {
      Location loc = phased.getLocation();
      loc.add(0.5, 0, 0.5);
      loc.setPitch(player.getLocation().getPitch());
      loc.setYaw(player.getLocation().getYaw());
      player.teleport(loc);
      return CastResult.SUCCESS;
    } else {
      player.sendMessage(ChatColor.RED + "You cannot phase through that block");
      return CastResult.FAILURE;
    }
  }
  public String getNotchPortalDestination(Player p, Location l)
      throws MoreThanOneSignFoundException, NoMultiverseSignFoundException {
    // Determine corner, should be 1 of 4
    Block block = l.getBlock();
    Location portalStart;
    Location portalEnd;
    List<Sign> foundSigns = null;
    if (block.getType() == Material.PORTAL) {
      // We found the bottom 2: ##
      if (block.getRelative(1, 0, 0).getType() == Material.PORTAL) {
        portalEnd = block.getRelative(1, 0, 0).getLocation();
        portalStart = block.getRelative(0, 2, 0).getLocation();
        foundSigns =
            this.checkBlocksOutside(
                l.getWorld().getBlockAt(portalStart), l.getWorld().getBlockAt(portalEnd), Axis.X);
        this.plugin.log(Level.FINER, "Found normal X");

      } else if (block.getRelative(-1, 0, 0).getType() == Material.PORTAL) {
        portalEnd = block.getLocation();
        portalStart = block.getRelative(-1, 2, 0).getLocation();
        foundSigns =
            this.checkBlocksOutside(
                l.getWorld().getBlockAt(portalStart), l.getWorld().getBlockAt(portalEnd), Axis.X);
        this.plugin.log(Level.FINER, "Found inverse X");
      } else if (block.getRelative(0, 0, 1).getType() == Material.PORTAL) {
        portalEnd = block.getRelative(0, 0, 1).getLocation();
        portalStart = block.getRelative(0, 2, 0).getLocation();
        foundSigns =
            this.checkBlocksOutside(
                l.getWorld().getBlockAt(portalStart), l.getWorld().getBlockAt(portalEnd), Axis.Z);
        this.plugin.log(Level.FINER, "Found normal Z");

      } else if (block.getRelative(0, 0, -1).getType() == Material.PORTAL) {
        portalEnd = block.getLocation();
        portalStart = block.getRelative(0, 2, -1).getLocation();
        foundSigns =
            this.checkBlocksOutside(
                l.getWorld().getBlockAt(portalStart), l.getWorld().getBlockAt(portalEnd), Axis.Z);
        this.plugin.log(Level.FINER, "Found inverse Z");
      }
    }
    if (foundSigns != null) {
      this.plugin.log(Level.FINE, "Woo! Notch Portal!");
      return processSigns(foundSigns, p);
    } else {
      this.plugin.log(Level.FINE, ":( No Notch Portal Here...");
    }
    return null;
  }
示例#30
0
  public static void smartLogFallables(Consumer consumer, String playerName, Block origin) {

    WorldConfig wcfg = getWorldConfig(origin.getWorld());
    if (wcfg == null) return;

    // Handle falling blocks
    Block checkBlock = origin.getRelative(BlockFace.UP);
    int up = 0;
    final int highestBlock = checkBlock.getWorld().getHighestBlockYAt(checkBlock.getLocation());
    while (BukkitUtils.getRelativeTopFallables().contains(checkBlock.getType())) {

      // Record this block as falling
      consumer.queueBlockBreak(playerName, checkBlock.getState());

      // Guess where the block is going (This could be thrown of by explosions, but it is better
      // than nothing)
      Location loc = origin.getLocation();
      int x = loc.getBlockX();
      int y = loc.getBlockY();
      int z = loc.getBlockZ();
      while (y > 0 && BukkitUtils.canFall(loc.getWorld(), x, (y - 1), z)) {
        y--;
      }
      // If y is 0 then the sand block fell out of the world :(
      if (y != 0) {
        Location finalLoc = new Location(loc.getWorld(), x, y, z);
        // Run this check to avoid false positives
        if (!BukkitUtils.getFallingEntityKillers().contains(finalLoc.getBlock().getType())) {
          finalLoc.add(0, up, 0); // Add this here after checking for block breakers
          if (finalLoc.getBlock().getType() == Material.AIR
              || BukkitUtils.getRelativeTopFallables().contains(finalLoc.getBlock().getType())) {
            consumer.queueBlockPlace(
                playerName, finalLoc, checkBlock.getTypeId(), checkBlock.getData());
          } else {
            consumer.queueBlockReplace(
                playerName,
                finalLoc,
                finalLoc.getBlock().getTypeId(),
                finalLoc.getBlock().getData(),
                checkBlock.getTypeId(),
                checkBlock.getData());
          }
          up++;
        }
      }
      if (checkBlock.getY() >= highestBlock) break;
      checkBlock = checkBlock.getRelative(BlockFace.UP);
    }
  }