RO Renewal Math Core — Scenarios

Smoke test for the simplest possible physical damage path. No skill, no buffs, no cards, no element advantage. If this is wrong, everything is wrong.

Tests skill multiplier on physical damage path. Bash Lv10 multiplier is 400% (100 + 30*10). Verifies the skill formula evaluator and that the multiplier applies to WeaponratioATK at the right step.

Tests magical damage pipeline, element table lookup, and element advantage multiplier. Fire vs Earth lv1 should yield 1.50x; ensure the magical pipeline is structurally separate from physical.

Tests conditional Modifier evaluation. Hydra Card is '+20% damage to Demi-Human'. Same attack against a non-Demi-Human target should NOT include the bonus. Verifies the condition predicate language.

Tests critical hit path: crit ignores soft DEF (verify against rAthena which DEF components are skipped), applies critical multiplier (2.0 by default), and katar weapon type doubles base crit rate (verify rAthena handles this in stat resolution, not in damage formula).

Tests stat resolution with multiple stacking Effects. Blessing adds +10 STR/INT/DEX (flat). Increase AGI adds +DEX-relative AGI. Two-Hand Quicken adds ASPD%. Verifies that flat and percent Modifiers in the same scope stack correctly (additively for percent per D-005).

Tests the formulaId escape hatch (per D-010) for skills too unique for the expression language. Asura Strike: damage scales with SP, ignores DEF entirely, but Ghost armor (typical PvP build) has special interaction with Ghost-element. Verify the formulaId function path runs and DEF-ignore both flags are respected.

Same character, same target, same skill — only the weapon's refine level differs. Tests the refinement formula (D-008) and verifies that refine bonus enters via WeaponATK, not as a generic Modifier. Also tests over-refine (above safe level) bonus.

Tests Effect with periodic tickAction. Poison ticks every N seconds dealing damage based on max HP. Verify (a) the library returns per-tick damage when given the tick number, (b) the snapshot policy works (default dynamic: poison damage changes if MaxHP changes mid-poison), (c) total damage over duration matches expected.

Per D-015, the library does per-target math for AoE — callers pass an array of defenders. Tests that each defender's damage is computed independently with its own element/race/size against the same attacker. Also tests Magnum Break's self-buff (fire-conversion endow on next attack) as a triggered Effect candidate.

Tests the accuracy check and perfect-dodge path. Verifies that hit rate is computed correctly and that 'miss' and 'perfect_dodge' are distinct outcomes with different DamageResult shapes.

Tests the compareLoadouts utility. Same character stats, two different equipment setups, computes expected DPS for each. This is what build calculators do — and it's the most user-facing function in the simulator.

Verifies the upper end of the element table. Holy attacking Undead lv4 should be the strongest single-multiplier interaction in the game (typically 175%+). If this number is wrong, the table lookup is wrong.

Negative-control complement to SC-003. Same Fire Bolt cast, but defender is Fire-element instead of Earth. Multiplier should be ~25% (Fire vs Fire lv1) or near-zero at higher levels. Tests that the pipeline doesn't crash on heavy resistance and that the minimum-damage clamp fires correctly.

Tests the absorption case — some element interactions yield a NEGATIVE multiplier, meaning the 'damage' heals the target. The library must support this and the outcome should reflect 'absorbed' (a distinct DamageResult outcome).

Three sub-scenarios with identical attacker and identical Mandragora-type defender, varying only elementLevel (1 vs 2 vs 3). Damage must be monotonically different — proves element LEVEL is being read from the defender, not hardcoded.

resolveStatsOnly action. Verifies MATK derivation pipeline (the magical equivalent of D-003's ATK components). Two cases: base Wizard, then same Wizard with +10 INT food and Magnificat (which boosts SP regen but is included here as a stand-in for buff stacking). Expected MATK values are computed approximately from the Renewal formula.

Tests multi-hit magical skill behavior. Storm Gust does up to 10 hits per cast, each independently calculated. Each hit re-applies element multiplier and MDEF subtraction. Verifies the library returns 10 distinct damage instances and totalDamage is their sum.

Tests element-conversion buffs. Aspersio is a Priest skill that endows a weapon with Holy element for ~3 minutes. The attack should switch element from the weapon's stored element (Neutral) to Holy. Critically — the weapon's stored element field should NOT change; the active Effect provides the override at calculation time.

Tests that race-targeted modifiers apply to MAGICAL damage just as they do to physical. Soul Strike is Ghost-element by default. Mage equipped with a card that adds '+% damage to Demon race' should see the bonus apply.

Heaven's Drive is an Earth-element AoE that hits ground tiles. This scenario establishes whether (in our implementation) Heaven's Drive respects hard/soft MDEF normally or has a special defIgnore. Run against a Sage-class target with high MDEF.

Tests the freeze-status interaction. Frost Diver applies Frozen to the target on success. While Frozen, the target's DEFENSIVE element becomes Water lv1, regardless of its armor — this is a major game-mechanic interaction. Verifies: (1) Frost Diver returns a trigger candidate, (2) once Frozen is active (modeled as an Effect on the defender), a subsequent Wind attack treats the defender as Water lv1.

The most important test of refine math (D-008). Sweeps refine 0,4,7,8,10,15 on a weapon-level-3 weapon, expects strictly monotonic damage AND a visible inflection at the safe-refine boundary (+7) where over-refine bonus kicks in. If your library handles refine as a simple linear addition, this scenario reveals it.

Tests the per-weapon-type size-multiplier table. Same character, same target stats, only weapon type and target size vary. Daggers should excel vs Small; Spears vs Large; Swords are balanced. If a developer left the size table unwired, all 9 cells will show the same damage — this matrix reveals it instantly.

Tests multi-hit physical skill with hitCount=2. Each hit is independent (separate crit roll, separate DEF subtraction). Also verifies ranged-attack flag (Hunter's bow attacks count as ranged for Pneuma/etc.).

Specifically constructs a case where (raw damage) - (hardDEF + softDEF) <= 0. The library must clamp to 1 (D-004 damage floor rule) and the outcome must remain 'hit', not 'immune'. This is the difference between 'hits do nothing' (still progresses certain mechanics) and 'attack misses entirely' (different game logic).

Same attacker, same high-DEF/high-soft-DEF defender. Four skills with different defIgnore configurations. Damage should clearly differ: full-ignore highest, then hard-only or soft-only depending on which dominates, then no-ignore lowest. Verifies that skill.defIgnore.{hard,soft} is wired through correctly.

Perfect dodge is checked BEFORE the standard hit-vs-flee roll. Tests with deliberately mismatched accuracy: extremely high HIT, low FLEE — perfect dodge should still proc at its rate. 1000 sampled attacks with seed; expect perfect_dodge count within statistical tolerance of LUK/10 + flat bonuses.

Some passives turn auto-attacks into chance-based multi-hits. Triple Attack (Monk skill) gives auto-attacks a chance to hit 3 times. Tests that the library can express 'this auto-attack might be 1 hit or 3 hits' as a probabilistic outcome. In expected mode, returns the EV; in rolled mode, the outcome is sampled.

Combines AoE math (per-defender independent calculation) with a self-applied trigger (Magnum Break leaves the caster with a fire-endow buff for 10 seconds). Same as SC-010 in shape but with explicit assertions on the self-trigger and a follow-up sub-scenario verifying the next auto-attack uses Fire element.

Tests the damage.dealt.class.boss modifier scope. Crucially, a player wearing a +Boss card vs a Normal-class monster should NOT receive the bonus — even if everything else matches. Mirrors SC-004's race-condition logic for class.

Bowling Bash is a Knight skill with very high multiplier (~600%+ at Lv10). Tests that high-multiplier skills don't overflow, that the size modifier still applies, and that the breakdown shows the multiplier chain clearly. Use a Spear (favored vs Large) on a Large target to maximize all factors.

Verifies that multiple Modifiers with identical scope and condition stack ADDITIVELY (per D-005: 'two +10% cards give +20%, not +21%'). Three Hydra cards (each +20% vs Demi-Human) should give +60% total, not (1.20)^3 ≈ +73%.

Two cards with DIFFERENT scopes (race vs size) on the same weapon. Both should apply independently to a target matching both conditions. Verifies that scope grouping works correctly — race.demihuman bonus and size.medium bonus are in different scope groups and combine multiplicatively across groups but additively within.

Tests the hpBelow condition predicate targeting self. Run the same skill twice: once at full HP (no bonus), once at 30% HP (bonus applies). The two damage values must clearly differ.

Tests the weaponType condition predicate. The same Effect is active on the attacker for both variants; in one, attacker wields a sword (bonus applies); in the other, a dagger (bonus does not). Effect is in activeEffects either way — the library decides based on weapon at calc time.

Tests recursive condition combinators. The card applies a bonus to all defenders EXCEPT those that are Fire or Holy. Validates: (a) z.lazy() recursion works, (b) NOT inverts correctly, (c) OR inside NOT evaluates as expected.

Card combos are pairs of cards that grant an extra bonus when both are equipped. Tests an AND combinator over hypothetical 'cardEquipped' or 'hasItem' predicates. NOTE: this requires adding a 'cardEquipped' predicate kind to D-009 — surfacing the gap is part of this scenario's value.

Tests set bonuses, which are functionally combo cards across equipment items (not card slots). Same design gap as CARD-006 — requires a 'setEquippedCount >= N' predicate. Documents the requirement; scenario stays draft until resolved.

Tests the mapType predicate. Same character, same target — only the context.mapType differs across variants. Card should apply in pvp/gvg, not in pve.

A real-world-flavored card with AND of three conditions: class=boss, race=demon, mapType=pve. Tests that all three must match. Four variants flip each condition off in turn — exactly one variant should have the bonus active.

Tests that modifiers from DIFFERENT sources (Card vs Effect) in the SAME scope stack additively per D-005. The total atk.percent should be +25%, not (1.10)(1.15)=1.265.

Two independent buffs targeting different stats (Blessing → STR/INT/DEX, Increase AGI → AGI/ASPD). Both should fully apply with no interaction. The canonical positive case — if this doesn't work, the buff system is fundamentally broken. (Note: this duplicates SC-006 intentionally as a starting point for the STATUS-* suite.)

When the same Effect is applied to an Actor that already has it active, with stackingPolicy='refresh', the duration restarts but Modifiers do NOT double. Tests that the library de-duplicates by Effect ID, not by Modifier identity.

Tests that Effects with stackingPolicy='stack_intensity' use the stacks field to multiply Modifier values OR tick damage. This scenario uses tick damage scaling. Demonstrates that 5 stacks of bleed deal 5x the per-stack damage.

Per D-004, default snapshot=false means DoT ticks recompute from current state every tick. Two sub-tick computations: same Poison on the same target, but a buff that raises VIT (and therefore MaxHP) is active in the second. Tick damage must differ.

Inverse of STATUS-004. When snapshot=true, tick damage is computed from the snapshotState captured at apply time, not from current state. Even if the caster (or target) gets buffed later, ticks use the frozen values.

With stackingPolicy='stack_independent', applying the same Effect twice creates two distinct Effect instances on the target. Each has its own duration and ticks independently. Common case: two players DoT the same monster.

An Effect with maxStacks=5 should never exceed 5 stacks regardless of how many times it's applied. Tests that the schema's stacks field never exceeds maxStacks. (Note: enforcement is shared between caller (on apply) and library (on read) — both should respect it.)

Tests the hasStatus condition predicate (D-009). A Modifier conditional on the defender having a specific Effect active. Variants: target frozen → bonus applies; target not frozen → bonus does not.

Tests that debuff Effects with negative-value Modifiers reduce resolved stats correctly. Decrease AGI: -AGI flat → lower resolved AGI → lower FLEE. Confirms that flat modifiers with negative values work and don't accidentally clamp to zero.

Tests stackingPolicy='ignore'. If a buff with this policy is already on the actor, re-applying it does nothing (duration not refreshed, modifiers not doubled). This is rare in RO but exists for certain self-buffs that shouldn't be 'recasted up'. Verifies the library doesn't accidentally duplicate the effect.