Example #1
0
 @EventHandler
 public void onMove(PlayerMoveEvent event) {
   if (ConfigUtil.get().getConfig().getBoolean("tp-to-spawn")) {
     if (event.getTo().getY() <= 0) {
       Location teleportTo =
           LocationUtil.get()
               .deserialize(ConfigUtil.get().getConfig().getString("spawn.location"));
       event.getPlayer().teleport(teleportTo);
     }
   }
 }
	@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
	public void onPlayerMove(final PlayerMoveEvent event)
	{
		final IUser user = userMap.getUser(event.getPlayer());

		final ISettings settings = ess.getSettings();

		if (user.getData().isAfk() && settings.getData().getCommands().getAfk().isFreezeAFKPlayers())
		{
			final Location from = event.getFrom();
			final Location to = event.getTo().clone();
			to.setX(from.getX());
			to.setY(from.getY());
			to.setZ(from.getZ());
			try
			{
				event.setTo(LocationUtil.getSafeDestination(to));
			}
			catch (Exception ex)
			{
				event.setTo(to);
			}
			return;
		}

		final Location afk = user.getAfkPosition();
		if (afk == null || !event.getTo().getWorld().equals(afk.getWorld()) || afk.distanceSquared(event.getTo()) > 9)
		{
			user.updateActivity(true);
		}
	}
  @EventHandler
  public void onPlayerMove(PlayerMoveEvent event) {
    String playerName = event.getPlayer().getName();

    if (!moveCooldown.isOnCooldown(playerName)) {
      GamePlayer gamePlayer = FakeboardHandler.getPlayer(playerName);
      if (GameSetupHandler.isGameInProgress()) {
        // TODO prevent the null check from being needed
        if (gamePlayer != null && gamePlayer.isAfk()) {
          gamePlayer.setAfk(false, false);
        }
      }
      moveCooldown.setOnCooldown(playerName);
    }
  }
 @EventHandler(priority = EventPriority.HIGH)
 public void onPlayerMove(PlayerMoveEvent event) {
   if (event.isCancelled()) return;
   if (AFKUtils.isAfk(event.getPlayer())) {
     AFKUtils.unsetAfk(event.getPlayer());
     plugin.getServer().broadcastMessage(event.getPlayer().getName() + " is no longer AFK.");
     return;
   }
   if (PConfManager.getPValBoolean(event.getPlayer(), "frozen")) event.setCancelled(true);
 }
Example #5
0
  public void a(Packet10Flying packet10flying) {
    WorldServer worldserver = this.minecraftServer.a(this.player.dimension);

    this.i = true;
    double d0;

    if (!this.m) {
      d0 = packet10flying.y - this.y;
      if (packet10flying.x == this.x && d0 * d0 < 0.01D && packet10flying.z == this.z) {
        this.m = true;
      }
    }

    // CraftBukkit start
    Player player = getPlayer();
    Location from =
        new Location(player.getWorld(), lastPosX, lastPosY, lastPosZ, lastYaw, lastPitch);
    Location to = player.getLocation();

    // Prevent 40 event-calls for less than b single pixel of movement >.>
    double delta =
        Math.pow(this.lastPosX - this.x, 2)
            + Math.pow(this.lastPosY - this.y, 2)
            + Math.pow(this.lastPosZ - this.z, 2);
    float deltaAngle =
        Math.abs(this.lastYaw - this.player.yaw) + Math.abs(this.lastPitch - this.player.pitch);

    if (delta > 1f / 256 || deltaAngle > 10f) {
      // Skip the first time we do this
      if (lastPosX != Double.MAX_VALUE) {
        PlayerMoveEvent event = new PlayerMoveEvent(player, from, to);
        server.getPluginManager().callEvent(event);

        from = event.getFrom();
        to = event.isCancelled() ? from : event.getTo();

        this.player.locX = to.getX();
        this.player.locY = to.getY();
        this.player.locZ = to.getZ();
        this.player.yaw = to.getYaw();
        this.player.pitch = to.getPitch();
      }

      this.lastPosX = this.player.locX;
      this.lastPosY = this.player.locY;
      this.lastPosZ = this.player.locZ;
      this.lastYaw = this.player.yaw;
      this.lastPitch = this.player.pitch;
    }

    if (Math.abs(packet10flying.x) > 32000000 || Math.abs(packet10flying.z) > 32000000) {
      player.teleport(player.getWorld().getSpawnLocation());
      System.err.println(
          player.getName() + " was caught trying to crash the server with an invalid position.");
      player.kickPlayer("Nope!");
      return;
    }

    if (Double.isNaN(packet10flying.x)
        || packet10flying.x == Double.POSITIVE_INFINITY
        || packet10flying.x == Double.NEGATIVE_INFINITY) {
      player.teleport(player.getWorld().getSpawnLocation());
      System.err.println(player.getName() + " was caught trying to set an invalid position.");
      player.kickPlayer("Nope!");
      return;
    }

    if (Double.isNaN(packet10flying.y)
        || packet10flying.y == Double.POSITIVE_INFINITY
        || packet10flying.y == Double.NEGATIVE_INFINITY) {
      player.teleport(player.getWorld().getSpawnLocation());
      System.err.println(player.getName() + " was caught trying to set an invalid position.");
      player.kickPlayer("Nope!");
      return;
    }

    if (Double.isNaN(packet10flying.z)
        || packet10flying.z == Double.POSITIVE_INFINITY
        || packet10flying.z == Double.NEGATIVE_INFINITY) {
      player.teleport(player.getWorld().getSpawnLocation());
      System.err.println(player.getName() + " was caught trying to set an invalid position.");
      player.kickPlayer("Nope!");
      return;
    }

    if (Double.isNaN(packet10flying.stance)
        || packet10flying.stance == Double.POSITIVE_INFINITY
        || packet10flying.stance == Double.NEGATIVE_INFINITY) {
      player.teleport(player.getWorld().getSpawnLocation());
      System.err.println(player.getName() + " was caught trying to set an invalid position.");
      player.kickPlayer("Nope!");
      return;
    }

    if (this.m && !this.player.dead) {
      // CraftBukkit end
      double d1;
      double d2;
      double d3;
      double d4;

      if (this.player.vehicle != null) {
        float f = this.player.yaw;
        float f1 = this.player.pitch;

        this.player.vehicle.f();
        d1 = this.player.locX;
        d2 = this.player.locY;
        d3 = this.player.locZ;
        double d5 = 0.0D;

        d4 = 0.0D;
        if (packet10flying.hasLook) {
          f = packet10flying.yaw;
          f1 = packet10flying.pitch;
        }

        if (packet10flying.h && packet10flying.y == -999.0D && packet10flying.stance == -999.0D) {
          d5 = packet10flying.x;
          d4 = packet10flying.z;
        }

        this.player.onGround = packet10flying.g;
        this.player = this.player.a(true); // CraftBukkit
        this.player.move(d5, 0.0D, d4);
        this.player.setLocation(d1, d2, d3, f, f1);
        this.player.motX = d5;
        this.player.motZ = d4;
        if (this.player.vehicle != null) {
          worldserver.vehicleEnteredWorld(this.player.vehicle, true);
        }

        if (this.player.vehicle != null) {
          this.player.vehicle.f();
        }

        this.minecraftServer.serverConfigurationManager.d(this.player);
        this.x = this.player.locX;
        this.y = this.player.locY;
        this.z = this.player.locZ;
        worldserver.playerJoinedWorld(this.player);
        return;
      }

      d0 = this.player.locY;
      this.x = this.player.locX;
      this.y = this.player.locY;
      this.z = this.player.locZ;
      d1 = this.player.locX;
      d2 = this.player.locY;
      d3 = this.player.locZ;
      float f2 = this.player.yaw;
      float f3 = this.player.pitch;

      if (packet10flying.h && packet10flying.y == -999.0D && packet10flying.stance == -999.0D) {
        packet10flying.h = false;
      }

      if (packet10flying.h) {
        d1 = packet10flying.x;
        d2 = packet10flying.y;
        d3 = packet10flying.z;
        d4 = packet10flying.stance - packet10flying.y;
        if (!this.player.isSleeping() && (d4 > 1.65D || d4 < 0.1D)) {
          this.disconnect("Illegal stance");
          a.warning(this.player.name + " had an illegal stance: " + d4);
          return;
        }

        if (Math.abs(packet10flying.x) > 3.2E7D || Math.abs(packet10flying.z) > 3.2E7D) {
          this.disconnect("Illegal position");
          return;
        }
      }

      if (packet10flying.hasLook) {
        f2 = packet10flying.yaw;
        f3 = packet10flying.pitch;
      }

      this.player.a(true);
      this.player.br = 0.0F;
      this.player.setLocation(this.x, this.y, this.z, f2, f3);
      if (!this.m) {
        return;
      }

      d4 = d1 - this.player.locX;
      double d6 = d2 - this.player.locY;
      double d7 = d3 - this.player.locZ;
      double d8 = d4 * d4 + d6 * d6 + d7 * d7;

      // CraftBukkit start - make the movement speed check behave properly under tick degradation.
      int elapsedTicks = MinecraftServer.currentTick - this.lastTick;
      // Added this.m condition to solve this check being triggered by teleports
      if (d8 > 100.0D * (elapsedTicks <= 0 ? 1 : elapsedTicks) && this.m) {
        a.warning(
            this.player.name
                + " moved too quickly! Elapsed ticks: "
                + (elapsedTicks == 0 ? 1 : elapsedTicks)
                + ", Distance change: "
                + d8);
        this.disconnect("You moved too quickly :( (Hacking?)");
        return;
      }
      this.lastTick = MinecraftServer.currentTick;
      // CraftBukkit end

      float f4 = 0.0625F;
      boolean flag =
          worldserver
                  .getEntities(
                      this.player,
                      this.player.boundingBox.clone().shrink((double) f4, (double) f4, (double) f4))
                  .size()
              == 0;

      this.player.move(d4, d6, d7);
      d4 = d1 - this.player.locX;
      d6 = d2 - this.player.locY;
      if (d6 > -0.5D || d6 < 0.5D) {
        d6 = 0.0D;
      }

      d7 = d3 - this.player.locZ;
      d8 = d4 * d4 + d6 * d6 + d7 * d7;
      boolean flag1 = false;

      if (d8 > 0.0625D && !this.player.isSleeping()) {
        flag1 = true;
        a.warning(this.player.name + " moved wrongly!");
        System.out.println("Got position " + d1 + ", " + d2 + ", " + d3);
        System.out.println(
            "Expected " + this.player.locX + ", " + this.player.locY + ", " + this.player.locZ);
      }

      this.player.setLocation(d1, d2, d3, f2, f3);
      boolean flag2 =
          worldserver
                  .getEntities(
                      this.player,
                      this.player.boundingBox.clone().shrink((double) f4, (double) f4, (double) f4))
                  .size()
              == 0;

      if (flag && (flag1 || !flag2) && !this.player.isSleeping()) {
        this.a(this.x, this.y, this.z, f2, f3);
        return;
      }

      AxisAlignedBB axisalignedbb =
          this.player
              .boundingBox
              .clone()
              .b((double) f4, (double) f4, (double) f4)
              .a(0.0D, -0.55D, 0.0D);

      if (!this.minecraftServer.o && !worldserver.b(axisalignedbb)) {
        if (d6 >= -0.03125D) {
          ++this.h;
          if (this.h > 80) {
            a.warning(this.player.name + " was kicked for floating too long!");
            this.disconnect("Flying is not enabled on this server");
            return;
          }
        }
      } else {
        this.h = 0;
      }

      this.player.onGround = packet10flying.g;
      this.minecraftServer.serverConfigurationManager.d(this.player);
      this.player.b(this.player.locY - d0, packet10flying.g);
    }
  }
Example #6
0
  @EventHandler
  public void onPlayerMove(PlayerMoveEvent e) {
    Player p = e.getPlayer();
    Location loc =
        new Location(
            e.getTo().getWorld(),
            (int) e.getTo().getX(),
            (int) e.getTo().getY(),
            (int) e.getTo().getZ());
    if (Main.getInstance().redSpawnArea.contains(loc)) {
      Bukkit.getPluginManager().callEvent(new AreaWalkEvent(Area.RED_SPAWN, p));
    }
    if (Main.getInstance().blueSpawnArea.contains(loc)) {
      Bukkit.getPluginManager().callEvent(new AreaWalkEvent(Area.BLUE_SPAWN, p));
    }
    if (Main.getInstance().blockspawnAreas.contains(loc)) {
      Bukkit.getPluginManager().callEvent(new AreaWalkEvent(getArea(loc), p));
    }
    if (blockManager.canPickUpBlock(p)) {
      blockManager.pickUpBlock(p);
    }
    if (canGetNeededBlock(p)) {
      if (p.getGameMode() == GameMode.SURVIVAL) {
        gameManager.setCarrying(p, nexusManager.getCurrentNexusColor());
        String[] data = neededBlockMaterial.split(";");
        neededBlock
            .getBlock()
            .setTypeIdAndData(Integer.valueOf(data[0]), Byte.valueOf(data[1]), false);
        neededBlock = new Location(Bukkit.getWorlds().get(0), 0, 0, 0);

        Bukkit.broadcastMessage(
            Color.np(
                "&6The needed block was picked up by the "
                    + teamManager.getTeam(p).getTeamName()
                    + "&6 team!"));
      }
    }
    if ((int) e.getFrom().getX() != (int) e.getTo().getX()
        || (int) e.getFrom().getZ() != (int) e.getTo().getZ()
        || (int) e.getFrom().getY() != (int) e.getTo().getY()) {
      if (getTurret(loc) != null) {
        Bukkit.getPluginManager().callEvent(new TurretWalkEvent(p, getTurret(loc)));
      }
      if (isInTurret(p)) {
        Turret t = getTurret(p);
        if (t.containsUser()) {
          e.getPlayer().teleport(e.getFrom());
        }
      }
    }
    if ((int) e.getFrom().getX() != (int) e.getTo().getX()
        || (int) e.getFrom().getZ() != (int) e.getTo().getZ()) {
      if (!released || stunned.contains(p.getName())) {
        if (GameState.getState() == GameState.INGAME) {
          e.getPlayer().teleport(e.getFrom());
        }
      }
    }
  }
  @EventHandler(priority = EventPriority.NORMAL)
  public void onPlayerMove(PlayerMoveEvent event) {
    if (!TFM_AdminWorld.getInstance().validateMovement(event)) {
      return;
    }

    Player p = event.getPlayer();
    TFM_PlayerData playerdata = TFM_PlayerData.getPlayerData(p);

    for (Entry<Player, Double> fuckoff : TotalFreedomMod.fuckoffEnabledFor.entrySet()) {
      Player fuckoff_player = fuckoff.getKey();

      if (fuckoff_player.equals(p) || !fuckoff_player.isOnline()) {
        continue;
      }

      double fuckoff_range = fuckoff.getValue().doubleValue();

      Location mover_pos = p.getLocation();
      Location fuckoff_pos = fuckoff_player.getLocation();

      double distanceSquared;
      try {
        distanceSquared = mover_pos.distanceSquared(fuckoff_pos);
      } catch (IllegalArgumentException ex) {
        continue;
      }

      if (distanceSquared < (fuckoff_range * fuckoff_range)) {
        event.setTo(
            fuckoff_pos
                .clone()
                .add(
                    mover_pos
                        .subtract(fuckoff_pos)
                        .toVector()
                        .normalize()
                        .multiply(fuckoff_range * 1.1)));
        break;
      }
    }

    boolean do_freeze = false;
    if (TotalFreedomMod.allPlayersFrozen) {
      if (!TFM_SuperadminList.isUserSuperadmin(p)) {
        do_freeze = true;
      }
    } else {
      if (playerdata.isFrozen()) {
        do_freeze = true;
      }
    }

    if (do_freeze) {
      Location from = event.getFrom();
      Location to = event.getTo().clone();

      to.setX(from.getX());
      to.setY(from.getY());
      to.setZ(from.getZ());

      event.setTo(to);
    }

    if (playerdata.isCaged()) {
      Location target_pos = p.getLocation().add(0, 1, 0);

      boolean out_of_cage;
      if (!target_pos.getWorld().equals(playerdata.getCagePos().getWorld())) {
        out_of_cage = true;
      } else {
        out_of_cage = target_pos.distanceSquared(playerdata.getCagePos()) > (2.5 * 2.5);
      }

      if (out_of_cage) {
        playerdata.setCaged(
            true,
            target_pos,
            playerdata.getCageMaterial(TFM_PlayerData.CageLayer.OUTER),
            playerdata.getCageMaterial(TFM_PlayerData.CageLayer.INNER));
        playerdata.regenerateHistory();
        playerdata.clearHistory();
        TFM_Util.buildHistory(target_pos, 2, playerdata);
        TFM_Util.generateCube(
            target_pos, 2, playerdata.getCageMaterial(TFM_PlayerData.CageLayer.OUTER));
        TFM_Util.generateCube(
            target_pos, 1, playerdata.getCageMaterial(TFM_PlayerData.CageLayer.INNER));
      }
    }

    if (playerdata.isOrbiting()) {
      if (p.getVelocity().length() < playerdata.orbitStrength() * (2.0 / 3.0)) {
        p.setVelocity(new Vector(0, playerdata.orbitStrength(), 0));
      }
    }

    if (TotalFreedomMod.landminesEnabled && TotalFreedomMod.allowExplosions) {
      Iterator<TFM_LandmineData> landmines = TFM_LandmineData.landmines.iterator();
      while (landmines.hasNext()) {
        TFM_LandmineData landmine = landmines.next();

        Location landmine_pos = landmine.landmine_pos;
        if (landmine_pos.getBlock().getType() != Material.TNT) {
          landmines.remove();
          continue;
        }

        if (!landmine.player.equals(p)) {
          if (p.getWorld().equals(landmine_pos.getWorld())) {
            if (p.getLocation().distanceSquared(landmine_pos)
                <= (landmine.radius * landmine.radius)) {
              landmine.landmine_pos.getBlock().setType(Material.AIR);

              TNTPrimed tnt1 = landmine_pos.getWorld().spawn(landmine_pos, TNTPrimed.class);
              tnt1.setFuseTicks(40);
              tnt1.setPassenger(p);
              tnt1.setVelocity(new Vector(0.0, 2.0, 0.0));

              TNTPrimed tnt2 = landmine_pos.getWorld().spawn(p.getLocation(), TNTPrimed.class);
              tnt2.setFuseTicks(1);

              p.setGameMode(GameMode.SURVIVAL);
              landmines.remove();
            }
          }
        }
      }
    }
  }
  @EventHandler(priority = EventPriority.NORMAL)
  public void onPlayerMove(PlayerMoveEvent event) {
    final Location from = event.getFrom();
    final Location to = event.getTo();
    try {
      if (from.getWorld() == to.getWorld() && from.distanceSquared(to) < (0.0001 * 0.0001)) {
        // If player just rotated, but didn't move, don't process this event.
        return;
      }
    } catch (IllegalArgumentException ex) {
    }

    if (!TFM_AdminWorld.getInstance().validateMovement(event)) {
      return;
    }

    Player player = event.getPlayer();
    TFM_PlayerData playerdata = TFM_PlayerData.getPlayerData(player);

    for (Entry<Player, Double> fuckoff : TotalFreedomMod.fuckoffEnabledFor.entrySet()) {
      Player fuckoffPlayer = fuckoff.getKey();

      if (fuckoffPlayer.equals(player) || !fuckoffPlayer.isOnline()) {
        continue;
      }

      double fuckoffRange = fuckoff.getValue().doubleValue();

      Location playerLocation = player.getLocation();
      Location fuckoffLocation = fuckoffPlayer.getLocation();

      double distanceSquared;
      try {
        distanceSquared = playerLocation.distanceSquared(fuckoffLocation);
      } catch (IllegalArgumentException ex) {
        continue;
      }

      if (distanceSquared < (fuckoffRange * fuckoffRange)) {
        event.setTo(
            fuckoffLocation
                .clone()
                .add(
                    playerLocation
                        .subtract(fuckoffLocation)
                        .toVector()
                        .normalize()
                        .multiply(fuckoffRange * 1.1)));
        break;
      }
    }

    boolean freeze = false;
    if (TotalFreedomMod.allPlayersFrozen) {
      if (!TFM_AdminList.isSuperAdmin(player)) {
        freeze = true;
      }
    } else {
      if (playerdata.isFrozen()) {
        freeze = true;
      }
    }

    if (freeze) {
      Location freezeTo = to.clone();

      freezeTo.setX(from.getX());
      freezeTo.setY(from.getY());
      freezeTo.setZ(from.getZ());

      event.setTo(freezeTo);
    }

    if (playerdata.isCaged()) {
      Location targetPos = player.getLocation().add(0, 1, 0);

      boolean outOfCage;
      if (!targetPos.getWorld().equals(playerdata.getCagePos().getWorld())) {
        outOfCage = true;
      } else {
        outOfCage = targetPos.distanceSquared(playerdata.getCagePos()) > (2.5 * 2.5);
      }

      if (outOfCage) {
        playerdata.setCaged(
            true,
            targetPos,
            playerdata.getCageMaterial(TFM_PlayerData.CageLayer.OUTER),
            playerdata.getCageMaterial(TFM_PlayerData.CageLayer.INNER));
        playerdata.regenerateHistory();
        playerdata.clearHistory();
        TFM_Util.buildHistory(targetPos, 2, playerdata);
        TFM_Util.generateHollowCube(
            targetPos, 2, playerdata.getCageMaterial(TFM_PlayerData.CageLayer.OUTER));
        TFM_Util.generateCube(
            targetPos, 1, playerdata.getCageMaterial(TFM_PlayerData.CageLayer.INNER));
      }
    }

    if (playerdata.isOrbiting()) {
      if (player.getVelocity().length() < playerdata.orbitStrength() * (2.0 / 3.0)) {
        player.setVelocity(new Vector(0, playerdata.orbitStrength(), 0));
      }
    }

    if (TFM_Jumppads.getInstance().getMode().isOn()) {
      TFM_Jumppads.getInstance().PlayerMoveEvent(event);
    }

    if (!(TFM_ConfigEntry.LANDMINES_ENABLED.getBoolean()
        && TFM_ConfigEntry.ALLOW_EXPLOSIONS.getBoolean())) {
      return;
    }

    Iterator<Command_landmine.TFM_LandmineData> landmines =
        Command_landmine.TFM_LandmineData.landmines.iterator();
    while (landmines.hasNext()) {
      Command_landmine.TFM_LandmineData landmine = landmines.next();

      Location location = landmine.location;
      if (location.getBlock().getType() != Material.TNT) {
        landmines.remove();
        continue;
      }

      if (landmine.player.equals(player)) {
        break;
      }

      if (!player.getWorld().equals(location.getWorld())) {
        break;
      }

      if (!(player.getLocation().distanceSquared(location)
          <= (landmine.radius * landmine.radius))) {
        break;
      }

      landmine.location.getBlock().setType(Material.AIR);

      TNTPrimed tnt1 = location.getWorld().spawn(location, TNTPrimed.class);
      tnt1.setFuseTicks(40);
      tnt1.setPassenger(player);
      tnt1.setVelocity(new Vector(0.0, 2.0, 0.0));

      TNTPrimed tnt2 = location.getWorld().spawn(player.getLocation(), TNTPrimed.class);
      tnt2.setFuseTicks(1);

      player.setGameMode(GameMode.SURVIVAL);
      landmines.remove();
    }
  }
Example #9
0
 public void onPlayerChat(PlayerMoveEvent event) {
   Player player = event.getPlayer();
   String playerName = player.getName();
   plugin.users.put(playerName, System.currentTimeMillis());
 }
 @EventHandler
 public void afk(PlayerMoveEvent e) {
   AFKUtils.setLastMove(e.getPlayer(), new Date().getTime());
 }