Java DamageSource类代码示例

import org.spongepowered.api.event.cause.entity.damage.source.DamageSource; //导入依赖的package包/类
public static boolean canDamage(IActiveCharacter character, Living l) {
	if (character.getPlayer() == l) {
		return false;
	}
	if (l.getType() == EntityTypes.PLAYER) {
		if (character.hasParty()) {
			IActiveCharacter c = globalScope.characterService.getCharacter(l.getUniqueId());
			if (character.getParty().getPlayers().contains(c)) {
				return false;
			}
		}
	}
	DamageSource build = new SpongeDamageSourceBuilder()
			.type(NDamageType.DAMAGE_CHECK)
			.absolute()
			.build();

	return l.damage(0, build);
}
 

import org.spongepowered.api.event.cause.entity.damage.source.DamageSource; //导入依赖的package包/类
@Listener(order = Order.LATE)
public void onEntityDamage(DamageEntityEvent event, @Getter(value = "getTargetEntity") Player player, @First DamageSource dmgSrc) {
  if (!isBlockable(dmgSrc)) {
    return;
  }

  Optional<Clause<Integer, Clause<ItemStack, Clause<Integer, Long>>>> optFeatherDetail = getHighestPoweredFeather(player);
  if (!optFeatherDetail.isPresent()) {
    return;
  }

  Clause<Integer, Clause<ItemStack, Clause<Integer, Long>>> featherDetail = optFeatherDetail.get();

  int redQ = featherDetail.getValue().getValue().getKey();
  final double dmg = event.getBaseDamage();
  final int k = (dmg > 80 ? 16 : dmg > 40 ? 8 : dmg > 20 ? 4 : 2);

  final double blockable = redQ * k;
  final double blocked = blockable - (blockable - dmg);

  event.setBaseDamage(Math.max(0, dmg - blocked));

  redQ = (int) ((blockable - blocked) / k);
  updateFeatherPower(featherDetail.getValue().getKey(), redQ, (long) blocked * 75);
  tf(player).inventory.mainInventory.set(featherDetail.getKey(), tf(featherDetail.getValue().getKey()));
}
 

import org.spongepowered.api.event.cause.entity.damage.source.DamageSource; //导入依赖的package包/类
@Listener(order = Order.LAST)
public void onEntityDamageEvent(DamageEntityEvent event) {
  Entity defender = event.getTargetEntity();

  Optional<PatientXInstance> optInst = manager.getApplicableZone(defender);
  if (!optInst.isPresent()) {
    return;
  }

  PatientXInstance inst = optInst.get();

  DamageSource dmgSource = event.getCause().first(DamageSource.class).get();

  if (defender instanceof Player && manager.getBlockedDamage().contains(dmgSource.getType())) {
    // Explosive damage formula: (1 × 1 + 1) × 8 × power + 1
    // Use 49, snowball power is 3
    double ratio = event.getBaseDamage() / 49;

    // Nullify all modifiers
    for (DamageFunction modifier : event.getModifiers()) {
      event.setDamage(modifier.getModifier(), (a) -> 0D);
    }

    event.setBaseDamage(ratio * inst.getDifficulty());
  }
}
 

import org.spongepowered.api.event.cause.entity.damage.source.DamageSource; //导入依赖的package包/类
@Command(desc = "Slaps a player")
public void slap(CommandSource context, Player player, @Optional Integer damage)
{
    damage = damage == null ? 3 : damage;

    if (damage < 1 || damage > 20)
    {
        i18n.send(context, NEGATIVE, "Only damage values from 1 to 20 are allowed!");
        return;
    }

    final Vector3d userDirection = player.getTransform().getRotationAsQuaternion().getDirection().mul(-1);
    Sponge.getCauseStackManager().pushCause(context);
    player.damage(damage, DamageSource.builder().type(DamageTypes.ATTACK).absolute().build());
    player.setVelocity(new Vector3d(userDirection.getX() * damage / 2, userDirection.getY() * damage / 20, userDirection.getZ() * damage / 2));
}
 

import org.spongepowered.api.event.cause.entity.damage.source.DamageSource; //导入依赖的package包/类
/**
 * Attempts to damage the defending LivingEntity, this allows for various protection plugins to
 * cancel damage events.
 *
 * @param attacking  attempting to deal the damage
 * @param defenderLE entity being damaged
 *
 * @return true if the damage check was successful
 */
public static boolean damageCheck(Insentient attacking, Living defenderLE) {
    if (attacking.getEntity().get().equals(defenderLE)) {
        return false;
    }
    if (defenderLE instanceof Player && attacking instanceof Champion) {
        if (!attacking.getWorld().getProperties().isPVPEnabled()) {
            ((Champion) attacking).sendMessage(Texts.of(TextColors.RED, "PVP is disabled!"));
            return false;
        }
    }
    DamageEntityEvent event = SpongeEventFactory
            .createDamageEntityEvent(Cause.of(NamedCause.source(DamageSource.builder().type
                    (DamageTypes.MAGIC))),
                                     ImmutableList.<Tuple<DamageModifier, Function<? super Double, Double>>>of(),
                                     defenderLE, 0);
    Sponge.getEventManager().post(event);
    return event.isCancelled();
}
 

import org.spongepowered.api.event.cause.entity.damage.source.DamageSource; //导入依赖的package包/类
@Override
public void execute(CommandQueue queue, CommandEntry entry) {
    EntityTag ent = EntityTag.getFor(queue.error, entry.getArgumentObject(queue, 0));
    NumberTag dam = NumberTag.getFor(queue.error, entry.getArgumentObject(queue, 1));
    DamageSource.Builder build = DamageSource.builder();
    if (entry.namedArgs.containsKey("absolute")) {
        BooleanTag abs = BooleanTag.getFor(queue.error, entry.getNamedArgumentObject(queue, "absolute"));
        if (abs.getInternal()) {
            build.absolute();
        }
    }
    else {
        build.absolute();
    }
    if (entry.namedArgs.containsKey("type")) {
        String typeName = CoreUtilities.toLowerCase(entry.getNamedArgumentObject(queue, "type").toString());
        Optional<DamageType> type = Sponge.getRegistry().getType(DamageType.class, typeName);
        if (!type.isPresent()) {
            queue.handleError(entry, "Invalid damage type: '" + typeName + "'!");
            return;
        }
        build.type(type.get());
    }
    else {
        build.type(DamageTypes.GENERIC);
    }
    if (queue.shouldShowGood()) {
        queue.outGood("Hurting " + ColorSet.emphasis + ent.debug() + ColorSet.good
                + " for " + ColorSet.emphasis + dam.debug() + ColorSet.good + " points of damage!");
    }
    ent.getInternal().damage(dam.getInternal(), build.build());
}
 

import org.spongepowered.api.event.cause.entity.damage.source.DamageSource; //导入依赖的package包/类
@Listener
public void onPlayerDamage(DamageEntityEvent event) {
	// C'est un joueur
	if (event.getTargetEntity() instanceof Player) {
		EPlayer player = this.plugin.getEServer().getEPlayer((Player) event.getTargetEntity());
		if (player.isGod()) {
			Optional<DamageSource> damagesource = event.getCause().first(DamageSource.class);
			// Le joueur tombe dans le vide
			if (damagesource.isPresent() && damagesource.get().equals(DamageSources.VOID)) {
				// L'option de téléportation au spwan est activé
				if (this.plugin.getConfigs().isGodTeleportToSpawn()) {
					EEMessages.GOD_TELEPORT.sendTo(player);
					player.teleportSpawn();
					player.heal();
					event.setCancelled(true);
				}
				// Domage normal
			} else {
				player.heal();
				event.setCancelled(true);
			}
		}
	} else if (event.getTargetEntity() instanceof Creature) {
		if (this.plugin.getConfigs().isGameModeKill()) {
			Optional<EntityDamageSource> optDamageSource = event.getCause().first(EntityDamageSource.class);
			if (optDamageSource.isPresent() && optDamageSource.get().getSource() instanceof Player) {
				Player killer = (Player) optDamageSource.get().getSource();
				if (killer.get(Keys.IS_SNEAKING).orElse(false) && 
						killer.get(Keys.GAME_MODE).orElse(GameModes.SURVIVAL).equals(GameModes.CREATIVE)) {
					Entity entity = event.getTargetEntity();
					event.setBaseDamage(entity.get(Keys.MAX_HEALTH).orElse(Double.MAX_VALUE));
				}
			}
		}
	}
}
 

import org.spongepowered.api.event.cause.entity.damage.source.DamageSource; //导入依赖的package包/类
public DamageSourceView(DamageSource value) {
    super(value);

    this.affectsCreative = value.doesAffectCreative();
    this.absolute = value.isAbsolute();
    this.bypassingArmour = value.isBypassingArmor();
    this.explosive = value.isExplosive();
    this.magic = value.isMagic();
    this.scaledByDifficulty = value.isScaledByDifficulty();
    this.damageType = value.getType();
}
 

import org.spongepowered.api.event.cause.entity.damage.source.DamageSource; //导入依赖的package包/类
@Listener(order = Order.POST)
public void playerDeath(DestructEntityEvent.Death event, @Getter("getTargetEntity") Player player)
        throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    String key = "death";
    Optional<DamageSource> dmgSrcOpt = event.getCause().first(DamageSource.class);
    if (dmgSrcOpt.isPresent()) {
        key += ":" + dmgSrcOpt.get().getType().getId();
    }

    processEvent(event, player, key);
}
 

import org.spongepowered.api.event.cause.entity.damage.source.DamageSource; //导入依赖的package包/类
@Listener(order = Order.FIRST, beforeModifications = true)
public void onEntityAttack(AttackEntityEvent event, @First DamageSource damageSource) {
    if (!GPFlags.ENTITY_DAMAGE || !GriefPreventionPlugin.instance.claimsEnabledForWorld(event.getTargetEntity().getWorld().getProperties())) {
        return;
    }

    GPTimings.ENTITY_ATTACK_EVENT.startTimingIfSync();
    if (protectEntity(event, event.getTargetEntity(), event.getCause(), damageSource)) {
        event.setCancelled(true);
    }
    GPTimings.ENTITY_ATTACK_EVENT.stopTimingIfSync();
}
 

import org.spongepowered.api.event.cause.entity.damage.source.DamageSource; //导入依赖的package包/类
@Listener(order = Order.FIRST, beforeModifications = true)
public void onEntityDamage(DamageEntityEvent event, @First DamageSource damageSource) {
    if (!GPFlags.ENTITY_DAMAGE || !GriefPreventionPlugin.instance.claimsEnabledForWorld(event.getTargetEntity().getWorld().getProperties())) {
        return;
    }

    GPTimings.ENTITY_DAMAGE_EVENT.startTimingIfSync();
    if (protectEntity(event, event.getTargetEntity(), event.getCause(), damageSource)) {
        event.setCancelled(true);
    }
    GPTimings.ENTITY_DAMAGE_EVENT.stopTimingIfSync();
}
 

import org.spongepowered.api.event.cause.entity.damage.source.DamageSource; //导入依赖的package包/类
@Listener(order = Order.FIRST)
public void onPlayerDeath(DestructEntityEvent.Death event, @Root DamageSource damageSource) {
    GPTimings.PLAYER_DEATH_EVENT.startTimingIfSync();
    if (!(event.getTargetEntity() instanceof Player) || !GriefPreventionPlugin.instance.claimsEnabledForWorld(event.getTargetEntity().getWorld().getProperties())) {
        GPTimings.PLAYER_DEATH_EVENT.stopTimingIfSync();
        return;
    }

    // FEATURE: prevent death message spam by implementing a "cooldown period" for death messages
    Player player = (Player) event.getTargetEntity();
    GPPlayerData playerData = this.dataStore.getOrCreatePlayerData(player.getWorld(), event.getTargetEntity().getUniqueId());
    long now = Calendar.getInstance().getTimeInMillis();

    if (GriefPreventionPlugin.getGlobalConfig().getConfig().spam.monitorEnabled && (now - playerData.lastDeathTimeStamp) < GriefPreventionPlugin.getGlobalConfig().getConfig().spam.deathMessageCooldown * 1000) {
        event.setMessage(Text.of());
    }

    playerData.lastDeathTimeStamp = now;

    // these are related to locking dropped items on death to prevent theft
    World world = event.getTargetEntity().getWorld();
    if (world != null) {
        GriefPreventionConfig<?> activeConfig = GriefPreventionPlugin.getActiveConfig(world.getProperties());
        GPClaim claim = this.dataStore.getClaimAtPlayer(playerData, player.getLocation());
        if ((claim.pvpRulesApply() && activeConfig.getConfig().pvp.protectItemsOnDeathPvp) ||
                (!claim.isPvpEnabled() && activeConfig.getConfig().general.protectItemsOnDeathNonPvp)) {
            playerData.dropsAreUnlocked = false;
            playerData.receivedDropUnlockAdvertisement = false;
        }
    }
    GPTimings.PLAYER_DEATH_EVENT.stopTimingIfSync();
}
 

import org.spongepowered.api.event.cause.entity.damage.source.DamageSource; //导入依赖的package包/类
@Listener(order = Order.PRE)
public void onPlayerDeath(DestructEntityEvent.Death event) {
  Optional<DamageSource> optDmgSrc = event.getCause().first(DamageSource.class);
  if (optDmgSrc.isPresent() && event.getTargetEntity() instanceof Player) {
    if (event.getMessage().toPlain().contains(DAMAGE_TYPE.getId())) {
      event.setMessage(Text.of(((Player) event.getTargetEntity()).getName(), " was killed by an ancient enchantment"));
    }
  }
}
 

import org.spongepowered.api.event.cause.entity.damage.source.DamageSource; //导入依赖的package包/类
private void damagePlayers() {
  for (Player player : getPlayers(PARTICIPANT)) {
    BlockType blockType = player.getLocation().getBlockType();
    if (blockType == BlockTypes.WATER || blockType == BlockTypes.FLOWING_WATER) {
      // If the game is in progress, damage, otherwise return to the spawn point
      if (state == SkyWarsState.IN_PROGRESS) {
        player.damage(Probability.getRandom(3), DamageSource.builder().type(DamageTypes.DROWN).build());
      } else {
        player.setLocation(startingLocation);
      }
    }
  }
}
 

import org.spongepowered.api.event.cause.entity.damage.source.DamageSource; //导入依赖的package包/类
@Override
public Optional<Instruction<DamagedCondition, Boss<Living, ZoneBossDetail<FreakyFourInstance>>>> apply(
    DamagedCondition damagedCondition, Boss<Living, ZoneBossDetail<FreakyFourInstance>> boss
) {
  Optional<DamageSource> optDmgSource = damagedCondition.getDamageSource();
  if (optDmgSource.isPresent()) {
    if (optDmgSource.get().getType() == DamageTypes.EXPLOSIVE) {
      DamageEntityEvent event = damagedCondition.getEvent();
      EntityHealthUtil.heal(boss.getTargetEntity().get(), event.getFinalDamage());
      event.setCancelled(true);
    }
  }
  return Optional.empty();
}