Пример #1
0
 private void changeMap(String newMap) {
   World newWorld;
   if (Bukkit.getWorld(newMap) != null) {
     newWorld = Bukkit.getWorld(newMap);
     setCurrentMap(newWorld.getName());
     setCurrentWorld(newWorld);
     if (Main.getInstance().getConfig().getBoolean("TPPlayers")) {
       broadcast(Msg.getMessage("MAP_CHANGED_PLAYERS_TPED").replace("mapname", newMap));
       for (Player p : Bukkit.getOnlinePlayers()) {
         p.setNoDamageTicks(2 * 20);
         p.teleport(currentWorld.getSpawnLocation());
       }
     } else {
       broadcast(Msg.getMessage("MAP_CHANGED").replace("mapname", newMap));
     }
   } else {
     broadcast(Msg.getMessage("ERROR_CHANING_MAP").replace("mapname", newMap));
     return;
   }
 }
  /* (non-Javadoc)
   * @see org.bukkit.event.player.PlayerListener#onPlayerMove(org.bukkit.event.player.PlayerMoveEvent)
   */
  @Override
  public void onPlayerMove(PlayerMoveEvent event) {
    Player p = event.getPlayer();
    Location l = event.getTo();
    Block ch = l.getWorld().getBlockAt(l.getBlockX(), l.getBlockY(), l.getBlockZ());
    Stargate st = StargateManager.getGateFromBlock(ch);

    if (st != null && st.Active && st.Target != null) {
      String gatenetwork;
      if (st.Network != null) {
        gatenetwork = st.Network.netName;
      } else {
        gatenetwork = "Public";
      }
      wxt.prettyLog(
          Level.FINE,
          false,
          "Player in gate:"
              + st.Name
              + " gate Active: "
              + st.Active
              + " Target Gate: "
              + st.Target.Name
              + " Network: "
              + gatenetwork);

      if (ConfigManager.getWormholeUseIsTeleport()
          && ((st.IsSignPowered && !WXPermissions.checkWXPermissions(p, st, PermissionType.SIGN))
              || (!st.IsSignPowered
                  && !WXPermissions.checkWXPermissions(p, st, PermissionType.DIALER)))) {
        p.sendMessage(ConfigManager.output_strings.get(StringTypes.PERMISSION_NO));
        return;
      }
      if (st.Target.IrisActive) {
        p.sendMessage(ConfigManager.errorheader + "Remote Iris is locked!");
        p.setNoDamageTicks(2);
        event.setFrom(st.TeleportLocation);
        event.setTo(st.TeleportLocation);
        p.teleport(st.TeleportLocation);
        if (p.getFireTicks() > 0) {
          p.setFireTicks(0);
        }
        return;
      }

      Location target = st.Target.TeleportLocation;
      if (WormholeXTreme.iconomy != null) {
        double cost = ConfigManager.getIconomyWormholeUseCost();
        if (!ConfigManager.getIconomyOpsExcempt()
            && !p.isOp()
            && cost != 0.0
            && st.Owner != null
            && !st.Owner.equals(p.getName())) {
          Account player_account = iConomy.getBank().getAccount(p.getName());
          double balance = player_account.getBalance();
          String currency = iConomy.getBank().getCurrency();
          if (balance >= cost) {
            player_account.subtract(cost);
            // player_account.save();
            p.sendMessage(
                ConfigManager.normalheader
                    + "Wormhole Use \u00A7F- \u00A72"
                    + cost
                    + " \u00A77"
                    + currency);
            // p.sendMessage("You were charged " + cost + " " + iConomy.getBank().getCurrency() + "
            // to use wormhole." );
            double owner_percent = ConfigManager.getIconomyWormholeOwnerPercent();

            if (owner_percent != 0.0 && st.Owner != null) {
              if (st.Owner != null && iConomy.getBank().hasAccount(st.Owner)) {
                Account own_acc = iConomy.getBank().getAccount(st.Owner);
                own_acc.add(cost * owner_percent);
                // own_acc.save();
              }
            }
          } else {
            p.sendMessage(
                ConfigManager.errorheader
                    + "Not enough "
                    + currency
                    + "! - Requires: \u00A72"
                    + cost
                    + " \u00A77- Available: \u00A74"
                    + player_account.getBalance()
                    + " \u00A77"
                    + currency);
            // p.sendMessage("Not enough " + iConomy.getBank().getCurrency() + " to use - requires:
            // " + cost);
            target = st.TeleportLocation;
          }
        }
      }

      Block target_block =
          target.getWorld().getBlockAt(target.getBlockX(), target.getBlockY(), target.getBlockZ());
      while (target_block.getType() != Material.AIR
          && target_block.getType() != Material.WATER
          && target_block.getType() != Material.LAVA) {
        target_block = target_block.getFace(BlockFace.UP);
        target.setY(target.getY() + 1.0);
      }
      event.setFrom(target);
      event.setTo(target);
      p.setNoDamageTicks(2);
      p.teleport(target);
      event.setCancelled(true);
      if (target == st.Target.TeleportLocation)
        wxt.prettyLog(
            Level.INFO,
            false,
            p.getDisplayName() + " used wormhole: " + st.Name + " to go to: " + st.Target.Name);

      if (ConfigManager.getTimeoutShutdown() == 0) {
        st.ShutdownStargate();
      }
    } else if (st != null) {
      wxt.prettyLog(
          Level.FINE, false, "Player entered gate but wasn't active or didn't have a target.");
    }
  }
Пример #3
0
 @Override
 public void setNoDamageTicks(int ticks) {
   caller.setNoDamageTicks(ticks);
 }
Пример #4
0
  public void unload() {
    final Player player = Bukkit.getPlayerExact(name);

    if (player == null) {
      final ArenaPlayer aPlayer = ArenaPlayer.parsePlayer(name);
      PVPArena.instance.getAgm().disconnect(aPlayer.getArena(), aPlayer);
      return;
    }
    debug.i("restoring PlayerState of " + name, player);

    player.setFireTicks(fireticks);
    player.setFoodLevel(foodlevel);
    player.setGameMode(GameMode.getByValue(gamemode));

    final ArenaPlayer aPlayer = ArenaPlayer.parsePlayer(player.getName());
    player.setFoodLevel(foodlevel);
    if (player.getMaxHealth() != maxhealth) {
      final double newHealth = player.getMaxHealth() * health / maxhealth;
      if (newHealth > player.getMaxHealth()) {
        player.setHealth(player.getMaxHealth());
      } else {
        player.setHealth(newHealth);
      }

    } else {
      player.setHealth(health);
    }
    player.setSaturation(saturation);
    player.setGameMode(GameMode.getByValue(gamemode));
    player.setLevel(explevel);
    player.setExp(experience);
    player.setExhaustion(exhaustion);
    player.setFallDistance(0);
    player.setVelocity(new Vector());
    if (aPlayer.getArena() != null
        && aPlayer.getArena().getArenaConfig().getBoolean(CFG.CHAT_COLORNICK)) {
      player.setDisplayName(displayname);
    }

    if (aPlayer.getArena() != null) {

      ArenaModuleManager.unload(aPlayer.getArena(), player);
      PVPArena.instance.getAgm().unload(aPlayer.getArena(), player);
    }

    removeEffects(player);
    player.addPotionEffects(potionEffects);

    aPlayer.setTelePass(false);
    player.setFireTicks(fireticks);

    if (aPlayer.getArena() != null) {
      player.setNoDamageTicks(
          aPlayer.getArena().getArenaConfig().getInt(CFG.TIME_TELEPORTPROTECT) * 20);
    }
    player.resetPlayerTime();
    if (flying && !player.getAllowFlight()) {
      player.setAllowFlight(true);
    }
    player.setFlying(flying);
  }
Пример #5
0
  public void disableRocketBoots(
      Player player,
      Boolean keepUsage,
      Boolean keepPower,
      Boolean keepFlight,
      Boolean keepVariant,
      Boolean keepEnhancement) {

    UUID playerUUID = player.getUniqueId();

    if (!keepUsage && RocketInit.rocketUsage.contains(playerUUID))
      RocketInit.rocketUsage.remove(playerUUID);

    if (RocketInit.rocketSprint.containsKey(playerUUID)) RocketInit.rocketSprint.remove(playerUUID);

    if (!keepPower && RocketInit.rocketPower.containsKey(playerUUID))
      RocketInit.rocketPower.remove(playerUUID);

    if (!RocketInit.rocketFire.isEmpty()) RocketInit.rocketFire.clear();

    if (RocketInit.rocketWater.contains(playerUUID)) RocketInit.rocketWater.remove(playerUUID);

    if (RocketInit.rocketRepair.containsKey(playerUUID)) RocketInit.rocketRepair.remove(playerUUID);

    if (!keepEnhancement && RocketInit.rocketEnhancement.containsKey(playerUUID))
      RocketInit.rocketEnhancement.remove(playerUUID);

    if (!keepVariant && RocketInit.rocketVariant.containsKey(playerUUID)) {

      switch (RocketInit.rocketVariant.get(playerUUID)) {
        case ENDER:
          player.removePotionEffect(PotionEffectType.NIGHT_VISION);
          player.removePotionEffect(PotionEffectType.HEALTH_BOOST);
          break;

        case ZERO:
          player.removePotionEffect(PotionEffectType.CONFUSION);
          player.removePotionEffect(PotionEffectType.DAMAGE_RESISTANCE);
          player.removePotionEffect(PotionEffectType.INCREASE_DAMAGE);
          break;

        case STEALTH:
          for (Player onlinePlayer : Bukkit.getOnlinePlayers()) onlinePlayer.showPlayer(player);
          break;

        case DRUNK:
          player.removePotionEffect(PotionEffectType.CONFUSION);
          player.removePotionEffect(PotionEffectType.FAST_DIGGING);
          break;

        case BOOST:
          player.removePotionEffect(PotionEffectType.HEAL);
          break;

        case RUNNER:
          player.removePotionEffect(PotionEffectType.SPEED);
          break;
      }

      RocketInit.rocketVariant.remove(playerUUID);
    }

    if (player.isOnline() && gamemodeCheck.check(player, GameMode.SURVIVAL, GameMode.ADVENTURE)) {

      for (Player onlinePlayer : Bukkit.getOnlinePlayers()) onlinePlayer.showPlayer(player);

      player.setFlySpeed(0.1f);
      player.setFlying(false);
      if (!keepFlight) player.setAllowFlight(false);

      player.setNoDamageTicks(100);
      player.setFallDistance(0);
    }
  }
  @Override
  public void onPlayerTeleport(PlayerTeleportEvent event) {
    if (event.isCancelled()) return;

    Location locFrom = event.getFrom();
    Location locTo = event.getTo();

    Player player = event.getPlayer();
    // No more processing if the player isn't invisible
    if (!plugin.isPlayerInvisible(player.getName())) {
      plugin.scheduler.scheduleSyncDelayedTask(
          plugin, new TPInvisibleTimerTask(player, locTo, false), 10);
      return;
    }

    long distance_squared = plugin.getDistanceSquared(locFrom, locTo);
    boolean bDifferentWorld = false;

    if (locFrom.getWorld().getName() != locTo.getWorld().getName()) {
      bDifferentWorld = true;
    }

    VanishTeleportInfo tpi = null;
    int iLocation = -1;
    for (int i = 0; i < plugin.teleporting.size() - 1; i++) {
      if (plugin.teleporting.get(i).name == player.getName()) {
        tpi = plugin.teleporting.get(i);
        iLocation = i;
        break;
      }
    }

    boolean bTeleportUp = false;
    boolean bPlayerClose = false;

    List<Player> lPlayers = locTo.getWorld().getPlayers();
    for (Player worldPlayer : lPlayers) {
      if (plugin.getDistanceSquared(locTo, worldPlayer.getLocation()) < 25) {
        bPlayerClose = true;
        break;
      }
    }
    // Only teleport up if someone is really close to where we're landing and we're TPing pretty
    // far(> 80)
    // Set distance > 125 means they probably don't have us loaded
    // 6400 = 80^2
    bTeleportUp = (bDifferentWorld || ((distance_squared >= 6400) && bPlayerClose));

    // if we don't find their teleport info, we should add it
    if ((tpi == null) && bTeleportUp) {
      // plugin.log.info("Cancelling Teleport for player and moving to top:" + player.getName());
      // Add them to our teleporting list
      plugin.teleporting.add(new VanishTeleportInfo(player.getName(), locTo));

      // Don't cancel the event, just move them to the top
      // player.sendMessage(ChatColor.RED + "TP'd to 127y because you're invisible.");
      Location new_location = new Location(locTo.getWorld(), locTo.getX(), 127, locTo.getZ());
      event.setTo(new_location);
      // event.setCancelled(true);

      // Make it so the player doesn't take damage for one second.
      // This is in case they spawn within a block
      player.setNoDamageTicks(40);
      // Fire a scheduled task to TP the player to the original location
      // Bumped this up to 1.5 seconds
      plugin.scheduler.scheduleSyncDelayedTask(
          plugin, new TPInvisibleTimerTask(player, locTo, true), 30);
      return;
    } else {
      // plugin.log.info("Should be at final destination:" + player.getName());
      // Remove the player from the TPing list and update their invisibile info
      if (iLocation >= 0) {
        plugin.teleporting.remove(iLocation);
      }
      plugin.updateInvisibleForPlayerDelayed(player);
    }

    // We could cancel the event and TP the player to above the world where they're TPing
    // Then WAIT 2 seconds and TP them to exactly where they wanted.
    // 2 seconds is completely arbitrary, but we want them to be invisible to the
    // Player that they're TPing to.
    // We might need some metadata to be stored(is being moved) because we're going to end
    // up inside of this event again if we TP the player a 2nd time.

    // Make it so this player can't see anyone invisible around them
    // Make it so no one around this player will see them if they're invisible

  }