From 0dc69dfcdc7e0bb4b24ad33d557717284b68c835 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 12 Nov 2026 05:53:59 +0000 Subject: [PATCH] Let a damage request scale or add to the weapon's damage A request can now say that the attacker's weapon damage takes part in the hit changed: multiplied by a factor, with an amount added, for every damage type or for one. Divinity's damage action and area damage are weapon swings of that kind, and a skill that deals a share of the weapon's damage is too. Additive. A request that sets none of this leaves the weapon's damage as it is. Part of magemonkeystudio/divinity#365 Co-Authored-By: Claude Fable 5.2 Claude-Session: https://claude.ai/code/session_01FaEyTtryHphQWR4EVUMbsz --- .../codex/api/damage/DamageRequest.java | 128 ++++++++++++++++++ .../codex/api/damage/DamageRequestTest.java | 83 ++++++++++++ 2 files changed, 211 insertions(+) diff --git a/codex-api/src/main/java/studio/magemonkey/codex/api/damage/DamageRequest.java b/codex-api/src/main/java/studio/magemonkey/codex/api/damage/DamageRequest.java index fae8fd8..ae41996 100644 --- a/codex-api/src/main/java/studio/magemonkey/codex/api/damage/DamageRequest.java +++ b/codex-api/src/main/java/studio/magemonkey/codex/api/damage/DamageRequest.java @@ -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 weaponScales; + @Getter(AccessLevel.NONE) + private final Map weaponBonuses; @Getter(AccessLevel.NONE) private final boolean knockback; @@ -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; } @@ -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. + *

+ * 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. + *

+ * 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 */ @@ -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 weaponScales = new LinkedHashMap<>(); + @Setter(AccessLevel.NONE) + private final Map weaponBonuses = new LinkedHashMap<>(); + @Setter(AccessLevel.NONE) + private double weaponScale = 1; + @Setter(AccessLevel.NONE) + private double weaponBonus = 0; /** Defaults to true. */ private boolean knockback = true; @@ -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); diff --git a/codex-api/src/test/java/studio/magemonkey/codex/api/damage/DamageRequestTest.java b/codex-api/src/test/java/studio/magemonkey/codex/api/damage/DamageRequestTest.java index 15af987..00e78f8 100644 --- a/codex-api/src/test/java/studio/magemonkey/codex/api/damage/DamageRequestTest.java +++ b/codex-api/src/test/java/studio/magemonkey/codex/api/damage/DamageRequestTest.java @@ -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)); + } }