Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -49,6 +49,20 @@ public final class DamageRequest {
/** How the attacker's equipment should take part in the hit. */
@NotNull
private final WeaponStatsMode weaponStats;
/**
* What every damage type of the attacker's weapon is multiplied by, unless a type has its own factor.
* 1 leaves the weapon's damage as it is. See {@link #adjustWeaponDamage}.
*/
private final double weaponScale;
/**
* What is added to every damage type of the attacker's weapon, unless a type has its own amount. It may
* be negative. See {@link #adjustWeaponDamage}.
*/
private final double weaponBonus;
@Getter(AccessLevel.NONE)
private final Map<String, Double> weaponScales;
@Getter(AccessLevel.NONE)
private final Map<String, Double> weaponBonuses;
@Getter(AccessLevel.NONE)
private final boolean knockback;

Expand All @@ -58,6 +72,10 @@ private DamageRequest(Builder builder) {
this.cause = builder.cause;
this.amounts = Collections.unmodifiableMap(new LinkedHashMap<>(builder.amounts));
this.weaponStats = builder.weaponStats;
this.weaponScale = builder.weaponScale;
this.weaponBonus = builder.weaponBonus;
this.weaponScales = Collections.unmodifiableMap(new LinkedHashMap<>(builder.weaponScales));
this.weaponBonuses = Collections.unmodifiableMap(new LinkedHashMap<>(builder.weaponBonuses));
this.knockback = builder.knockback;
}

Expand All @@ -73,6 +91,48 @@ public boolean hasKnockback() {
return knockback;
}

/**
* @param type a damage type id of the plugin that calculates the damage, without a namespace
* @return what the weapon's damage of that type is multiplied by
*/
public double getWeaponScale(@NotNull String type) {
return weaponScales.getOrDefault(type, weaponScale);
}

/**
* @param type a damage type id of the plugin that calculates the damage, without a namespace
* @return what is added to the weapon's damage of that type
*/
public double getWeaponBonus(@NotNull String type) {
return weaponBonuses.getOrDefault(type, weaponBonus);
}

/**
* @return whether this request changes the weapon's damage at all
*/
public boolean adjustsWeaponDamage() {
return weaponScale != 1 || weaponBonus != 0 || !weaponScales.isEmpty() || !weaponBonuses.isEmpty();
}

/**
* Applies this request's scale and bonus to one damage type of the attacker's weapon: the amount is
* multiplied by the scale, then the bonus is added.
* <p>
* A type the weapon does not deal stays at 0, so a bonus never gives a weapon a damage type it does not
* have. The result can be negative when the bonus is; what to do with that is up to the caller.
* <p>
* This only means something where the weapon's damage is part of the hit, which is
* {@link WeaponStatsMode#ADD}.
*
* @param type the damage type id, without a namespace
* @param amount the weapon's damage of that type
* @return the adjusted amount
*/
public double adjustWeaponDamage(@NotNull String type, double amount) {
if (amount == 0) return amount;
return amount * getWeaponScale(type) + getWeaponBonus(type);
}

/**
* @return the sum of all amounts
*/
Expand Down Expand Up @@ -100,6 +160,14 @@ public static final class Builder {
/** Defaults to {@link WeaponStatsMode#ADD}. */
@NonNull
private WeaponStatsMode weaponStats = WeaponStatsMode.ADD;
@Setter(AccessLevel.NONE)
private final Map<String, Double> weaponScales = new LinkedHashMap<>();
@Setter(AccessLevel.NONE)
private final Map<String, Double> weaponBonuses = new LinkedHashMap<>();
@Setter(AccessLevel.NONE)
private double weaponScale = 1;
@Setter(AccessLevel.NONE)
private double weaponBonus = 0;
/** Defaults to true. */
private boolean knockback = true;

Expand All @@ -118,6 +186,66 @@ public Builder amount(@NonNull String type, double amount) {
return this;
}

/**
* Multiplies every damage type of the attacker's weapon. Defaults to 1.
*
* @param factor the factor, which must be a number and not negative
*/
@NotNull
public Builder weaponScale(double factor) {
this.weaponScale = checkScale(factor);
return this;
}

/**
* Multiplies one damage type of the attacker's weapon, in place of the factor for every type.
*
* @param type the damage type id of the plugin that calculates the damage, without a namespace
* @param factor the factor, which must be a number and not negative
*/
@NotNull
public Builder weaponScale(@NonNull String type, double factor) {
weaponScales.put(type, checkScale(factor));
return this;
}

/**
* Adds to every damage type the attacker's weapon deals. Defaults to 0.
*
* @param amount the amount, which may be negative
*/
@NotNull
public Builder weaponBonus(double amount) {
this.weaponBonus = checkBonus(amount);
return this;
}

/**
* Adds to one damage type of the attacker's weapon, in place of the amount for every type.
*
* @param type the damage type id of the plugin that calculates the damage, without a namespace
* @param amount the amount, which may be negative
*/
@NotNull
public Builder weaponBonus(@NonNull String type, double amount) {
weaponBonuses.put(type, checkBonus(amount));
return this;
}

private static double checkScale(double factor) {
if (Double.isNaN(factor) || factor < 0) {
throw new IllegalArgumentException("Weapon scale must be 0 or more, got " + factor);
}
return factor;
}

private static double checkBonus(double amount) {
if (Double.isNaN(amount)) {
throw new IllegalArgumentException("Weapon bonus must be a number");
}
return amount;
}

@NotNull
public DamageRequest build() {
return new DamageRequest(this);
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -85,4 +85,87 @@ void request_isNotChangedByLaterUseOfItsBuilder() {
assertEquals(1, request.getAmounts().size());
assertThrows(UnsupportedOperationException.class, () -> request.getAmounts().put("ice", 1D));
}

@Test
void weaponDamage_isLeftAloneByDefault() {
DamageRequest request = DamageRequest.builder().build();

assertFalse(request.adjustsWeaponDamage());
assertEquals(1D, request.getWeaponScale());
assertEquals(0D, request.getWeaponBonus());
assertEquals(20D, request.adjustWeaponDamage("physical", 20));
}

@Test
void weaponScale_multipliesEveryType() {
DamageRequest request = DamageRequest.builder().weaponScale(0.5).build();

assertTrue(request.adjustsWeaponDamage());
assertEquals(10D, request.adjustWeaponDamage("physical", 20));
assertEquals(5D, request.adjustWeaponDamage("fire", 10));
}

@Test
void weaponBonus_isAddedToEveryTypeTheWeaponDeals_andMayBeNegative() {
DamageRequest plus = DamageRequest.builder().weaponBonus(5).build();
DamageRequest minus = DamageRequest.builder().weaponBonus(-5).build();

assertTrue(plus.adjustsWeaponDamage());
assertEquals(25D, plus.adjustWeaponDamage("physical", 20));
assertEquals(15D, minus.adjustWeaponDamage("physical", 20));
assertEquals(-2D, minus.adjustWeaponDamage("fire", 3), "Clamping is left to the caller");
}

@Test
void weaponBonus_doesNotGiveAWeaponADamageTypeItDoesNotDeal() {
DamageRequest request = DamageRequest.builder().weaponBonus(5).weaponScale(2).build();

assertEquals(0D, request.adjustWeaponDamage("fire", 0));
}

@Test
void weaponScaleAndBonus_scaleFirstThenAdd() {
DamageRequest request = DamageRequest.builder().weaponScale(0.5).weaponBonus(3).build();

// 20 * 0.5 + 3
assertEquals(13D, request.adjustWeaponDamage("physical", 20));
}

@Test
void weaponScaleAndBonus_forOneType_replaceTheOnesForEveryType() {
DamageRequest request = DamageRequest.builder()
.weaponScale(0.5)
.weaponBonus(1)
.weaponScale("fire", 2)
.weaponBonus("ice", 10)
.build();

assertTrue(request.adjustsWeaponDamage());
// physical: both general values. fire: its own scale, the general bonus. ice: the general scale,
// its own bonus.
assertEquals(11D, request.adjustWeaponDamage("physical", 20));
assertEquals(41D, request.adjustWeaponDamage("fire", 20));
assertEquals(20D, request.adjustWeaponDamage("ice", 20));
assertEquals(2D, request.getWeaponScale("fire"));
assertEquals(0.5D, request.getWeaponScale("ice"));
assertEquals(10D, request.getWeaponBonus("ice"));
assertEquals(1D, request.getWeaponBonus("fire"));
}

@Test
void weaponScaleForOneTypeOnly_countsAsAnAdjustment() {
assertTrue(DamageRequest.builder().weaponScale("fire", 1).build().adjustsWeaponDamage());
assertTrue(DamageRequest.builder().weaponBonus("fire", 0).build().adjustsWeaponDamage());
}

@Test
void weaponScale_rejectsNegativeAndNotANumber_weaponBonusRejectsNotANumber() {
DamageRequest.Builder builder = DamageRequest.builder();

assertThrows(IllegalArgumentException.class, () -> builder.weaponScale(-1));
assertThrows(IllegalArgumentException.class, () -> builder.weaponScale(Double.NaN));
assertThrows(IllegalArgumentException.class, () -> builder.weaponScale("fire", -1));
assertThrows(IllegalArgumentException.class, () -> builder.weaponBonus(Double.NaN));
assertThrows(IllegalArgumentException.class, () -> builder.weaponBonus("fire", Double.NaN));
}
}
Loading