Scaling System

Introduction

The Scaling system is the mathematical engine that powers all dynamic value calculations in Ascend from Nine Mountains. Whether you are creating techniques that deal damage, buffs that modify stats, or crafting effects that scale with player progression, understanding scaling is essential for creating balanced, engaging content.

Every damage number, healing amount, buff strength, and stat modifier flows through this system, creating the progression curves that make cultivation feel meaningful.

Core Architecture

The Scaling Interface

interface Scaling {
  value: number;          // Base multiplier
  /** When false, this stat remains active but is omitted from buff tooltips. */
  tooltipCondition?: string;
  stat?:                   // Stat to scale off. Normally 'power' or undefined
    | PhysicalStatistic
    | SocialStatistic
    | CombatStatistic
    | CraftingStatistic
    | TechniqueElement
    | undefined;
  scaling?: string;       // Special scaling mode (e.g. 'stacks', 'consumed', or a buff name)
  eqn?: string;           // Expression MULTIPLIED onto the result
  // When true, the eqn is INCLUDED in tooltip display. Default strips eqn so the
  // shown amount is just the base (value * stat), which is often zero outside combat.
  keepEqnForTooltip?: boolean;
  additiveEqn?: string;   // Expression ADDED to the result (after eqn multiplication)
  customScaling?: {       // Additional multiplier, e.g. '+30% per stack of a buff'
    multiplier: number;
    scaling: string;      // Same as scaling above (e.g. buff name)
    upgradeKey?: string;
  };
  max?: Scaling;          // Cap the final value
  scalingMax?: Scaling;   // Cap the resolved scaling multiplier before it is multiplied onto value
  divideByStanceLength?: boolean; // Divide the result by the number of techniques in the stance
  multiplyByStanceLength?: boolean; // Multiply the result by the number of techniques in the stance
  upgradeKey?: string;    // Links to mastery upgrades
  buff?: Buff;            // Buff reference used internally for some effects
  increment?: number;     // For hit-based scaling: each subsequent hit costs this much more of the scaling buff
  cantUpgrade?: boolean;  // When true, this scaling value cannot be improved by technique mastery upgrades
  isItem?: boolean;       // When true, the result is additionally multiplied by (1 + itemEffectiveness * 0.01). Set on pills, concoctions, and formation parts.
  /** When true, the result is additionally scaled by the Charisma multiplier in scope. */
  scalesWithCharisma?: boolean;
  /** Value that Charisma scales away from. Defaults to 0; inverse percentages use 100. */
  charismaScalingPivot?: number;
  /** Snapshot of `value` taken before harmony upgrades are applied; used internally for stacking effects that need the original pre-harmony number. */
  baseValue?: number;
}

Valid stat Values

The stat field accepts any combat statistic, crafting statistic, physical statistic, social statistic, or technique element. The most commonly used values are:

Combat: 'power', 'defense', 'barrier', 'artefactpower', 'maxhp', 'hp', 'toxicity', 'maxtoxicity', 'critchance', 'critmultiplier', 'lifesteal', 'vulnerability', 'qiDroplets'

Crafting: 'control', 'intensity', 'maxpool', 'pool', 'resistance', 'itemEffectiveness'

Physical: 'muscles', 'dantian', 'meridians', 'flesh', 'digestion', 'eyes'

Elements: 'blood', 'blossom', 'fist', 'cloud', 'weapon', 'celestial', 'none'

Evaluation Formula

The system resolves fields in this fixed order, each layer multiplying or adding onto the result of the previous:

output = value
output *= stat                          // if stat is set
output *= scalingValue                  // if scaling is set; bounded by scalingMax if present
output *= eqn                           // if eqn is set
output *= (1 + itemEffectiveness * 0.01) // if isItem is true
output *= (1 + customScaling.multiplier * customScalingValue) // if customScaling is set
output += additiveEqn                  // if additiveEqn is set
output = apply max cap                 // if max is set

The key implication is that isItem and customScaling are applied after eqn, meaning they compound on top of any equation-based multiplier rather than being part of it.

Deep Dive: Scaling Patterns

Pattern 1: Flat Values

When to use: Fixed effects, utility abilities, resource generation that should not scale with combat stats.

// Always grants exactly 3 stacks
{
  value: 3,
  stat: undefined  // No stat multiplication
}

// Fixed damage (rare, usually for utility)
{
  value: 100,
  stat: undefined
}

// Equation-only calculation
{
  value: 1,
  stat: undefined,
  eqn: 'toxicity * 2'  // Result comes entirely from equation
}

Real Example: Concentrate Force scales only with Ripple Force stacks:

amount: {
  value: 1,
  stat: undefined,
  scaling: rippleForce.name,  // 1 damage per stack, no stat scaling
  max: { value: 7, upgradeKey: 'maxStacks' }
}

Pattern 2: Basic Stat Scaling

When to use: Standard techniques, straightforward damage/healing effects.

// 150% of player's power as damage
{
  value: 1.5,
  stat: 'power'
}

// Barrier equal to 300% of defense
{
  value: 3,
  stat: 'defense'
}

// Crafting perfection based on control
{
  value: 0.8,
  stat: 'control'
}

Real Example: Sun Blast technique:

amount: {
  value: 2,              // 200% of power
  stat: 'power',
  upgradeKey: 'power'    // Improves with mastery
}

Pattern 3: Stack-Based Scaling

When to use: Buff effects that scale with accumulated stacks, combo systems.

// Damage per buff stack
{
  value: 0.3,        // 30% power per stack
  stat: 'power',
  scaling: 'stacks'
}

// Fixed amount per stack (no stat scaling)
{
  value: 10,         // 10 damage per stack
  scaling: 'stacks'
}

Real Example: Blossom technique scaling with Vitality:

amount: {
  value: 0.3,
  stat: 'power',
  scaling: 'stacks'  // 30% power x Vitality stacks
}

Pattern 4: Game State Scaling

When to use: Effects that respond to dynamic game conditions like toxicity, health, etc.

// Final value = 0.1 * power * toxicity
{
  value: 0.1,
  stat: 'power',
  scaling: 'toxicity'
}

Real Example: Lianjin Bandolier toxicity scaling:

stats: {
  power: {
    value: 0.005,        // 0.5% power per toxicity point
    stat: 'power',
    scaling: 'toxicity',
    max: { value: 1, stat: 'power' }  // Capped at 100% bonus
  }
}

Pattern 5: Cross-Buff Scaling

When to use: Synergies between different buffs, combo effects that reward specific buff combinations.

// Scale with specific buff stacks
{
  value: 1,
  scaling: specificBuffName  // Uses that buff's current stacks
}

// Scale with target's debuffs
{
  value: 2,
  stat: 'power',
  scaling: 'target.' + debuffName  // Enemy's debuff stacks
}

Real Example: Celestial Discordance:

amount: {
  value: 1,
  scaling: 'target.' + harmonicDiscord.name  // Damage per target's discord
}

Pattern 6: Complex Equations

When to use: Percentage calculations, conditional logic, multi-variable formulas.

// Toxicity percentage bonus
{
  value: 3,
  stat: 'power',
  eqn: 'toxicity/maxtoxicity'  // Scales with toxicity %
}

// Conditional damage boost
{
  value: 1,
  stat: 'power',
  eqn: 'qi < maxqi * 0.3 ? 2 : 1'  // Double power when low on qi
}

// Multi-buff synergy
{
  value: 4,
  eqn: `${flag(buff1.name)} + ${flag(buff2.name)}`  // Sum of two buffs
}

Pattern 7: Capped Scaling

When to use: Preventing runaway scaling, maintaining game balance.

// Stat scaling with hard cap
{
  value: 0.05,         // 5% per stack
  stat: 'power',
  scaling: 'stacks',
  max: { value: 2, stat: 'power' }  // Max 200% power bonus
}

// Fixed numerical cap
{
  value: 10,
  scaling: 'stacks',
  max: { value: 100 }   // Never exceeds 100
}

Real Example: Ripple Force power bonus:

stats: {
  power: {
    value: 0.05,          // 5% per stack
    stat: 'power',
    scaling: 'stacks',
    max: {
      value: 2,           // Caps at 200% power
      stat: 'power'
    }
  }
}

Pattern 8: Stance Length Adjustment

When to use: Effects that need to stay constant regardless of stance size (divide) or that should compound with longer stances (multiply).

// Total output stays constant regardless of stance size
// (e.g. a technique that deals 300% power total, split across all techniques)
{
  value: 3,
  stat: 'power',
  divideByStanceLength: true
}

// Total output grows with stance size
// (e.g. a technique that deals 50% power per technique in the stance)
{
  value: 0.5,
  stat: 'power',
  multiplyByStanceLength: true
}

Pattern 9: Hit-Based Increment

When to use: Multi-hit techniques where each subsequent hit consumes progressively more of a buff stack.

{
  value: 0.5,
  stat: 'power',
  scaling: flow.name,
  increment: 5  // First hit costs current stacks; second costs stacks+5; third costs stacks+10; etc.
}

Pattern 10: Item-Effectiveness Scaling

When to use: Consumables (pills, concoctions, formation parts) where the effect should scale with the item’s quality tier.

// A healing pill that benefits from item effectiveness
{
  value: 500,
  stat: undefined,
  isItem: true  // Multiplies by (1 + itemEffectiveness * 0.01)
}

// A formation part that scales with both artefactpower and item effectiveness
{
  value: 1,
  stat: 'artefactpower',
  eqn: '1 + (itemEffectiveness * 0.01)',
  isItem: true
}

Standard scaling

To keep numbers consistent, there are a few standard patterns for scaling you want to follow:

For technique effects

Anything that creates a direct effect (damage, healing, barrier) on techniques should scale from power:

{
  value: 1, // 100% of power
  stat: "power"
}

For stacks of buffs

Anything that produces stacks of buffs should not scale off any stat, but can scale off other fields to increase those stacks:

{
  value: 1, // Create 1 stack
  stat: undefined,
  scaling: "Flow" // Multiply by the flow stacks
}

For items

Consumables should normally have a flat scaling to ensure that lower realm items are not excessively powerful in higher realms.

{
  value: Math.floor(window.modAPI.utils.getExpectedHealth("bodyForging", "Late") * 0.5), // A flat 50% of the players expected hp in the Body Forging realm
  stat: undefined,
  eqn: '1 + (itemEffectiveness * 0.01)', // Multiplied by item effectiveness
}

For artefacts / formation parts

Externally controlled / powered items like artefacts and formation parts should scale off artefact power, not power:

{
  value: 1,
  stat: 'artefactpower',
  eqn: '1 + (itemEffectiveness * 0.01)', // Only for formation parts scale by item effectiveness too
}

Practical Examples by School

Fist School: Stack Accumulation

// Generate Flow stacks
{
  kind: 'buffSelf',
  buff: flow,
  amount: { value: 1 }  // Always 1 stack
}

// Convert Flow to damage
{
  kind: 'damage',
  amount: {
    value: 0.8,           // 80% power per Flow stack
    stat: 'power',
    scaling: flow.name
  }
}

Weapon School: Progressive Momentum

// Momentum builds over turns
stats: {
  power: {
    value: 0.02,          // 2% power per stack
    stat: 'power',
    scaling: 'stacks',
    max: { value: 0.5, stat: 'power' }  // 50% power cap
  }
}

Celestial School: Dual Attunement

// Power from both light and dark
stats: {
  celestialBoost: {
    value: 4,
    eqn: `${flag(lunarAttunement.name)} + ${flag(solarAttunement.name)}`
  }
}

Blood School: Risk/Reward

// Low health = high power
{
  value: 2,
  stat: 'power',
  eqn: '1 - (hp / maxhp)',   // max power at 0 hp
}

Advanced Techniques

Upgrade Key Integration

Link scaling to mastery progression:

{
  value: 0.65,
  stat: 'intensity',
  upgradeKey: 'completion'  // Improves as player masters technique
}

// Upgrade affects caps
{
  value: 3,
  scaling: 'stacks',
  max: {
    value: 5,
    upgradeKey: 'maxStacks'  // Max stacks increase with mastery
  }
}

// Prevent upgrade on specific scaling values
{
  value: 1.5,
  stat: 'power',
  cantUpgrade: true  // This specific value will not be improved by mastery
}

State-Dependent Effects

// Desperation bonus
{
  kind: 'perfection',
  amount: {
    value: 20,
    eqn: '(stability < 30) * 20'  // Bonus when desperate
  }
}

Tips and Best Practices

Scaling Guidelines

Damage Multipliers:

  • Basic attacks: 0.5-1.2x stat
  • Strong techniques: 1.5-2.5x stat
  • Ultimate abilities: 3.0-4.0x stat
  • Per-stack scaling: 0.05-0.1x stat per stack

When to Use Each Pattern

  1. Flat Values (stat: undefined):

    • Utility effects (cleanse, dispel)
    • Resource generation/consumption
    • Equation-only calculations
    • Upgrade-driven progression

  2. Basic Stat Scaling:

    • Standard damage and healing
    • Straightforward stat bonuses
    • Effects that should grow with character power

  3. Stack Scaling:

    • Combo systems and buff interactions
    • Resource accumulation mechanics
  4. Equation Scaling:
    • Complex conditional logic
    • Percentage-based effects
    • Multi-variable calculations
  5. divideByStanceLength and multiplyByStanceLength:
    • Total-budget effects that should not compound as stances grow longer (divideByStanceLength)
    • Effects that should grow with stance size (multiplyByStanceLength)
  6. increment:
    • Multi-hit techniques where later hits should cost more than earlier ones

Balance Considerations

  • Always cap percentage scaling to prevent exponential growth
  • Use meaningful stat relationships (power for damage, control for crafting)
  • Test edge cases thoroughly, especially with equations
  • Consider upgrade keys for meaningful progression
  • Make patterns intuitive - players will optimize around your systems
  • Use cantUpgrade on effects that are already balanced at their base value and should not grow further

Common Pitfalls

  1. Uncapped scaling - Leads to broken balance
  2. Illogical stat relationships - Confuses players
  3. Overly complex equations - Hard to debug and understand
  4. Missing progression - Static effects feel unrewarding
  5. Inconsistent patterns - Makes the system unpredictable

The scaling system is powerful and flexible. Master these patterns, and you will create techniques and effects that feel both impactful and balanced, scaling naturally with player progression while maintaining strategic depth.