AttackEntityEvent (SpongeAPI 7.3.0 API)

All Superinterfaces:

Cancellable, Event, TargetEntityEvent

All Known Implementing Classes:

AbstractAttackEntityEvent
```
public interface AttackEntityEvent
extends TargetEntityEvent, Cancellable
```
Represents the base event for when an Entity is being "attacked". The uniqueness of this event is that all DamageSources can deal varying amounts of damage with varying modifiers based on various reasons. Due to this ambiguous variety of information that is possible to provide, the AttackEntityEvent can be summarized as so:
An Arrow, that was shot by a Skeleton, with an enchanted ItemTypes.BOW ItemStack, when the World Difficulty was set to Difficulties.HARD, will deal possibly "5" damage to any Entity it hits.

The issue with representing this type of "logic flow" is that a particular amount of damage from a DamageSource, even if specified to a particular DamageType, has no static finalized amount of damage to deal to a particular Entity. To properly represent this, a DamageSource has various "states" such as: DamageSource.isAbsolute(), or DamageSource.isBypassingArmor(). Quite simply, the DamageSource will always be the "first" element within a Cause that can be retrieved from Event.getCause().

Next, any additional "aides" in attacking the Entity will be included in order of "priority of relation" to "attacking" the entity. In short, if another Entity is considered a "team member" to the attacking Entity, the "team member" may be a second element within the Cause. The same can be said if an Arrow was shot from a Dispenser that was triggered by a Player flipping a switch.

Continuing with the notion of "modifiers" to damage, the "base" damage is modified or added onto after various unknown methods are called or processed on the damage. Optimally, these modifiers can be traced to a particular object, be it an ItemStack, Difficulty, or simply an an attribute. The interesting part is that these "modifiers" do not just define a static value to add to the "base" damage, they are usually a loose form of a Function that are applied to the "base" damage. Given that Cause has a unique capability of storing any and every Object willing to be passed into it, we can easily represent these "sources" of "modifiers" in a Cause. Now, knowing the "source" will not provide enough information, so a DamageModifierType is provided with a DamageModifier to paint the fullest picture of "explaining" the DamageModifier as to why it is present, and why it is "modifying" the "base" damage. Finally, we can associate a DamageModifier with a Function that is passed the current "damage" into Function.apply(Object), being added to the current "damage". After all DamageModifier Functions are "applied", the overall "damage" is now the final damage to actually throw a AttackEntityEvent.

Note that due to the mechanics of the game, DamageModifiers are always ordered in the order of which they apply their modifier onto the "base" damage. The implementation for getFinalOutputDamage() can be exemplified like so:

double damage = this.baseDamage; for (Map.Entry<DamageModifier, Function<? super Double, Double>> entry : this.modifierFunctions.entrySet()) { damage += checkNotNull(entry.getValue().apply(damage)); } return damage;

After which, the "final" damage is simply the summation of the "base" damage and all "modified damage" for each DamageModifier provided in this event.

Coming forward, it is possible to further customize not only the "base" damage, but override pre-existing DamageModifier Functions by calling setOutputDamage(DamageModifier, DoubleUnaryOperator) at which point the end result may be undefined. However, if a custom DamageModifier that aims to alter the "final" damage based on some custom circumstances, calling setOutputDamage(DamageModifier, DoubleUnaryOperator) on a new DamageModifier instance, easily created from the DamageModifier.Builder, the provided pairing will be added at the "end" of the list for "modifying" the "base" damage.

Note that this event is intended for processing incoming damage to an Entity prior to any DamageModifiers associated with the TargetEntityEvent.getTargetEntity(). The AttackEntityEvent is used to process the various DamageModifiers of which originate or are associated with the targeted Entity.

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`ABSORPTION` For use with a `DamageModifier` where it's type is a `DamageModifierTypes.ABSORPTION` and the `Cause` contains a `PotionEffect`.
`static String`	`BOOTS` For use with a `DamageModifier` where it's type is a `DamageModifierTypes.ARMOR` and the `Cause` contains an `ItemStackSnapshot` for "boots".
`static String`	`CHESTPLATE` For use with a `DamageModifier` where it's type is a `DamageModifierTypes.ARMOR` and the `Cause` contains an `ItemStackSnapshot` for a "chestplate".
`static String`	`CREATOR` For use with a `DamageModifier` where the root cause is "created" by an object, usually the `Entity` or `Living` entity.
`static String`	`GENERAL_ARMOR` For use with a `DamageModifier` where it's type is a `DamageModifierTypes.ARMOR` and the `Cause` contains an `ItemStackSnapshot`.
`static String`	`HARD_HAT_ARMOR` For use with a `DamageModifier` where it's type is a `DamageModifierTypes.HARD_HAT` and the `Cause` contains an `ItemStackSnapshot`, usually a helmet.
`static String`	`HELMET` For use with a `DamageModifier` where it's type is a `DamageModifierTypes.ARMOR` and the `Cause` contains an `ItemStackSnapshot` for a "helmet".
`static String`	`LEGGINGS` For use with a `DamageModifier` where it's type is a `DamageModifierTypes.ARMOR` and the `Cause` contains an `ItemStackSnapshot` for "leggings".
`static String`	`NOTIFIER` For use with a `DamageSource` where it is either a `BlockDamageSource` or `EntityDamageSource` such that it was last "notified" by the object represented in the cause.
`static String`	`RESISTANCE` For use with a `DamageModifier` where it's type is a `DamageModifierTypes.HARD_HAT` and the `Cause` contains a `PotionEffect`.
`static String`	`SHIELD` or use with a `DamageModifier` where its type is a `DamageModifierTypes.SHIELD` and the `Cause` contains an `ItemStackSnapshot` (in Vanilla, a shield).
`static String`	`SOURCE` For use with the `DamageSource` that is known as the "source" of the damage.

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`void`	`addDamageModifierAfter(DamageModifier damageModifier, DoubleUnaryOperator function, Set<DamageModifierType> after)` Adds the provided `DamageModifier` and `Function` to the list of modifiers, such that the modifier will appear in order after any current modifiers whose type are included in the provided `Set` of `DamageModifierType`s.
`void`	`addDamageModifierBefore(DamageModifier damageModifier, DoubleUnaryOperator function, Set<DamageModifierType> before)` Adds the provided `DamageModifier` and `Function` to the list of modifiers, such that the `Set` containing `DamageModifierType`s provided in `before` will appear after the provided damage modifier.
`double`	`getBaseOutputDamage()` Gets the "base" damage to deal to the targeted `Entity`.
`double`	`getFinalOutputDamage()` Gets the final damage that will be passed into the proceeding `AttackEntityEvent`.
`int`	`getKnockbackModifier()` Gets the knock back modifier.
`List<DamageFunction>`	`getModifiers()` Gets a list of simple `Tuple`s of `DamageModifier` keyed to their representative `Function`s.
`double`	`getOriginalDamage()` Gets the original "raw" amount of damage to deal to the targeted `Entity`.
`Map<DamageModifier,Double>`	`getOriginalDamages()` Gets an `ImmutableMap` of all original `DamageModifier`s and their associated "modified" damage.
`double`	`getOriginalFinalDamage()` Gets the original "final" amount of damage after all original `DamageModifier`s are applied to `getOriginalDamage()`.
`List<ModifierFunction<DamageModifier>>`	`getOriginalFunctions()` Gets the original `List` of `DamageModifier` to `Function` that was originally passed into the event.
`double`	`getOriginalModifierDamage(DamageModifier damageModifier)` Gets the original damage for the provided `DamageModifier`.
`double`	`getOutputDamage(DamageModifier damageModifier)` Gets the damage for the provided `DamageModifier`.
`boolean`	`isModifierApplicable(DamageModifier damageModifier)` Checks whether the provided `DamageModifier` is applicable to the current available `DamageModifier`s.
`void`	`setBaseOutputDamage(double baseDamage)` Sets the "base" damage to deal to the targeted `Entity`.
`void`	`setKnockbackModifier(int modifier)` Sets the knock back modifier.
`void`	`setOutputDamage(DamageModifier damageModifier, DoubleUnaryOperator function)` Sets the provided `Function` to be used for the given `DamageModifier`.

Methods inherited from interface org.spongepowered.api.event.entity.TargetEntityEvent
getTargetEntity

Methods inherited from interface org.spongepowered.api.event.Event
getCause, getContext, getSource

Methods inherited from interface org.spongepowered.api.event.Cancellable
isCancelled, setCancelled

- Field Detail
  - SOURCE
```
static final String SOURCE
```
    For use with the DamageSource that is known as the "source" of the damage.
    
    See Also:
    
    Constant Field Values
  - HARD_HAT_ARMOR
```
static final String HARD_HAT_ARMOR
```
    For use with a DamageModifier where it's type is a DamageModifierTypes.HARD_HAT and the Cause contains an ItemStackSnapshot, usually a helmet.
    
    See Also:
    
    Constant Field Values
  - SHIELD
```
static final String SHIELD
```
    or use with a DamageModifier where its type is a DamageModifierTypes.SHIELD and the Cause contains an ItemStackSnapshot (in Vanilla, a shield).
    
    See Also:
    
    Constant Field Values
  - GENERAL_ARMOR
```
static final String GENERAL_ARMOR
```
    For use with a DamageModifier where it's type is a DamageModifierTypes.ARMOR and the Cause contains an ItemStackSnapshot. Separate from hard hat but still considered as "armor" where it will absorb a certain amount of damage before dealing damage to the wearer.
    
    See Also:
    
    Constant Field Values
  - HELMET
```
static final String HELMET
```
    For use with a DamageModifier where it's type is a DamageModifierTypes.ARMOR and the Cause contains an ItemStackSnapshot for a "helmet".
    
    See Also:
    
    Constant Field Values
  - CHESTPLATE
```
static final String CHESTPLATE
```
    For use with a DamageModifier where it's type is a DamageModifierTypes.ARMOR and the Cause contains an ItemStackSnapshot for a "chestplate".
    
    See Also:
    
    Constant Field Values
  - LEGGINGS
```
static final String LEGGINGS
```
    For use with a DamageModifier where it's type is a DamageModifierTypes.ARMOR and the Cause contains an ItemStackSnapshot for "leggings".
    
    See Also:
    
    Constant Field Values
  - BOOTS
```
static final String BOOTS
```
    For use with a DamageModifier where it's type is a DamageModifierTypes.ARMOR and the Cause contains an ItemStackSnapshot for "boots".
    
    See Also:
    
    Constant Field Values
  - RESISTANCE
```
static final String RESISTANCE
```
    For use with a DamageModifier where it's type is a DamageModifierTypes.HARD_HAT and the Cause contains a PotionEffect.
    
    See Also:
    
    Constant Field Values
  - ABSORPTION
```
static final String ABSORPTION
```
    For use with a DamageModifier where it's type is a DamageModifierTypes.ABSORPTION and the Cause contains a PotionEffect.
    
    See Also:
    
    Constant Field Values
  - CREATOR
```
static final String CREATOR
```
    For use with a DamageModifier where the root cause is "created" by an object, usually the Entity or Living entity.
    
    See Also:
    
    Constant Field Values
  - NOTIFIER
```
static final String NOTIFIER
```
    For use with a DamageSource where it is either a BlockDamageSource or EntityDamageSource such that it was last "notified" by the object represented in the cause.
    Usually this is used where a Player interacted with the now DamageSource such that they
    
    See Also:
    
    Constant Field Values
- Method Detail
  - getOriginalDamage
```
double getOriginalDamage()
```
    Gets the original "raw" amount of damage to deal to the targeted Entity.
    
    Returns:
    
    The original "raw" damage
  - getOriginalFinalDamage
```
double getOriginalFinalDamage()
```
    Gets the original "final" amount of damage after all original DamageModifiers are applied to getOriginalDamage(). The "final" damage is considered the amount of health being lost by the Entity, if health is tracked.
    
    Returns:
    
    The final amount of damage to originally deal
  - getOriginalDamages
```
Map<DamageModifier,Double> getOriginalDamages()
```
    Gets an ImmutableMap of all original DamageModifiers and their associated "modified" damage. Note that ordering is not retained.
    
    Returns:
    
    An immutable map of the original modified damages
  - getOriginalModifierDamage
```
double getOriginalModifierDamage(DamageModifier damageModifier)
```
    Gets the original damage for the provided DamageModifier. If the provided DamageModifier was not included in getOriginalDamages(), an IllegalArgumentException is thrown.
    
    Parameters:
    
    damageModifier - The original damage modifier
    
    Returns:
    
    The original damage change
  - getOriginalFunctions
```
List<ModifierFunction<DamageModifier>> getOriginalFunctions()
```
    Gets the original List of DamageModifier to Function that was originally passed into the event.
    
    Returns:
    
    The list of damage modifier functions
  - getBaseOutputDamage
```
double getBaseOutputDamage()
```
    Gets the "base" damage to deal to the targeted Entity. The "base" damage is the original value before passing along the chain of Functions for all known DamageModifiers.
    
    Returns:
    
    The base damage
  - setBaseOutputDamage
```
void setBaseOutputDamage(double baseDamage)
```
    Sets the "base" damage to deal to the targeted Entity. The "base" damage is the original value before passing along the chain of Functions for all known DamageModifiers.
    
    Parameters:
    
    baseDamage - The base damage
  - getFinalOutputDamage
```
double getFinalOutputDamage()
```
    Gets the final damage that will be passed into the proceeding AttackEntityEvent. The final damage is the end result of the getBaseOutputDamage() being applied in Function.apply(Object) available from all the Tuples of DamageModifier to Function in getOriginalFunctions().
    
    Returns:
    
    The final damage to deal
  - isModifierApplicable
```
boolean isModifierApplicable(DamageModifier damageModifier)
```
    Checks whether the provided DamageModifier is applicable to the current available DamageModifiers.
    
    Parameters:
    
    damageModifier - The damage modifier to check
    
    Returns:
    
    True if the damage modifier is relevant to this event
  - getOutputDamage
```
double getOutputDamage(DamageModifier damageModifier)
```
    Gets the damage for the provided DamageModifier. Providing that isModifierApplicable(DamageModifier) returns true, the cached "damage" for the DamageModifier is returned.
    
    Parameters:
    
    damageModifier - The damage modifier to get the damage for
    
    Returns:
    
    The modifier
  - setOutputDamage
```
void setOutputDamage(DamageModifier damageModifier,
                     DoubleUnaryOperator function)
```
    Sets the provided Function to be used for the given DamageModifier. If the DamageModifier is already included in getModifiers(), the Function replaces the existing function. If there is no Tuple for the DamageModifier, a new one is created and added to the end of the list of Functions to be applied to the getBaseOutputDamage().
    If needing to create a custom DamageModifier is required, usage of the DamageModifier.Builder is recommended.
    
    Parameters:
    
    damageModifier - The damage modifier
    
    function - The function to map to the modifier
  - addDamageModifierBefore
```
void addDamageModifierBefore(DamageModifier damageModifier,
                             DoubleUnaryOperator function,
                             Set<DamageModifierType> before)
```
    Adds the provided DamageModifier and Function to the list of modifiers, such that the Set containing DamageModifierTypes provided in before will appear after the provided damage modifier.
    
    Parameters:
    
    damageModifier - The damage modifier to add
    
    function - The associated function
    
    before - The set containing the modifier types to come after the provided modifier
  - addDamageModifierAfter
```
void addDamageModifierAfter(DamageModifier damageModifier,
                            DoubleUnaryOperator function,
                            Set<DamageModifierType> after)
```
    Adds the provided DamageModifier and Function to the list of modifiers, such that the modifier will appear in order after any current modifiers whose type are included in the provided Set of DamageModifierTypes.
    
    Parameters:
    
    damageModifier - The damage modifier to add
    
    function - The associated function
    
    after - The set of modifier types to come before the new modifier
  - getModifiers
```
List<DamageFunction> getModifiers()
```
    Gets a list of simple Tuples of DamageModifier keyed to their representative Functions. All DamageModifiers are applicable to the entity based on the DamageSource and any possible invulnerabilities due to the DamageSource.
    
    Returns:
    
    A list of damage modifiers to functions
  - getKnockbackModifier
```
int getKnockbackModifier()
```
    Gets the knock back modifier. The modifier itself will apply to the momentum of the attacked entity.
    
    Returns:
    
    The knock back modifier
  - setKnockbackModifier
```
void setKnockbackModifier(int modifier)
```
    Sets the knock back modifier. The modifier itself will apply to the momentum of the attacked entity.
    
    Parameters:
    
    modifier - The knock back modifier to set

Interface AttackEntityEvent

Field Summary

Method Summary

Methods inherited from interface org.spongepowered.api.event.entity.TargetEntityEvent

Methods inherited from interface org.spongepowered.api.event.Event

Methods inherited from interface org.spongepowered.api.event.Cancellable

Field Detail

SOURCE

HARD_HAT_ARMOR

SHIELD

GENERAL_ARMOR

HELMET

CHESTPLATE

LEGGINGS

BOOTS

RESISTANCE

ABSORPTION

CREATOR

NOTIFIER

Method Detail

getOriginalDamage

getOriginalFinalDamage

getOriginalDamages

getOriginalModifierDamage

getOriginalFunctions

getBaseOutputDamage

setBaseOutputDamage

getFinalOutputDamage

isModifierApplicable

getOutputDamage

setOutputDamage

addDamageModifierBefore

addDamageModifierAfter

getModifiers

getKnockbackModifier

setKnockbackModifier