@rpgm-tools/neo-angband-core 0.18.0 → 0.19.0

package/dist/obj/power.js

@@ -5,8 +5,18 @@
  * (object_value_real) and randart balance.
  *
  * Faithful notes / deferrals (ledgered in parity/ledger/obj-power.yaml):
- * - The upstream `verbose`/`log_file` logging is dropped; it never affects the
- *   returned power. object_power's signature here is (reg, obj) with no logging.
+ * - The upstream `verbose`/`log_file` logging IS ported (PORT_TODO 5.5). All 59
+ *   `log_obj` sites narrate into obj/randart-log.ts's sink, which is a
+ *   module-level static exactly as upstream's `object_log` is - NULL for the
+ *   whole game except inside do_randart, so objectPower on the item-pricing
+ *   path pays nothing for it. object_power's signature stays (reg, obj): the
+ *   `log_file` argument is what SETS that static in the C, and there is only
+ *   ever one log. `verbose` is likewise not a parameter here - it gates four
+ *   lines in slay_power, every randart evaluation passes it, and nothing else
+ *   calls slayPower with a log open, so an open log is the flag.
+ *   This note used to say the logging was dropped "because it never affects
+ *   the returned power". That is true, and it was never the question: the
+ *   maintainer's disposition is pursue parity.
  * - Every `wield_slot(obj) == slot_by_name(player, "shooting")` test in
  *   upstream is exactly `obj->tval == TV_BOW` for the standard body (only a bow
  *   maps to the shooting slot), so it is ported as tvalIsLauncher(obj.tval).
@@ -18,6 +28,7 @@
  *   a bare curse template (curse->obj, which has no kind/ac/dd/ds/brands/slays)
  *   can be valued; a curse template is adapted by cursePowerObject.
  */
+import { randartLog, randartLogOpen, randartLogf } from "./randart-log.js";
 import { KF, OBJ_MOD, OF, TV } from "../generated/index.js";
 import { addGuardi, INT_MAX, INT_MIN, subGuardi } from "../guard.js";
 import { applyCurseAttributes, objectWeightOne, tvalIsAmmo, tvalIsJewelry, tvalIsLauncher, tvalIsMeleeWeapon, } from "./object.js";
@@ -57,31 +68,31 @@ const ARCHERY = [
     { ammoDam: 14, launchDam: 9, launchMult: 7 }, // bolt
 ];
 const FLAG_SETS = [
-    { type: OFT.SUST, factor: 1, bonus: 10, size: 5 },
-    { type: OFT.PROT, factor: 3, bonus: 15, size: 4 },
-    { type: OFT.MISC, factor: 1, bonus: 25, size: 8 },
+    { type: OFT.SUST, factor: 1, bonus: 10, size: 5, desc: "sustains" },
+    { type: OFT.PROT, factor: 3, bonus: 15, size: 4, desc: "protections" },
+    { type: OFT.MISC, factor: 1, bonus: 25, size: 8, desc: "misc abilities" },
 ];
 const T_LRES = 0;
 const T_HRES = 1;
 const ELEMENT_SETS = [
-    { type: T_LRES, resLevel: 3, factor: 6, bonus: INHIBIT_POWER, size: 4 },
-    { type: T_LRES, resLevel: 1, factor: 1, bonus: 10, size: 4 },
-    { type: T_HRES, resLevel: 1, factor: 2, bonus: 10, size: 9 },
+    { type: T_LRES, resLevel: 3, factor: 6, bonus: INHIBIT_POWER, size: 4, desc: "immunities" },
+    { type: T_LRES, resLevel: 1, factor: 1, bonus: 10, size: 4, desc: "low resists" },
+    { type: T_HRES, resLevel: 1, factor: 2, bonus: 10, size: 9, desc: "high resists" },
 ];
 const EL_POWERS = [
-    { type: T_LRES, ignorePower: 3, vulnPower: -6, resPower: 5, imPower: 38 }, // acid
-    { type: T_LRES, ignorePower: 1, vulnPower: -6, resPower: 6, imPower: 35 }, // elec
-    { type: T_LRES, ignorePower: 3, vulnPower: -6, resPower: 6, imPower: 40 }, // fire
-    { type: T_LRES, ignorePower: 1, vulnPower: -6, resPower: 6, imPower: 37 }, // cold
-    { type: T_HRES, ignorePower: 0, vulnPower: 0, resPower: 28, imPower: 0 }, // pois
-    { type: T_HRES, ignorePower: 0, vulnPower: 0, resPower: 6, imPower: 0 }, // light
-    { type: T_HRES, ignorePower: 0, vulnPower: 0, resPower: 16, imPower: 0 }, // dark
-    { type: T_HRES, ignorePower: 0, vulnPower: 0, resPower: 14, imPower: 0 }, // sound
-    { type: T_HRES, ignorePower: 0, vulnPower: 0, resPower: 8, imPower: 0 }, // shards
-    { type: T_HRES, ignorePower: 0, vulnPower: 0, resPower: 15, imPower: 0 }, // nexus
-    { type: T_HRES, ignorePower: 0, vulnPower: 0, resPower: 20, imPower: 0 }, // nether
-    { type: T_HRES, ignorePower: 0, vulnPower: 0, resPower: 20, imPower: 0 }, // chaos
-    { type: T_HRES, ignorePower: 0, vulnPower: 0, resPower: 20, imPower: 0 }, // disen
+    { name: "acid", type: T_LRES, ignorePower: 3, vulnPower: -6, resPower: 5, imPower: 38 },
+    { name: "electricity", type: T_LRES, ignorePower: 1, vulnPower: -6, resPower: 6, imPower: 35 },
+    { name: "fire", type: T_LRES, ignorePower: 3, vulnPower: -6, resPower: 6, imPower: 40 },
+    { name: "cold", type: T_LRES, ignorePower: 1, vulnPower: -6, resPower: 6, imPower: 37 },
+    { name: "poison", type: T_HRES, ignorePower: 0, vulnPower: 0, resPower: 28, imPower: 0 },
+    { name: "light", type: T_HRES, ignorePower: 0, vulnPower: 0, resPower: 6, imPower: 0 },
+    { name: "dark", type: T_HRES, ignorePower: 0, vulnPower: 0, resPower: 16, imPower: 0 },
+    { name: "sound", type: T_HRES, ignorePower: 0, vulnPower: 0, resPower: 14, imPower: 0 },
+    { name: "shards", type: T_HRES, ignorePower: 0, vulnPower: 0, resPower: 8, imPower: 0 },
+    { name: "nexus", type: T_HRES, ignorePower: 0, vulnPower: 0, resPower: 15, imPower: 0 },
+    { name: "nether", type: T_HRES, ignorePower: 0, vulnPower: 0, resPower: 20, imPower: 0 },
+    { name: "chaos", type: T_HRES, ignorePower: 0, vulnPower: 0, resPower: 20, imPower: 0 },
+    { name: "disenchantment", type: T_HRES, ignorePower: 0, vulnPower: 0, resPower: 20, imPower: 0 },
 ];
 /** Boost ratings for combinations of ability bonuses (index bonus/10). */
 const ABILITY_POWER = [
@@ -133,15 +144,23 @@ function powerClone(obj) {
 /* Property lookup (obj-properties.c L24)                               */
 /* ------------------------------------------------------------------ */
 /**
- * lookup_obj_property: the property whose type and stored index match. Stats
- * count as mods for a MOD lookup, exactly as upstream.
+ * lookup_obj_property (obj-properties.c:196) over a bare property table: the
+ * property whose type and stored index match, PLUS upstream's "special case -
+ * stats count as mods" (:207), which is the half that is easy to leave out and
+ * costs a NAME when you do.
+ *
+ * THE ONE IMPLEMENTATION. player/shape-lore.ts had a second copy that omitted
+ * the special case, so every shape's stat line rendered as "Adds -3 to ." with
+ * an empty name - a screen-visible blank that the copy with the special case
+ * could never have produced. Anything needing this lookup calls here.
  */
-export function lookupObjProperty(reg, type, index) {
-    for (const prop of reg.properties) {
+export function lookupObjPropertyIn(properties, type, index) {
+    for (const prop of properties) {
         if (!prop)
             continue;
         if (prop.type === type && prop.propIndex === index)
             return prop;
+        /* Special case - stats count as mods (obj-properties.c:207). */
         if (type === OBJ_PROPERTY.MOD &&
             prop.type === OBJ_PROPERTY.STAT &&
             prop.propIndex === index) {
@@ -150,21 +169,32 @@ export function lookupObjProperty(reg, type, index) {
     }
     return null;
 }
+/** lookup_obj_property against an ObjRegistry's table. */
+export function lookupObjProperty(reg, type, index) {
+    return lookupObjPropertyIn(reg.properties, type, index);
+}
 /* ------------------------------------------------------------------ */
 /* Power helper ratings (obj-power.c)                                   */
 /* ------------------------------------------------------------------ */
 function bowMultiplier(obj) {
     if (obj.tval !== TV.BOW)
         return 1;
-    return obj.pval;
+    const mult = obj.pval;
+    randartLogf(() => `Base mult for this weapon is ${mult}\n`);
+    return mult;
 }
 function toDamagePower(obj) {
     let p = Math.trunc((obj.toD * DAMAGE_POWER) / 2);
+    if (p)
+        randartLogf(() => `${p} power from to_dam\n`);
     /* Add a second lot of damage power for non-weapons. */
     if (!tvalIsLauncher(obj.tval) &&
         !tvalIsMeleeWeapon(obj.tval) &&
         !tvalIsAmmo(obj.tval)) {
-        p += obj.toD * DAMAGE_POWER;
+        const q = obj.toD * DAMAGE_POWER;
+        p += q;
+        if (q)
+            randartLogf(() => `Add ${q} from non-weapon to_dam, total ${p}\n`);
     }
     return p;
 }
@@ -172,6 +202,9 @@ function damageDicePower(obj) {
     let dice = 0;
     if (tvalIsMeleeWeapon(obj.tval) || tvalIsAmmo(obj.tval)) {
         dice = Math.trunc((obj.dd * (obj.ds + 1) * DAMAGE_POWER) / 4);
+        /* No newline, deliberately: object_power continues the line with
+         * "total is %d" once damage_dice_power returns (obj-power.c L1017). */
+        randartLogf(() => `Add ${dice} power for damage dice, `);
     }
     else if (!tvalIsLauncher(obj.tval)) {
         /* Power boost for nonweapons with combat flags. */
@@ -181,11 +214,12 @@ function damageDicePower(obj) {
             (obj.modifiers[OBJ_MOD.SHOTS] ?? 0) > 0 ||
             (obj.modifiers[OBJ_MOD.MIGHT] ?? 0) > 0) {
             dice = WEAP_DAMAGE * DAMAGE_POWER;
+            randartLogf(() => `Add ${dice} power for non-weapon combat bonuses, `);
         }
     }
     return dice;
 }
-function ammoDamagePower(obj) {
+function ammoDamagePower(obj, p) {
     if (!tvalIsLauncher(obj.tval))
         return 0;
     let launcher = -1;
@@ -198,7 +232,11 @@ function ammoDamagePower(obj) {
         launcher = 2;
     if (launcher === -1)
         return 0;
-    return Math.trunc((ARCHERY[launcher].ammoDam * DAMAGE_POWER) / 2);
+    const q = Math.trunc((ARCHERY[launcher].ammoDam * DAMAGE_POWER) / 2);
+    /* Logs p + q, the running total, not the return value - which is why this
+     * function takes p at all (obj-power.c L239). */
+    randartLogf(() => `Adding ${q} power from ammo, total is ${p + q}\n`);
+    return q;
 }
 function launcherAmmoDamagePower(obj, p) {
     if (!tvalIsAmmo(obj.tval))
@@ -212,37 +250,50 @@ function launcherAmmoDamagePower(obj, p) {
     if (obj.ego)
         p += Math.trunc((a.launchDam * DAMAGE_POWER) / 2);
     p = Math.trunc((p * a.launchMult) / (2 * MAX_BLOWS));
+    randartLogf(() => `After multiplying ammo and rescaling, power is ${p}\n`);
     return p;
 }
 function extraBlowsPower(obj, p) {
     const blows = obj.modifiers[OBJ_MOD.BLOWS] ?? 0;
     if (blows === 0)
         return p;
-    if (blows >= INHIBIT_BLOWS)
+    const before = p;
+    if (blows >= INHIBIT_BLOWS) {
+        randartLog(`INHIBITING - too many extra blows - quitting\n`);
         return p + INHIBIT_POWER;
+    }
     p = Math.trunc((p * (MAX_BLOWS + blows)) / MAX_BLOWS);
     /* Add boost for assumed off-weapon damage. */
     p += Math.trunc((NONWEAP_DAMAGE * blows * DAMAGE_POWER) / 2);
+    randartLogf(() => `Add ${p - before} power for extra blows, total is ${p}\n`);
     return p;
 }
 function extraShotsPower(obj, p) {
     const shots = obj.modifiers[OBJ_MOD.SHOTS] ?? 0;
     if (shots === 0)
         return p;
-    if (shots >= INHIBIT_SHOTS)
+    if (shots >= INHIBIT_SHOTS) {
+        randartLog(`INHIBITING - too many extra shots - quitting\n`);
         return p + INHIBIT_POWER;
+    }
     if (shots > 0) {
         p *= 10 + shots;
         p = Math.trunc(p / 10);
+        /* "%d%%" is a literal percent sign in the C. */
+        randartLogf(() => `Adding ${10 * shots}% power for extra shots, total is ${p}\n`);
     }
     return p;
 }
 function extraMightPower(obj, p, mult) {
     const might = obj.modifiers[OBJ_MOD.MIGHT] ?? 0;
-    if (might >= INHIBIT_MIGHT)
+    if (might >= INHIBIT_MIGHT) {
+        randartLog(`INHIBITING - too much extra might - quitting\n`);
         return p + INHIBIT_POWER;
+    }
     mult += might;
+    randartLogf(() => `Mult after extra might is ${mult}\n`);
     p *= mult;
+    randartLogf(() => `After multiplying power for might, total is ${p}\n`);
     return p;
 }
 function slayPower(reg, obj, p, dicePwr) {
@@ -275,45 +326,88 @@ function slayPower(reg, obj, p, dicePwr) {
     }
     if (numSlays + numBrands + numKills === 0)
         return p;
+    /* The `verbose` half (obj-power.c L370-393). Upstream threads a bool from
+     * object_power's caller purely to gate these four lines; every randart
+     * evaluation passes it, and nothing else in the port calls slayPower with a
+     * log open, so an open log IS the verbose flag here. */
+    if (randartLogOpen()) {
+        randartLog(`Slay and brands: `);
+        if (obj.brands) {
+            for (let i = 1; i < reg.brands.length; i++) {
+                if (obj.brands[i]) {
+                    const b = reg.brands[i];
+                    randartLog(`${b.name}x${b.multiplier} `);
+                }
+            }
+        }
+        if (obj.slays) {
+            for (let i = 1; i < reg.slays.length; i++) {
+                if (obj.slays[i]) {
+                    const sl = reg.slays[i];
+                    randartLog(`${sl.name}x${sl.multiplier} `);
+                }
+            }
+        }
+        randartLog(`\nbest power is : ${bestPower}\n`);
+    }
     let q = Math.trunc((dicePwr * dicePwr * (bestPower - 100)) / 2500);
     p += q;
+    randartLogf(() => `Add ${q} for slay power, total is ${p}\n`);
     if (numSlays > 1) {
         q = Math.trunc((numSlays * numSlays * dicePwr) / (DAMAGE_POWER * 5));
         p += q;
+        randartLogf(() => `Add ${q} power for multiple slays, total is ${p}\n`);
     }
     if (numBrands > 1) {
         q = Math.trunc((2 * numBrands * numBrands * dicePwr) / (DAMAGE_POWER * 5));
         p += q;
+        randartLogf(() => `Add ${q} power for multiple brands, total is ${p}\n`);
     }
     if (numSlays && numBrands) {
         q = Math.trunc((numSlays * numBrands * dicePwr) / (DAMAGE_POWER * 5));
         p += q;
+        randartLogf(() => `Add ${q} power for slay and brand, total is ${p}\n`);
     }
     if (numKills > 1) {
         q = Math.trunc((3 * numKills * numKills * dicePwr) / (DAMAGE_POWER * 5));
         p += q;
+        randartLogf(() => `Add ${q} power for multiple kills, total is ${p}\n`);
     }
-    if (numSlays === 8)
+    if (numSlays === 8) {
         p += 10;
-    if (numBrands === 5)
+        randartLogf(() => `Add 10 power for full set of slays, total is ${p}\n`);
+    }
+    if (numBrands === 5) {
         p += 20;
-    if (numKills === 3)
+        randartLogf(() => `Add 20 power for full set of brands, total is ${p}\n`);
+    }
+    if (numKills === 3) {
         p += 20;
+        randartLogf(() => `Add 20 power for full set of kills, total is ${p}\n`);
+    }
     return p;
 }
 function rescaleBowPower(obj, p) {
-    if (tvalIsLauncher(obj.tval))
+    if (tvalIsLauncher(obj.tval)) {
         p = Math.trunc(p / MAX_BLOWS);
+        randartLogf(() => `Rescaling bow power, total is ${p}\n`);
+    }
     return p;
 }
 function toHitPower(obj, p) {
-    return p + Math.trunc((obj.toH * TO_HIT_POWER) / 2);
+    const q = Math.trunc((obj.toH * TO_HIT_POWER) / 2);
+    p += q;
+    /* Gated on the TOTAL being non-zero, not the addend (obj-power.c L458). */
+    if (p)
+        randartLogf(() => `Add ${q} power for to hit, total is ${p}\n`);
+    return p;
 }
 function acPower(reg, obj, p) {
     if (obj.ac) {
         const weight = objectWeightOne(obj, reg.curses);
         p += BASE_ARMOUR_POWER;
         let q = Math.trunc((obj.ac * BASE_AC_POWER) / 2);
+        randartLogf(() => `Adding ${q} power for base AC value\n`);
         if (weight > 0) {
             let i = Math.trunc((750 * (obj.ac + obj.toA)) / weight);
             /* Avoid overpricing Elven Cloaks. */
@@ -327,26 +421,37 @@ function acPower(reg, obj, p) {
             q *= 5;
         }
         p += q;
+        randartLogf(() => `Add ${q} power for AC per unit weight, now ${p}\n`);
     }
     return p;
 }
 function toAcPower(obj, p) {
     if (obj.toA === 0)
         return p;
-    p += Math.trunc((obj.toA * TO_AC_POWER) / 2);
+    let q = Math.trunc((obj.toA * TO_AC_POWER) / 2);
+    p += q;
+    randartLogf(() => `Add ${q} power for to_ac of ${obj.toA}, total is ${p}\n`);
     if (obj.toA > HIGH_TO_AC) {
-        p += (obj.toA - (HIGH_TO_AC - 1)) * TO_AC_POWER;
+        q = (obj.toA - (HIGH_TO_AC - 1)) * TO_AC_POWER;
+        p += q;
+        randartLogf(() => `Add ${q} power for high to_ac, total is ${p}\n`);
     }
     if (obj.toA > VERYHIGH_TO_AC) {
-        p += (obj.toA - (VERYHIGH_TO_AC - 1)) * TO_AC_POWER * 2;
+        q = (obj.toA - (VERYHIGH_TO_AC - 1)) * TO_AC_POWER * 2;
+        p += q;
+        randartLogf(() => `Add ${q} power for very high to_ac, total is ${p}\n`);
     }
-    if (obj.toA >= INHIBIT_AC)
+    if (obj.toA >= INHIBIT_AC) {
         p += INHIBIT_POWER;
+        randartLog(`INHIBITING: AC bonus too high\n`);
+    }
     return p;
 }
 function jewelryPower(obj, p) {
-    if (tvalIsJewelry(obj.tval))
+    if (tvalIsJewelry(obj.tval)) {
         p += BASE_JEWELRY_POWER;
+        randartLogf(() => `Adding ${BASE_JEWELRY_POWER} power for jewelry, total is ${p}\n`);
+    }
     return p;
 }
 function modifierPower(reg, obj, p) {
@@ -358,10 +463,15 @@ function modifierPower(reg, obj, p) {
         const k = obj.modifiers[i] ?? 0;
         extraStatBonus += k * mod.mult;
         if (mod.power) {
-            p += k * mod.power * (mod.typeMult[obj.tval] ?? 1);
+            const q = k * mod.power * (mod.typeMult[obj.tval] ?? 1);
+            p += q;
+            if (q) {
+                randartLogf(() => `Add ${q} power for ${k} ${mod.name}, total is ${p}\n`);
+            }
         }
     }
     if (extraStatBonus > 249) {
+        randartLogf(() => `Inhibiting - Total ability bonus of ${extraStatBonus} is too high\n`);
         p += INHIBIT_POWER;
     }
     else if (extraStatBonus > 0) {
@@ -369,6 +479,7 @@ function modifierPower(reg, obj, p) {
         if (!q)
             return p;
         p += q;
+        randartLogf(() => `Add ${q} power for modifier total of ${extraStatBonus}, total is ${p}\n`);
     }
     return p;
 }
@@ -380,7 +491,9 @@ function flagsPower(reg, obj, p) {
         if (!flag)
             continue;
         if (flag.power) {
-            p += flag.power * (flag.typeMult[obj.tval] ?? 1);
+            const q = flag.power * (flag.typeMult[obj.tval] ?? 1);
+            p += q;
+            randartLogf(() => `Add ${q} power for ${flag.name}, total is ${p}\n`);
         }
         for (let j = 0; j < FLAG_SETS.length; j++) {
             if (FLAG_SETS[j].type === flag.subtype)
@@ -390,10 +503,16 @@ function flagsPower(reg, obj, p) {
     for (let i = 0; i < FLAG_SETS.length; i++) {
         const set = FLAG_SETS[i];
         const count = counts[i];
-        if (count > 1)
-            p += set.factor * count * count;
-        if (count === set.size)
-            p += set.bonus;
+        if (count > 1) {
+            const q = set.factor * count * count;
+            p += q;
+            randartLogf(() => `Add ${q} power for multiple ${set.desc}, total is ${p}\n`);
+        }
+        if (count === set.size) {
+            const q = set.bonus;
+            p += q;
+            randartLogf(() => `Add ${q} power for full set of ${set.desc}, total is ${p}\n`);
+        }
     }
     return p;
 }
@@ -403,19 +522,30 @@ function elementPower(obj, p) {
         const el = EL_POWERS[i];
         const ei = obj.elInfo[i];
         if ((ei.flags & EL_INFO_IGNORE) !== 0 && el.ignorePower !== 0) {
-            p += el.ignorePower;
+            const q = el.ignorePower;
+            p += q;
+            randartLogf(() => `Add ${q} power for ignoring ${el.name}, total is ${p}\n`);
         }
         if (ei.resLevel === -1) {
-            if (el.vulnPower !== 0)
-                p += el.vulnPower;
+            if (el.vulnPower !== 0) {
+                const q = el.vulnPower;
+                p += q;
+                randartLogf(() => `Add ${q} power for vulnerability to ${el.name}, total is ${p}\n`);
+            }
         }
         else if (ei.resLevel === 1) {
-            if (el.resPower !== 0)
-                p += el.resPower;
+            if (el.resPower !== 0) {
+                const q = el.resPower;
+                p += q;
+                randartLogf(() => `Add ${q} power for resistance to ${el.name}, total is ${p}\n`);
+            }
         }
         else if (ei.resLevel === 3) {
-            if (el.imPower !== 0)
-                p += el.imPower + el.resPower;
+            if (el.imPower !== 0) {
+                const q = el.imPower + el.resPower;
+                p += q;
+                randartLogf(() => `Add ${q} power for immunity to ${el.name}, total is ${p}\n`);
+            }
         }
         for (let j = 0; j < ELEMENT_SETS.length; j++) {
             const set = ELEMENT_SETS[j];
@@ -426,10 +556,16 @@ function elementPower(obj, p) {
     for (let i = 0; i < ELEMENT_SETS.length; i++) {
         const set = ELEMENT_SETS[i];
         const count = counts[i];
-        if (count > 1)
-            p += set.factor * count * count;
-        if (count === set.size)
-            p += set.bonus;
+        if (count > 1) {
+            const q = set.factor * count * count;
+            p += q;
+            randartLogf(() => `Add ${q} power for multiple ${set.desc}, total is ${p}\n`);
+        }
+        if (count === set.size) {
+            const q = set.bonus;
+            p += q;
+            randartLogf(() => `Add ${q} power for full set of ${set.desc}, total is ${p}\n`);
+        }
     }
     return p;
 }
@@ -439,8 +575,10 @@ function effectsPower(obj, p) {
         q = obj.activation.power;
     else if (obj.kind && obj.kind.power)
         q = obj.kind.power;
-    if (q)
+    if (q) {
         p += q;
+        randartLogf(() => `Add ${q} power for item activation, total is ${p}\n`);
+    }
     return p;
 }
 /** Scale v by num with the same INT_MIN/INT_MAX clamp as upstream. */
@@ -469,8 +607,11 @@ function cursePower(reg, obj, p) {
                 weightAffecting = true;
                 continue;
             }
+            const cname = reg.curses[i].name;
+            randartLogf(() => `Calculating ${cname} curse power...\n`);
             let cp = objectPower(reg, cursePowerObject(cobj));
             cp -= Math.trunc(power / 10);
+            randartLogf(() => `Adjust for strength of curse, ${cp} for ${cname} curse power\n`);
             q += cp;
         }
         /* Pass 2: weight-affecting curses, valued by difference of merged power. */
@@ -479,6 +620,7 @@ function cursePower(reg, obj, p) {
             applyCurseAttributes(reg.curses, -1, objLocal);
             objLocal.curses = null;
             const pAllCurse = objectPower(reg, objLocal);
+            randartLogf(() => `Power is ${pAllCurse} with all curses applied\n`);
             for (let i = 1; i < reg.curses.length; i++) {
                 const power = obj.curses[i]?.power ?? 0;
                 if (!power)
@@ -495,18 +637,23 @@ function cursePower(reg, obj, p) {
                 applyCurseAttributes(reg.curses, i, objLocal);
                 objLocal.curses = null;
                 const pAllButI = objectPower(reg, objLocal);
+                const cname = reg.curses[i].name;
+                randartLogf(() => `Power is ${pAllButI} with all but ${cname} curse applied\n`);
                 let pCurse = subGuardi(pAllCurse, pAllButI);
                 if (pCurse < 0) {
                     const resistance = Math.max(20, Math.min(100, power));
                     pCurse = scaleGuarded(pCurse, resistance);
                     pCurse = Math.trunc(pCurse / 100);
                 }
+                randartLogf(() => `Adjusted power is ${pCurse} for ${cname} curse\n`);
                 q = addGuardi(q, pCurse);
             }
         }
     }
-    if (q !== 0)
+    if (q !== 0) {
         p += q;
+        randartLogf(() => `Total of ${q} power added for curses, total is ${p}\n`);
+    }
     return p;
 }
 function nonstandardWeightPower(reg, obj, p) {
@@ -526,16 +673,31 @@ function nonstandardWeightPower(reg, obj, p) {
     /* ac_power already accounted for weight when the object provides base AC. */
     if (!obj.ac) {
         const adjWc = Math.trunc((stdWeight - nonstdWeight) / WGT_POWER_DEN_NOBASEAC);
-        adj = addGuardi(adj, scaleGuarded(adjWc, WGT_POWER_NUM_NOBASEAC));
+        const scaled = scaleGuarded(adjWc, WGT_POWER_NUM_NOBASEAC);
+        randartLogf(() => `Add ${scaled} power for non-standard weight of object not affecting base armor.\n`);
+        adj = addGuardi(adj, scaled);
     }
     /* THROWING items can gain damage with weight. */
     if (flags.has(OF.THROWING)) {
         const adjTh = Math.trunc(nonstdWeight / WGT_POWER_DEN_THROW) -
             Math.trunc(stdWeight / WGT_POWER_DEN_THROW);
-        adj = addGuardi(adj, scaleGuarded(adjTh, WGT_POWER_NUM_THROW));
+        const scaled = scaleGuarded(adjTh, WGT_POWER_NUM_THROW);
+        randartLogf(() => `Add ${scaled} power for non-standard weight of object good for throwing.\n`);
+        adj = addGuardi(adj, scaled);
     }
-    if (adj)
+    if (adj) {
         p = addGuardi(p, adj);
+        /* UPSTREAM TYPO, NOT REPRODUCED. obj-power.c:994 passes an int to "%p":
+         *   log_obj("Add %d power combined for non-standard weight; "
+         *           "total is %p\n", adj, p);
+         * That is undefined behaviour with no portable output - glibc prints a
+         * pointer-formatted value of whatever ends up in the register - so there
+         * is nothing here to be byte-identical TO. The port prints the number the
+         * line plainly means. Recorded in parity/ledger/obj-power.yaml rather
+         * than silently normalised, because a wart this port would usually keep
+         * (see the staircase invariant) is being dropped on purpose. */
+        randartLogf(() => `Add ${adj} power combined for non-standard weight; total is ${p}\n`);
+    }
     return p;
 }
 /* ------------------------------------------------------------------ */
@@ -549,7 +711,10 @@ export function objectPower(reg, obj) {
     let p = toDamagePower(obj);
     const dicePwr = damageDicePower(obj);
     p += dicePwr;
-    p += ammoDamagePower(obj);
+    /* Completes damage_dice_power's trailing "Add %d power for damage dice, ". */
+    if (dicePwr)
+        randartLogf(() => `total is ${p}\n`);
+    p += ammoDamagePower(obj, p);
     const mult = bowMultiplier(obj);
     p = launcherAmmoDamagePower(obj, p);
     p = extraBlowsPower(obj, p);
@@ -576,6 +741,7 @@ export function objectPower(reg, obj) {
     p = effectsPower(obj, p);
     p = cursePower(reg, obj, p);
     p = nonstandardWeightPower(reg, obj, p);
+    randartLogf(() => `FINAL POWER IS ${p}\n`);
     return p;
 }
 //# sourceMappingURL=power.js.map