public void onPlayerRespawn(final PlayerRespawnEvent event)
	{
		final User user = ess.getUser(event.getPlayer());

		if (user.isJailed() && user.getJail() != null && !user.getJail().isEmpty())
		{
			return;
		}

		if (ess.getSettings().getRespawnAtHome())
		{
			Location home;
			final Location bed = user.getBedSpawnLocation();
			if (bed != null && bed.getBlock().getType() == Material.BED_BLOCK)
			{
				home = bed;
			}
			else
			{
				home = user.getHome(user.getLocation());
			}
			if (home != null)
			{
				event.setRespawnLocation(home);
				return;
			}
		}
		final Location spawn = spawns.getSpawn(user.getGroup());
		if (spawn != null)
		{
			event.setRespawnLocation(spawn);
		}
	}
示例#2
0
 public final boolean onBlockBreak(final Block block, final Player player, final IEssentials ess) {
   User user = ess.getUser(player);
   try {
     return onBlockBreak(block, user, getUsername(user), ess);
   } catch (SignException ex) {
     ess.showError(user, ex, signName);
   }
   return false;
 }
示例#3
0
 public final boolean onSignBreak(final Block block, final Player player, final IEssentials ess) {
   final ISign sign = new BlockSign(block);
   final User user = ess.getUser(player);
   try {
     return (user.isAuthorized("essentials.signs." + signName.toLowerCase() + ".break")
             || user.isAuthorized("essentials.signs.break." + signName.toLowerCase()))
         && onSignBreak(sign, user, getUsername(user), ess);
   } catch (SignException ex) {
     ess.showError(user, ex, signName);
     return false;
   }
 }
	@Override
	public void onPlayerJoin(final PlayerJoinEvent event)
	{
		final User user = ess.getUser(event.getPlayer());

		if (!user.isNew() || user.getBedSpawnLocation() != null)
		{
			return;
		}
		user.setNew(false);
		if (!"none".equalsIgnoreCase(ess.getSettings().getNewbieSpawn()))
		{
			ess.scheduleSyncDelayedTask(new NewPlayerTeleport(user));
		}

		if (ess.getSettings().getAnnounceNewPlayers())
		{
			ess.broadcastMessage(user, ess.getSettings().getAnnounceNewPlayerFormat(user));
		}
	}
 @EventHandler(priority = EventPriority.HIGHEST)
 public void onEntityTarget(final EntityTargetEvent event) {
   if (event.isCancelled()) {
     return;
   }
   if (!(event.getTarget() instanceof Player)) {
     return;
   }
   final User user = ess.getUser(event.getTarget());
   if ((event.getReason() == TargetReason.CLOSEST_PLAYER
           || event.getReason() == TargetReason.TARGET_ATTACKED_ENTITY
           || event.getReason() == TargetReason.PIG_ZOMBIE_TARGET
           || event.getReason() == TargetReason.RANDOM_TARGET
           || event.getReason() == TargetReason.TARGET_ATTACKED_OWNER
           || event.getReason() == TargetReason.OWNER_ATTACKED_TARGET)
       && prot.getSettingBool(ProtectConfig.prevent_entitytarget)
       && !user.isAuthorized("essentials.protect.entitytarget.bypass")) {
     event.setCancelled(true);
     return;
   }
 }
	@Override
	public void onPlayerJoin(final PlayerJoinEvent event)
	{
		final User user = ess.getUser(event.getPlayer());

		if (user.hasPlayedBefore())
		{
			LOGGER.log(Level.FINE, "Old player join");
			return;
		}		
		if (!"none".equalsIgnoreCase(ess.getSettings().getNewbieSpawn()))
		{
			ess.scheduleSyncDelayedTask(new NewPlayerTeleport(user), 1L);
		}

		if (ess.getSettings().getAnnounceNewPlayers())
		{
			ess.broadcastMessage(user, ess.getSettings().getAnnounceNewPlayerFormat(user));
		}
		
		LOGGER.log(Level.FINE, "New player join");
	}
	public void onPlayerJoin(final PlayerJoinEvent event)
	{
		if (event.getPlayer().hasPlayedBefore())
		{
			LOGGER.log(Level.FINE, "Old player join");
			return;
		}

		final User user = ess.getUser(event.getPlayer());

		if (!"none".equalsIgnoreCase(ess.getSettings().getNewbieSpawn()))
		{
			ess.scheduleSyncDelayedTask(new NewPlayerTeleport(user), 1L);
		}

		if (ess.getSettings().getAnnounceNewPlayers())
		{
			final IText output = new KeywordReplacer(ess.getSettings().getAnnounceNewPlayerFormat(), user, ess);
			final SimpleTextPager pager = new SimpleTextPager(output);
			ess.broadcastMessage(user, pager.getString(0));
		}

		final String kitName = ess.getSettings().getNewPlayerKit();
		if (!kitName.isEmpty())
		{
			try
			{
				final Map<String, Object> kit = ess.getSettings().getKit(kitName.toLowerCase(Locale.ENGLISH));
				final List<String> items = Kit.getItems(user, kit);
				Kit.expandItems(ess, user, items);
			}
			catch (Exception ex)
			{
				LOGGER.log(Level.WARNING, ex.getMessage());
			}
		}

		LOGGER.log(Level.FINE, "New player join");
	}
 @Override
 public void alert(final User user, final String item, final String type) {
   final Location loc = user.getLocation();
   final String warnMessage =
       Util.format(
           "alertFormat",
           user.getName(),
           type,
           item,
           loc.getWorld().getName()
               + ","
               + loc.getBlockX()
               + ","
               + loc.getBlockY()
               + ","
               + loc.getBlockZ());
   LOGGER.log(Level.WARNING, warnMessage);
   for (Player p : this.getServer().getOnlinePlayers()) {
     final User alertUser = ess.getUser(p);
     if (alertUser.isAuthorized("essentials.protect.alerts")) {
       alertUser.sendMessage(warnMessage);
     }
   }
 }
	@Override
	public void onPlayerRespawn(final PlayerRespawnEvent event)
	{		
		final User user = ess.getUser(event.getPlayer());

		if (ess.getSettings().getRespawnAtHome())
		{
			Location home = user.getHome(user.getLocation());
			if (home == null)
			{
				home = user.getBedSpawnLocation();
			}
			if (home != null)
			{
				event.setRespawnLocation(home);
				return;
			}
		}
		final Location spawn = spawns.getSpawn(user.getGroup());
		if (spawn != null)
		{
			event.setRespawnLocation(spawn);
		}
	}
示例#10
0
 public final boolean onSignCreate(final SignChangeEvent event, final IEssentials ess) {
   final ISign sign = new EventSign(event);
   final User user = ess.getUser(event.getPlayer());
   if (!(user.isAuthorized("essentials.signs." + signName.toLowerCase() + ".create")
       || user.isAuthorized("essentials.signs.create." + signName.toLowerCase()))) {
     // Return true, so other plugins can use the same sign title, just hope
     // they won't change it to §1[Signname]
     return true;
   }
   sign.setLine(0, Util.format("signFormatFail", this.signName));
   try {
     final boolean ret = onSignCreate(sign, user, getUsername(user), ess);
     if (ret) {
       sign.setLine(0, getSuccessName());
     }
     return ret;
   } catch (ChargeException ex) {
     ess.showError(user, ex, signName);
   } catch (SignException ex) {
     ess.showError(user, ex, signName);
   }
   // Return true, so the player sees the wrong sign.
   return true;
 }
  @EventHandler(priority = EventPriority.HIGHEST)
  public void onEntityDamage(final EntityDamageEvent event) {
    if (event.isCancelled()) {
      return;
    }
    final Entity target = event.getEntity();

    if (target instanceof Villager && prot.getSettingBool(ProtectConfig.prevent_villager_death)) {
      event.setCancelled(true);
      return;
    }

    final User user = ess.getUser(target);
    if (event instanceof EntityDamageByBlockEvent) {
      final DamageCause cause = event.getCause();

      if (prot.getSettingBool(ProtectConfig.disable_contactdmg)
          && cause == DamageCause.CONTACT
          && !(target instanceof Player
              && user.isAuthorized("essentials.protect.damage.contact")
              && !user.isAuthorized("essentials.protect.damage.disable"))) {
        event.setCancelled(true);
        return;
      }
      if (prot.getSettingBool(ProtectConfig.disable_lavadmg)
          && cause == DamageCause.LAVA
          && !(target instanceof Player
              && user.isAuthorized("essentials.protect.damage.lava")
              && !user.isAuthorized("essentials.protect.damage.disable"))) {
        event.setCancelled(true);
        return;
      }
      if (prot.getSettingBool(ProtectConfig.prevent_tnt_explosion)
          && cause == DamageCause.BLOCK_EXPLOSION
          && !(target instanceof Player
              && user.isAuthorized("essentials.protect.damage.tnt")
              && !user.isAuthorized("essentials.protect.damage.disable"))) {
        event.setCancelled(true);
        return;
      }
    }

    if (event instanceof EntityDamageByEntityEvent) {
      final EntityDamageByEntityEvent edEvent = (EntityDamageByEntityEvent) event;
      final Entity eAttack = edEvent.getDamager();
      final User attacker = ess.getUser(eAttack);

      // PVP Settings
      if (target instanceof Player
          && eAttack instanceof Player
          && prot.getSettingBool(ProtectConfig.disable_pvp)
          && (!user.isAuthorized("essentials.protect.pvp")
              || !attacker.isAuthorized("essentials.protect.pvp"))) {
        event.setCancelled(true);
        return;
      }

      // Creeper explode prevention
      if (eAttack instanceof Creeper
          && prot.getSettingBool(ProtectConfig.prevent_creeper_explosion)
          && !(target instanceof Player
              && user.isAuthorized("essentials.protect.damage.creeper")
              && !user.isAuthorized("essentials.protect.damage.disable"))) {
        event.setCancelled(true);
        return;
      }

      if (eAttack instanceof Creeper
          && prot.getSettingBool(ProtectConfig.prevent_creeper_playerdmg)
          && !(target instanceof Player
              && user.isAuthorized("essentials.protect.damage.creeper")
              && !user.isAuthorized("essentials.protect.damage.disable"))) {
        event.setCancelled(true);
        return;
      }

      if ((event.getEntity() instanceof Fireball || event.getEntity() instanceof SmallFireball)
          && prot.getSettingBool(ProtectConfig.prevent_fireball_playerdmg)
          && !(target instanceof Player
              && user.isAuthorized("essentials.protect.damage.fireball")
              && !user.isAuthorized("essentials.protect.damage.disable"))) {
        event.setCancelled(true);
        return;
      }

      if (eAttack instanceof TNTPrimed
          && prot.getSettingBool(ProtectConfig.prevent_tnt_playerdmg)
          && !(target instanceof Player
              && user.isAuthorized("essentials.protect.damage.tnt")
              && !user.isAuthorized("essentials.protect.damage.disable"))) {
        event.setCancelled(true);
        return;
      }

      if (edEvent.getDamager() instanceof Projectile
          && target instanceof Player
          && ((prot.getSettingBool(ProtectConfig.disable_projectiles)
                  && !(user.isAuthorized("essentials.protect.damage.projectiles")
                      && !user.isAuthorized("essentials.protect.damage.disable")))
              || (((Projectile) edEvent.getDamager()).getShooter() instanceof Player
                  && prot.getSettingBool(ProtectConfig.disable_pvp)
                  && (!user.isAuthorized("essentials.protect.pvp")
                      || !ess.getUser(((Projectile) edEvent.getDamager()).getShooter())
                          .isAuthorized("essentials.protect.pvp"))))) {
        event.setCancelled(true);
        return;
      }
    }

    final DamageCause cause = event.getCause();
    if (target instanceof Player) {
      if (cause == DamageCause.FALL
          && prot.getSettingBool(ProtectConfig.disable_fall)
          && !(user.isAuthorized("essentials.protect.damage.fall")
              && !user.isAuthorized("essentials.protect.damage.disable"))) {
        event.setCancelled(true);
        return;
      }

      if (cause == DamageCause.SUFFOCATION
          && prot.getSettingBool(ProtectConfig.disable_suffocate)
          && !(user.isAuthorized("essentials.protect.damage.suffocation")
              && !user.isAuthorized("essentials.protect.damage.disable"))) {
        event.setCancelled(true);
        return;
      }
      if ((cause == DamageCause.FIRE || cause == DamageCause.FIRE_TICK)
          && prot.getSettingBool(ProtectConfig.disable_firedmg)
          && !(user.isAuthorized("essentials.protect.damage.fire")
              && !user.isAuthorized("essentials.protect.damage.disable"))) {
        event.setCancelled(true);
        return;
      }
      if (cause == DamageCause.DROWNING
          && prot.getSettingBool(ProtectConfig.disable_drown)
          && !(user.isAuthorized("essentials.protect.damage.drowning")
              && !user.isAuthorized("essentials.protect.damage.disable"))) {
        event.setCancelled(true);
        return;
      }
      if (cause == DamageCause.LIGHTNING
          && prot.getSettingBool(ProtectConfig.disable_lightning)
          && !(user.isAuthorized("essentials.protect.damage.lightning")
              && !user.isAuthorized("essentials.protect.damage.disable"))) {
        event.setCancelled(true);
        return;
      }
    }
  }