org.bukkit.event.entity.EntityRegainHealthEvent Java Examples

@EventHandler(ignoreCancelled = true)
public void onFoodHeal(EntityRegainHealthEvent event) {
    if (event.getRegainReason() != EntityRegainHealthEvent.RegainReason.SATIATED ||
            ConfigManager.getInstance().getFoodHealInCombat()) {
        return;
    }
    if (!(event.getEntity() instanceof Player)) {
        return;
    }
    Player player = (Player) event.getEntity();
    Civilian civilian = CivilianManager.getInstance().getCivilian(player.getUniqueId());
    if (!civilian.isInCombat()) {
        return;
    }
    event.setCancelled(true);
}
 

@EventHandler(priority = EventPriority.HIGH)
public void onRegainHealth(EntityRegainHealthEvent rhe) {
  if (rhe.getEntityType() != EntityType.PLAYER) {
    return;
  }

  Player player = (Player) rhe.getEntity();
  Game game = BedwarsRel.getInstance().getGameManager().getGameOfPlayer(player);

  if (game == null) {
    return;
  }

  if (game.getState() != GameState.RUNNING) {
    return;
  }

  if (player.getHealth() >= player.getMaxHealth()) {
    game.setPlayerDamager(player, null);
  }
}
 

@EventHandler(priority = EventPriority.MONITOR)
public void on(EntityRegainHealthEvent event) {
    final Entity entity = event.getEntity();
    if (!(entity instanceof Player)) {
        return;
    }

    // If the event was cancelled, another plugin may have edited the health
    // Update instantly with the current health
    final Player player = (Player) entity;

    if (event.isCancelled()) {
        updatePlayer(player);
        return;
    }

    // Calculate new health based on regen amount instead of waiting for one tick
    final double oldHealth = player.getHealth();
    final double healAmount = event.getAmount();
    final double newHealth = Math.min(oldHealth + healAmount, player.getMaxHealth());

    updatePlayer(player, newHealth);
}
 

@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void onHeal(EntityRegainHealthEvent event)
{
	if(event.getEntity() instanceof Player)
	{
		MarriagePlayer player = plugin.getPlayerData((Player) event.getEntity());
		if(player.isMarried())
		{
			Marriage marriage = player.getNearestPartnerMarriageData();
			if(marriage != null && marriage.inRangeSquared(range))
			{
				BonusHealEvent bonusHealEvent = new BonusHealEvent(player, marriage, event.getAmount() * multiplier, event.getRegainReason());
				plugin.getServer().getPluginManager().callEvent(bonusHealEvent);
				if(!bonusHealEvent.isCancelled())
				{
					event.setAmount(bonusHealEvent.getAmount());
				}
			}
		}
	}
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void updateMonitoredHealth(final EntityRegainHealthEvent event) {
  if (event.getEntity() instanceof Player) {
    Player player = (Player) event.getEntity();
    if (player.getHealth() == player.getMaxHealth()) return;
    this.scheduleCheck((Player) event.getEntity());
  }
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void updateMonitoredHealth(final EntityRegainHealthEvent event) {
    if(event.getEntity() instanceof Player) {
        Player player = (Player) event.getEntity();
        if(player.getHealth() == player.getMaxHealth()) return;
        this.scheduleCheck((Player) event.getEntity());
    }
}
 

@EventHandler(ignoreCancelled = true)
public void on(EntityRegainHealthEvent event) {
    if (isEnabled()) return;

    if (event.getEntityType() != EntityType.HORSE) return;

    event.setCancelled(true);
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onEntityRegainHealth(EntityRegainHealthEvent event) {
    if (Settings.INDICATOR_ENABLE.getValue("gainHealth")) {
        if ((event.getEntity() instanceof Player && Settings.INDICATOR_SHOW_FOR_PLAYERS.getValue("gainHealth")) || Settings.INDICATOR_SHOW_FOR_MOBS.getValue("gainHealth")) {
            Location l = event.getEntity().getLocation().clone();
            l.setY(l.getY() + Settings.INDICATOR_Y_OFFSET.getValue("gainHealth"));
            HoloAPI.getManager().createSimpleHologram(l, Settings.INDICATOR_TIME_VISIBLE.getValue("gainHealth"), true, Settings.INDICATOR_FORMAT.getValue("gainHealth", "default") + "+" + event.getAmount() + " " + HEART_CHARACTER);
        }
    }
}
 

/**
 * @param player The player that gets a heal bonus.
 * @param marriageData The marriage data of the player.
 * @param amount The amount of health the entity will regain.
 * @param regainReason The RegainReason detailing the reason for the entity regaining health.
 */
public BonusHealEvent(@NotNull MarriagePlayer player, @NotNull Marriage marriageData, final double amount, @NotNull final EntityRegainHealthEvent.RegainReason regainReason)
{
	this.player = player;
	this.marriageData = marriageData;
	this.amount = amount;
	this.regainReason = regainReason;
}
 

@EventHandler
public void onEntityRegainHealth(final EntityRegainHealthEvent ev) {
	if (ev.getRegainReason() == RegainReason.SATIATED) ev.setCancelled(true);
	if (ev.getEntity() instanceof Player) {
		Bukkit.getScheduler().runTaskLater(this.p, new BukkitRunnable() {
			
			@Override
			public void run() {
				p.updatePlayerListName((Player)ev.getEntity());
			}
		}, 1L);
	}
}
 

@EventHandler(ignoreCancelled = true, priority = EventPriority.LOWEST)
public void entityRegainHealthEvent(EntityRegainHealthEvent event) {
    if (listenerService.shouldCancelEvent(event)) {
        event.setAmount(0);
        event.setCancelled(true);
    }
}
 

@Test
public void shouldCancelRegainHealthEvent() {
    // given
    EntityRegainHealthEvent event = mock(EntityRegainHealthEvent.class);
    given(listenerService.shouldCancelEvent(event)).willReturn(true);

    // when
    listener.entityRegainHealthEvent(event);

    // then
    verify(listenerService).shouldCancelEvent(event);
    verify(event).setCancelled(true);
    verify(event).setAmount(0);
}
 

@Test
public void shouldNotCancelRegainedHealth() {
    // given
    EntityRegainHealthEvent event = mock(EntityRegainHealthEvent.class);
    given(listenerService.shouldCancelEvent(event)).willReturn(false);

    // when
    listener.entityRegainHealthEvent(event);

    // then
    verify(listenerService).shouldCancelEvent(event);
    verifyNoInteractions(event);
}
 

@EventHandler
public void onViewingEntityRegainHealth(EntityRegainHealthEvent event) {
    if (event.getEntity() instanceof Player) {
        refreshView(event.getEntity().getUniqueId());
    }
}
 

/**
 * Gets the reason for why the player is regaining health.
 *
 * @return A RegainReason detailing the reason for the entity regaining health.
 */
public @NotNull EntityRegainHealthEvent.RegainReason getRegainReason() {
	return regainReason;
}