Java Code Examples for org.bukkit.Location#distance()

public static void validateDistanceFromSpawn(Location loc) throws CivException {
	/* Check distance from spawn. */
	double requiredDistance;
	try {
		requiredDistance = CivSettings.getDouble(CivSettings.civConfig, "global.distance_from_spawn");
	} catch (InvalidConfiguration e) {
		e.printStackTrace();
		return;
	}
	
	for (Civilization civ : CivGlobal.getAdminCivs()) {
		Location townHallLoc = civ.getCapitolTownHallLocation();
		if (townHallLoc == null) {
			continue;
		}

		double distance = townHallLoc.distance(loc);
		if (distance < requiredDistance) {
			throw new CivException("You must build at least "+requiredDistance+" blocks away from spawn.");
		}
		
	}
}
 

/**
 * Prevent the Nether spawn from being blown up
 * 
 * @param e - event
 */
@EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
public void onExplosion(final EntityExplodeEvent e) {
    if (Settings.newNether) {
        // Not used in the new nether
        return;
    }
    // Find out what is exploding
    Entity expl = e.getEntity();
    if (expl == null) {
        return;
    }
    // Check world
    if (!e.getEntity().getWorld().getName().equalsIgnoreCase(Settings.worldName + "_nether")
            || e.getEntity().getWorld().getName().equalsIgnoreCase(Settings.worldName + "_the_end")) {
        return;
    }
    Location spawn = e.getLocation().getWorld().getSpawnLocation();
    Location loc = e.getLocation();
    if (spawn.distance(loc) < Settings.netherSpawnRadius) {
        e.blockList().clear();
    }
}
 

private boolean hasCleanShot(Location shootHere, Location targetHere) {
        double x = shootHere.getX();
        double y = shootHere.getY();
        double z = shootHere.getZ();

        double x1 = targetHere.getX();
        double y1 = targetHere.getY();
        double z1 = targetHere.getZ();

        Vector start = new Vector(x, y, z);
        Vector end = new Vector (x1, y1, z1);

        BlockIterator bi = new BlockIterator(shootHere.getWorld(), start, end, 0, (int) shootHere.distance(targetHere));
        while (bi.hasNext()) {
            Block block = bi.next();
//            System.out.println(Civs.getPrefix() + ((int) block.getLocation().getX()) +
//                    ":" + ((int) block.getLocation().getY()) + ":" +
//                    ((int) block.getLocation().getZ()) + " " + !Util.isSolidBlock(block.getType()));
            if (!Util.isSolidBlock(block.getType())) {
                return false;
            }
        }

        return true;
    }
 

private void checkForStuck() {
	if (this.targetName != null && this.lastLocation != null) {
		Location loc = getLocation(entity);
		if (loc.distance(this.lastLocation) < 0.5) {
			Player player;
			try {
				player = CivGlobal.getPlayer(this.targetName);
				entity.getBukkitEntity().teleport(player.getLocation());
			} catch (CivException e) {
				/* This player is no longer online. Lose target. */
				this.targetName = null;
				this.lastLocation = null;
			}			
		}
		this.lastLocation = loc;
	}
}
 

private Location getNearestTurret(Location playerLoc) {
	
	double distance = Double.MAX_VALUE;
	BlockCoord nearest = null;
	for (BlockCoord turretCoord : turrets) {
		Location turretLoc = turretCoord.getLocation();
		if (playerLoc.getWorld() != turretLoc.getWorld()) {
			return null;
		}
		
		double tmp = turretLoc.distance(playerLoc);
		if (tmp < distance) {
			distance = tmp;
			nearest = turretCoord;
		}
		
	}
	if (nearest == null) {
		return null;
	}
	return nearest.getLocation();
}
 

public static double distanceFromRanged(RangedInfo rangedInfo, @Nullable Location deathLocation) {
  if (rangedInfo.getOrigin() == null || deathLocation == null) return Double.NaN;

  // When players fall in the void, use y=0 as their death location
  if (deathLocation.getY() < 0) {
    deathLocation = deathLocation.clone();
    deathLocation.setY(0);
  }
  return deathLocation.distance(rangedInfo.getOrigin());
}
 

@EventHandler
public void onPlayerBucketEmpty(PlayerBucketEmptyEvent event) {
	Block block = event.getBlockClicked().getRelative(event.getBlockFace());
	Player player = event.getPlayer();
	NovaPlayer nPlayer = PlayerManager.getPlayer(player);

	if(nPlayer.getPreferences().getBypass()) {
		return;
	}

	//Fluid protection
	NovaRegion fluidProtectRegion = null;
	for(NovaRegion region : plugin.getRegionManager().getRegions()) {
		if(!region.getWorld().equals(block.getWorld())) {
			continue;
		}

		Location centerLocation = region.getCenter().clone();
		Location blockLocation = block.getLocation().clone();
		centerLocation.setY(0);
		blockLocation.setY(0);

		if(blockLocation.distance(centerLocation) <= region.getDiagonal() / 2 + Config.REGION_FLUIDPROTECT.getInt()) {
			fluidProtectRegion = region;
			break;
		}
	}

	if((fluidProtectRegion != null
			&& (!nPlayer.hasGuild()
				|| (!fluidProtectRegion.getGuild().isMember(nPlayer)
					&& !fluidProtectRegion.getGuild().isAlly(nPlayer.getGuild()))))
			|| (RegionManager.get(block) != null
				&& (!plugin.getRegionManager().canInteract(player, block)
					|| !nPlayer.hasPermission(GuildPermission.BLOCK_PLACE)))) {
		event.setCancelled(true);
		Message.CHAT_REGION_DENY_INTERACT.send(player);
	}
}
 

private void doHome(Player p, User iu, Location homeLoc, Location curLoc) {
    if (iu.getWorld() != homeLoc.getWorld() && ess.getSettings().isWorldHomePermissions() && !iu.isAuthorized("essentials.worlds." + homeLoc.getWorld().getName())) {
        msg(p, "internal.error.no_required_permission", "essentials.worlds." + homeLoc.getWorld().getName());
        return;
    }

    double fee = plugin.cfg.homeBase;
    if (homeLoc.getWorld() != curLoc.getWorld()) {
        fee += plugin.cfg.homeWorld;
        fee += homeLoc.distance(PlayerSpawn(p, homeLoc.getWorld())) * (double) plugin.cfg.homeIncrement / plugin.cfg.homeDistance;
    } else {
        fee += homeLoc.distance(curLoc) * (double) plugin.cfg.homeIncrement / plugin.cfg.homeDistance;
    }
    if (fee > plugin.cfg.homeMax) fee = plugin.cfg.homeMax;
    fee = new BigDecimal(fee).setScale(2, BigDecimal.ROUND_HALF_DOWN).doubleValue();
    if (!VaultUtils.withdraw(p, fee)) {
        msg(p, "user.teleport.money_insufficient", fee);
        return;
    }
    try {
        iu.getTeleport().teleport(homeLoc, new Trade(0, ess), PlayerTeleportEvent.TeleportCause.PLUGIN);
        msg(p, "user.teleport.ok", fee, I18n.format("user.teleport.home"));
        if (plugin.systemBalance != null) {
            plugin.systemBalance.deposit(fee, plugin);
        }
    } catch (Exception e) {
        VaultUtils.deposit(p, fee);
        p.sendMessage(e.getMessage());
    }
}
 

private void doBack(Player p, User iu, Location curLoc, Location lastLoc) {
    if (iu.getWorld() != lastLoc.getWorld() && ess.getSettings().isWorldTeleportPermissions() && !iu.isAuthorized("essentials.worlds." + lastLoc.getWorld().getName())) {
        msg(p, "internal.error.no_required_permission", "essentials.worlds." + lastLoc.getWorld().getName());
        return;
    }

    double fee = plugin.cfg.backBase;
    if (curLoc.getWorld() != lastLoc.getWorld()) {
        fee += plugin.cfg.backWorld;
        fee += lastLoc.distance(PlayerSpawn(p, lastLoc.getWorld())) * (double) plugin.cfg.backIncrement / plugin.cfg.backDistance;
    } else {
        fee += lastLoc.distance(curLoc) * (double) plugin.cfg.backIncrement / plugin.cfg.backDistance;
    }
    if (fee > plugin.cfg.backMax) fee = plugin.cfg.backMax;
    fee = new BigDecimal(fee).setScale(2, BigDecimal.ROUND_HALF_DOWN).doubleValue();
    if (!VaultUtils.withdraw(p, fee)) {
        msg(p, "user.teleport.money_insufficient", fee);
        return;
    }
    try {
        iu.getTeleport().back(new Trade(0, ess));
        msg(p, "user.teleport.ok", fee, I18n.format("user.teleport.back"));
        if (plugin.systemBalance != null) {
            plugin.systemBalance.deposit(fee, plugin);
        }
    } catch (Exception e) {
        VaultUtils.deposit(p, fee);
        p.sendMessage(e.getMessage());
    }
}
 

default double distanceFrom(@Nullable Location deathLocation) {
    if(getOrigin() == null || deathLocation == null) return Double.NaN;

    // When players fall in the void, use y=0 as their death location
    if(deathLocation.getY() < 0) {
        deathLocation = deathLocation.clone();
        deathLocation.setY(0);
    }
    return deathLocation.distance(getOrigin());
}
 

public static void buildLightning(Location start, Vector direction, int entries, int branches, double radius, double offset, double offsetRate, double length, double lengthRate, double branch, double branchRate, Consumer<Location> action) {
    ThreadLocalRandom random = ThreadLocalRandom.current();
    if (entries <= 0) {
        return;
    }
    boolean inRange = true;
    while (random.nextDouble() < branch || inRange) {
        Vector randomizer = new Vector(random.nextDouble(-radius, radius), random.nextDouble(-radius, radius), random.nextDouble(-radius, radius)).normalize().multiply((random.nextDouble(-radius, radius)) * offset);
        Vector endVector = start.clone().toVector().add(direction.clone().multiply(length)).add(randomizer);
        Location end = endVector.toLocation(start.getWorld());
        if (end.distance(start) <= length) {
            inRange = true;
            continue;
        } else {
            inRange = false;
        }
        int rate = (int) (start.distance(end) / 0.1); // distance * (distance / 10)
        Vector rateDir = endVector.clone().subtract(start.toVector()).normalize().multiply(0.1);
        for (int i = 0; i < rate; i++) {
            Location loc = start.clone().add(rateDir.clone().multiply(i));
            action.accept(loc);
        }
        buildLightning(end.clone(), direction, entries - 1, branches - 1, radius, offset * offsetRate, offsetRate, length * lengthRate, lengthRate, branch * branchRate, branchRate, action);
        if (branches <= 0) {
            break;
        }
    }
}
 

private void swingProcessor(ArmSwingEvent e) {
    UUID uuid = e.getPlayer().getUniqueId();
    if (!lastAttacked.containsKey(uuid))
        return;

    HawkPlayer att = e.getHawkPlayer();
    HawkPlayer victim = lastAttacked.get(uuid);
    if (victim == null)
        return;
    long lastSwingTick = swingTick.getOrDefault(uuid, 0L);

    //proceed if victim's invulnerability is gone
    //diff between current client tick and last swing tick should never be negative
    //a bypass for this IS possible, but you'd get caught by TickRate if you try to change your tickrate
    if (att.getCurrentTick() - lastSwingTick >= victim.getPlayer().getMaximumNoDamageTicks() / 2) {

        Map<UUID, FightData> accuracyToVictim = accuracy.getOrDefault(uuid, new HashMap<>());
        FightData fightData = accuracyToVictim.getOrDefault(victim.getUuid(), new FightData());
        fightData.swings++;
        accuracyToVictim.put(victim.getUuid(), fightData);

        accuracy.put(uuid, accuracyToVictim);
        swingTick.put(uuid, att.getCurrentTick());
    }

    Location attackerLoc = new Location(att.getWorld(), att.getPosition().getX(), att.getPosition().getY(), att.getPosition().getZ(), att.getYaw(), att.getPitch());
    Location victimLoc = new Location(victim.getWorld(), victim.getPosition().getX(), victim.getPosition().getY(), victim.getPosition().getZ(), victim.getYaw(), victim.getPitch());

    //determine how far the opponent has moved horizontally on local coordinates and compute required mouse precision
    if(!attackerLoc.getWorld().equals(victimLoc.getWorld()))
        return;
    Vector victimVelocity = victim.getVelocity().clone().setY(0);
    Vector attackerDirection = att.getPlayer().getLocation().getDirection().clone().setY(0);
    double localMovement = MathPlus.sin((float)MathPlus.angle(victimVelocity, attackerDirection)) * victimVelocity.length();
    if(Double.isNaN(localMovement))
        localMovement = 0D;
    double requiredPrecision = localMovement * attackerLoc.distance(victimLoc);
    double effort = this.effort.getOrDefault(uuid, 0D);

    if(DEBUG) {
        if(requiredPrecision >= MIN_PRECISION_THRESHOLD && effort < EFFORT_THRESHOLD && effort + 0.02 >= EFFORT_THRESHOLD) {
            att.getPlayer().sendMessage(ChatColor.GREEN + "You are now eligible to be checked by fightaccuracy because your opponent is moving significantly.");
        }
        else if(requiredPrecision < MIN_PRECISION_THRESHOLD && effort >= EFFORT_THRESHOLD && effort - 0.01 < EFFORT_THRESHOLD) {
            att.getPlayer().sendMessage(ChatColor.RED + "You are no longer eligible to be checked by fightaccuracy because your opponent is not moving enough.");
        }
    }

    if (requiredPrecision >= MIN_PRECISION_THRESHOLD) {
        //increase effort
        this.effort.put(uuid, Math.min(effort + 0.02, 1));
    } else {
        //decrease effort
        this.effort.put(uuid, Math.max(effort - 0.01, 0));
    }
}
 

private void processDirection(InteractEntityEvent e, float yaw, float pitch) {
    Entity entity = e.getEntity();
    if (!(entity instanceof Player) && !CHECK_OTHER_ENTITIES)
        return;
    Player attacker = e.getPlayer();
    int ping = ServerUtils.getPing(attacker);
    if (ping > PING_LIMIT && PING_LIMIT != -1)
        return;

    HawkPlayer att = e.getHawkPlayer();
    Location attackerEyeLocation = att.getPosition().clone().add(new Vector(0, 1.62, 0)).toLocation(att.getWorld());
    Vector attackerDirection = MathPlus.getDirection(yaw, pitch);

    double maxReach = MAX_REACH;
    if (attacker.getGameMode() == GameMode.CREATIVE)
        maxReach += 1.9;

    Vector victimLocation;
    if (LAG_COMPENSATION)
        //No need to add 50ms; the move and attack are already chronologically so close together
        victimLocation = hawk.getLagCompensator().getHistoryLocation(ping, e.getEntity()).toVector();
    else
        victimLocation = e.getEntity().getLocation().toVector();

    Vector eyePos = new Vector(attackerEyeLocation.getX(), attacker.isSneaking() ? attackerEyeLocation.getY() - 0.08 : attackerEyeLocation.getY(), attackerEyeLocation.getZ());
    Vector direction = new Vector(attackerDirection.getX(), attackerDirection.getY(), attackerDirection.getZ());
    Ray attackerRay = new Ray(eyePos, direction);

    AABB victimAABB;
    victimAABB = WrappedEntity.getWrappedEntity(entity).getHitbox(victimLocation);
    victimAABB.expand(BOX_EPSILON, BOX_EPSILON, BOX_EPSILON);

    Vector intersectVec3d = victimAABB.intersectsRay(attackerRay, 0, Float.MAX_VALUE);

    if (DEBUG_HITBOX) {
        victimAABB.highlight(hawk, attacker.getWorld(), 0.29);
    }

    if (DEBUG_RAY) {
        attackerRay.highlight(hawk, attacker.getWorld(), maxReach, 0.1);
    }

    if (intersectVec3d != null) {
        Location intersect = new Location(attacker.getWorld(), intersectVec3d.getX(), intersectVec3d.getY(), intersectVec3d.getZ());
        double interDistance = intersect.distance(attackerEyeLocation);
        if (interDistance > maxReach) {
            punish(att, 1, true, e, new Placeholder("type", "Reach: " + MathPlus.round(interDistance, 2) + "m"));
            return;
        }
        if (CHECK_OCCLUSION && interDistance > 1D) {
            BlockIterator iter = new BlockIterator(attacker.getWorld(), eyePos, attackerDirection, 0, (int) interDistance + 1);
            while (iter.hasNext()) {
                Block bukkitBlock = iter.next();

                if (bukkitBlock.getType() == Material.AIR || bukkitBlock.isLiquid())
                    continue;

                WrappedBlock b = WrappedBlock.getWrappedBlock(bukkitBlock, att.getClientVersion());
                Vector intersection = b.getHitBox().intersectsRay(new Ray(attackerEyeLocation.toVector(), attackerDirection), 0, Float.MAX_VALUE);
                if (intersection != null) {
                    if (intersection.distance(eyePos) < interDistance) {
                        punish(att, 1, true, e, new Placeholder("type", "Interacted through " + b.getBukkitBlock().getType()));
                        return;
                    }
                }
            }

        }
    } else if (CHECK_BOX_INTERSECTION) {
        punish(att, 1, true, e, new Placeholder("type", "Did not hit hitbox."));
        return;
    }

    reward(att); //reward player
}
 

public static List<Location> getTargetsPathBlocked(Location tLoc, Location dLoc, boolean useOnlyMaterialListing, boolean ignoreFirstZone) {
    final ArrayList<Location> targetsInPath = new ArrayList<Location>();

    // check world
    if (!dLoc.getWorld().getName().equalsIgnoreCase(tLoc.getWorld().getName())) {
        return targetsInPath;
    }

    // if the distance is too close... the path is not blocked ;)
    if (dLoc.distance(tLoc) <= 0.9) {
        return targetsInPath;
    }

    // try to iterate through blocks between dLoc and tLoc
    try {
        // Create a vector block trace from the detonator location to damaged block's location
        final Location tarLoc = tLoc.clone().add(0, 0.25, 0);
        final BlockIterator blocksInPath = new BlockIterator(tarLoc.getWorld(), dLoc.toVector(), tarLoc.toVector().subtract(dLoc.toVector()).normalize(), 0.5, (int) dLoc.distance(tarLoc));

        // iterate through the blocks in the path
        int i = ConfigManager.getInstance().getRadius() + 1;
        int over = 0; // prevents rare case of infinite loop and server crash
        while (blocksInPath.hasNext() && over < 128) {
            if (i > 0) {
                i--;
            } else {
                break;
            }
            over++;

            // the next block
            final Block block = blocksInPath.next();
            if (block == null) {
                continue;
            }
            // check if next block is the target block
            if (tarLoc.getWorld().getName().equals(block.getWorld().getName()) &&
                    tarLoc.getBlockX() == block.getX() &&
                    tarLoc.getBlockY() == block.getY() &&
                    tarLoc.getBlockZ() == block.getZ()) {
                // ignore target block
                continue;
            }
            // Ignore first blocks next to explosion
            if (ignoreFirstZone && ((i >= ConfigManager.getInstance().getRadius() - 1) || (dLoc.distance(tarLoc) <= 1.5))) {
                if (i >= ConfigManager.getInstance().getRadius() - 1 && MaterialManager.getInstance().contains(block.getType().name(), block.getData())) {
                    targetsInPath.add(block.getLocation());
                }
                continue;
            }

            // check if the block material is being handled
            if (useOnlyMaterialListing) {
                // only handle for certain case as to not interfere with all explosions
                if (MaterialManager.getInstance().contains(block.getType().name(), block.getData())) {
                    targetsInPath.add(block.getLocation());
                    continue;
                } else {
                    continue;
                }
            }
            // check if the block material is a solid
            if (!isNonSolid(block.getType())) {
                targetsInPath.add(block.getLocation());
                if (targetsInPath.size() > 3) {
                    break;
                }
            }
        }
    } catch (Exception e) {
        // ignore the error and return no targets in path
    }
    return targetsInPath;
}
 

public static boolean isTargetsPathBlocked(Location tLoc, Location dLoc, boolean useOnlyMaterialListing) {

        // check world
        if (!dLoc.getWorld().getName().equalsIgnoreCase(tLoc.getWorld().getName())) {
            return false;
        }

        // if the distance is too close... the path is not blocked ;)
        if (dLoc.distance(tLoc) <= 0.9) {
            return false;
        }

        // try to iterate through blocks between dLoc and tLoc
        try {
            // Create a vector block trace from the detonator location to damaged block's location
            final BlockIterator blocksInPath = new BlockIterator(tLoc.getWorld(), dLoc.toVector(), tLoc.toVector().subtract(dLoc.toVector()).normalize(), 0.5, (int) dLoc.distance(tLoc));

            // iterate through the blocks in the path
            int over = 0; // prevents rare case of infinite loop and server crash
            while (blocksInPath.hasNext() && over < 128) {
                over++;
                // the next block
                final Block block = blocksInPath.next();
                if (block == null) {
                    continue;
                }
                // check if next block is the target block
                if (tLoc.getWorld().getName().equals(block.getWorld().getName()) &&
                        tLoc.getBlockX() == block.getX() &&
                        tLoc.getBlockY() == block.getY() &&
                        tLoc.getBlockZ() == block.getZ()) {
                    // ignore target block
                    continue;
                }

                // check if the block material is being handled
                if (useOnlyMaterialListing) {
                    // only handle for certain case as to not interfere with all explosions
                    if (MaterialManager.getInstance().contains(block.getType().name(), block.getData())) {
                        return true;
                    } else {
                        continue;
                    }
                }
                // check if the block material is a solid
                if (!isNonSolid(block.getType())) {
                    return true;
                }
            }
        } catch (Exception e) {
            // ignore the error and return no targets in path
        }
        return false;
    }
 

/**
 * Spawns a broken line that creates more and extended branches
 * as it gets closer to the end length.
 * This method doesn't support rotations. Use the direction instead.
 *
 * @param start      the starting point of the new branch. For the first call it's the same location as the displays location.
 * @param direction  the direction of the lightning. A simple direction would be {@code entity.getLocation().getDirection().normalize()}
 *                   For a simple end point direction would be {@code endLocation.toVector().subtract(start.toVector()).normalize()}
 * @param entries    the number of entries for the main lightning branch. Recommended is 20
 * @param branches   the maximum number of branches each entry can have. Recommended is 200
 * @param radius     the radius of the lightning branches. Recommended is 0.5
 * @param offset     the offset of the lightning branches. Recommended is 2
 * @param offsetRate the offset change rate of the lightning branches. Recommended is 1
 * @param length     the length of the lightning branch. Recommended is 1.5
 * @param lengthRate the length change rate of the lightning branch. Recommended is 1
 * @param branch     the chance of creating a new branch. Recommended is 0.1
 * @param branchRate the chance change of creating a new branch. Recommended is 1
 * @since 3.0.0
 */
public static void lightning(Location start, Vector direction, int entries, int branches, double radius,
                             double offset, double offsetRate,
                             double length, double lengthRate,
                             double branch, double branchRate, ParticleDisplay display) {
    ThreadLocalRandom random = ThreadLocalRandom.current();
    if (entries <= 0) return;
    boolean inRange = true;

    // Check if we can create new branches or the current branch
    // length is already in range.
    while (random.nextDouble() < branch || inRange) {
        // Break our straight line randomly.
        Vector randomizer = new Vector(
                random.nextDouble(-radius, radius), random.nextDouble(-radius, radius), random.nextDouble(-radius, radius))
                .normalize().multiply((random.nextDouble(-radius, radius)) * offset);
        Vector endVector = start.clone().toVector().add(direction.clone().multiply(length)).add(randomizer);
        Location end = endVector.toLocation(start.getWorld());

        // Check if the broken line length is in our max length range.
        if (end.distance(start) <= length) {
            inRange = true;
            continue;
        } else inRange = false;

        // Create particle points in our broken straight line.
        int rate = (int) (start.distance(end) / 0.1); // distance * (distance / 10)
        Vector rateDir = endVector.clone().subtract(start.toVector()).normalize().multiply(0.1);
        for (int i = 0; i < rate; i++) {
            Location loc = start.clone().add(rateDir.clone().multiply(i));
            display.spawn(loc);
        }

        // Create new entries if possible.
        lightning(end.clone(), direction, entries - 1, branches - 1, radius, offset * offsetRate, offsetRate,
                length * lengthRate, lengthRate,
                branch * branchRate, branchRate, display);
        // Check if the maximum number of branches has already been used for this entry.
        if (branches <= 0) break;
    }
}
 

public void process(HashSet<String> alreadyAnnounced) {
		count++;
		if (count < reportSeconds) {
			return;
		}
		
		count = 0;
		boolean empty = true;
		
		for (PlayerLocationCache pc : proximityComponent.tryGetNearbyPlayers(true)) {
			empty = false;
			scoutDebug("Inspecting player:"+pc.getName());
			Player player;
			try {
				player = CivGlobal.getPlayer(pc.getName());
			} catch (CivException e) {
				scoutDebug("not online?");
				return;
			}
			
			if (player.isOp()) {
				scoutDebug("player is op");
				continue;
			}
			
			Location center = this.getCenterLocation().getLocation();
			
			/* Do not re-announce players announced by other scout towers */
			if (alreadyAnnounced.contains(this.getCiv().getName()+":"+player.getName())) {
				scoutDebug("already announced:"+pc.getName());
				continue;
			}
			
			/* Always announce outlaws, so skip down to bottom. */
			String relationName = "";
			String relationColor = "";
			if (!this.getTown().isOutlaw(player.getName())) {
				/* do not announce residents in this civ */
				Resident resident = CivGlobal.getResident(player);
				if (resident != null && resident.hasTown() && resident.getCiv() == this.getCiv()) {
					scoutDebug("same civ");
					continue;
				}
				
				/* Only announce hostile, war, and neutral players */
				Relation.Status relation = this.getCiv().getDiplomacyManager().getRelationStatus(player);
				switch (relation) {
				case PEACE:
				case ALLY:
//				case VASSAL:
//				case MASTER:
					scoutDebug("ally or peace");
					continue;
				default:
					break;
				}
				
				relationName = relation.name();
				relationColor = Relation.getRelationColor(relation);
			} else {
				relationName = "OUTLAW";
				relationColor = CivColor.Yellow;
			}
			
			
			if (center.getWorld() != this.getCorner().getLocation().getWorld()) {
				scoutDebug("wrong world");
				continue;
			}
			
			if (center.distance(player.getLocation()) < range) {
				/* Notify the town or civ. */
					CivMessage.sendScout(this.getCiv(), "Scout tower detected "+relationColor+
							player.getName()+"("+relationName+")"+CivColor.White+
							" at ("+player.getLocation().getBlockX()+","+player.getLocation().getBlockY()+","+player.getLocation().getBlockZ()+") in "+
							this.getTown().getName());
					alreadyAnnounced.add(this.getCiv().getName()+":"+player.getName());
				
			}
		}
		
		if (empty) {
			scoutDebug("Proximity cache was empty");
		}
	}
 

@EventHandler(priority = EventPriority.HIGH)
public void onEntityExplode(EntityExplodeEvent event) {
		
	if (event.isCancelled()) {
		return;
	}
	
	if (!War.isWarTime()) {
		return;
	}
	
	if (event.getEntity() == null) {
		return;
	}
	
	if (event.getEntityType().equals(EntityType.UNKNOWN)) {
		return;
	}
	
	if (event.getEntityType().equals(EntityType.PRIMED_TNT) ||
			event.getEntityType().equals(EntityType.MINECART_TNT)) {
					
		int yield;
		try {
			yield = CivSettings.getInteger(CivSettings.warConfig, "cannon.yield");
		} catch (InvalidConfiguration e) {
			e.printStackTrace();
			return;
		}
	
		yield = yield / 2;
	
		for (int y = -yield; y <= yield; y++) {
			for (int x = -yield; x <= yield; x++) {
				for (int z = -yield; z <= yield; z++) {
					Location loc = event.getLocation().clone().add(new Vector(x,y,z));
				
					if (loc.distance(event.getLocation()) < yield) {
						WarRegen.saveBlock(loc.getBlock(), Cannon.RESTORE_NAME, false);
						ItemManager.setTypeIdAndData(loc.getBlock(), CivData.AIR, 0, false);
					}
				}	
			}
		}
		event.setCancelled(true);
	}
}
 

private void handleGrapplingHook(Arrow arrow) {
    if (arrow != null && arrow.isValid() && arrow.getShooter() instanceof Player) {
        Player p = (Player) arrow.getShooter();
        GrapplingHookEntity hook = activeHooks.get(p.getUniqueId());

        if (hook != null) {
            Location target = arrow.getLocation();
            hook.drop(target);

            Vector velocity = new Vector(0.0, 0.2, 0.0);

            if (p.getLocation().distance(target) < 3.0) {
                if (target.getY() <= p.getLocation().getY()) {
                    velocity = target.toVector().subtract(p.getLocation().toVector());
                }
            }
            else {
                Location l = p.getLocation();
                l.setY(l.getY() + 0.5);
                p.teleport(l);

                double g = -0.08;
                double d = target.distance(l);
                double t = d;
                double vX = (1.0 + 0.08 * t) * (target.getX() - l.getX()) / t;
                double vY = (1.0 + 0.04 * t) * (target.getY() - l.getY()) / t - 0.5D * g * t;
                double vZ = (1.0 + 0.08 * t) * (target.getZ() - l.getZ()) / t;

                velocity = p.getVelocity();
                velocity.setX(vX);
                velocity.setY(vY);
                velocity.setZ(vZ);
            }

            p.setVelocity(velocity);

            hook.remove();
            Slimefun.runSync(() -> activeHooks.remove(p.getUniqueId()), 20L);
        }
    }
}
 

public static int distanceFromSpawnLevelIncrease(Location location) {

        double distanceUnit = ConfigValues.mobCombatSettingsConfig.getDouble(MobCombatSettingsConfig.DISTANCE_TO_INCREMENT);
        double levelToIncrement = ConfigValues.mobCombatSettingsConfig.getDouble(MobCombatSettingsConfig.LEVEL_TO_INCREMENT);

        Location spawnLocation = location.getWorld().getSpawnLocation();
        Location entityLocation = location;

        double distanceFromSpawn = spawnLocation.distance(entityLocation);

        int levelIncrease = (int) (distanceFromSpawn / distanceUnit * levelToIncrement);

        return levelIncrease;

    }