Magic progression is the spell ladder for your equipped staff ({base.weaponName}). Higher Magic auto-casts the strongest castable spell — that's the unlock that drives magic DPS.
)}
);
}
// ---- main pane -----------------------------------------------------------
function PlannerPane({ input, set }){
const SP = P();
const base = input;
const combatType = base.combatType;
const persisted = useRef(loadCfg());
const c0 = persisted.current;
const [metric, setMetric] = useState('xph');
const [futureWeapons, setFutureWeapons] = useState(!!c0.futureWeapons);
const [lockGear, setLockGear] = useState(!!c0.lockGear);
// Pause recomputation to save cycles when you're not actively planning. The
// shown plan freezes; `stale` flags that inputs drifted since it was built.
const [paused, setPaused] = useState(!!c0.paused);
const [stale, setStale] = useState(false);
// Sustained-boosts toggle is shared with the melee tab's "Avg over session"
// toggle — both read/write the same input.sustained so flipping one flips both.
const sustained = !!base.sustained;
const [userTargets, setUserTargets] = useState(c0.targets || {});
const [locked, setLocked] = useState(c0.locked || {}); // skill -> bool (frozen at current)
const [startXpUser, setStartXpUser] = useState(c0.startXp || {}); // skill -> xp (undefined = default)
const [poolByType, setPoolByType] = useState(c0.poolByType || {});
const [showPool, setShowPool] = useState(false);
// design-canvas captures wheel events (native listener on an ancestor) to
// zoom/pan the whole page. Stop wheel inside scroll areas so the mouse wheel
// scrolls the list instead of zooming.
const noZoom = useCallback((el) => {
if (!el || el.__noZoom) return;
el.__noZoom = true;
el.addEventListener('wheel', (e) => e.stopPropagation(), { passive: true });
}, []);
// resolve the active pool for this combat type (seed from defaults once)
const pool = useMemo(() => {
const stored = poolByType[combatType];
if (stored) {
// keep hypotheticals in sync with the toggle
const def = SP.defaultPool(combatType, futureWeapons);
const hypo = (SP.CANDIDATES[combatType]?.weaponHypo) || [];
let weapon = stored.weapon || def.weapon;
if (futureWeapons) weapon = [...new Set([...weapon, ...hypo])];
else weapon = weapon.filter(w => !hypo.includes(w));
return { ...def, ...stored, weapon };
}
return SP.defaultPool(combatType, futureWeapons);
}, [poolByType, combatType, futureWeapons]);
const setPool = (next) => {
const nbt = { ...poolByType, [combatType]: next };
setPoolByType(nbt);
};
useEffect(() => { saveCfg({ metric, futureWeapons, lockGear, sustained, paused, targets:userTargets, locked, startXp:startXpUser, poolByType }); },
[metric, futureWeapons, lockGear, sustained, paused, userTargets, locked, startXpUser, poolByType]);
// relevant skills + effective targets. A locked skill freezes at its current
// level (target = current) and is excluded from training.
const relevant = SP.SKILLS_FOR[combatType] || SP.SKILLS_FOR.melee;
const defaultTarget = (s) => s === 'defence' ? (relevant.includes('defence') ? 99 : base.defence) : 99;
const targets = useMemo(() => {
const t = {};
for (const s of relevant) t[s] = locked[s] ? base[s] : (userTargets[s] ?? defaultTarget(s));
return t;
}, [combatType, locked, userTargets, base.attack, base.strength, base.defence, base.ranged, base.magic]);
// current xp per skill: default to the xp the current level requires, clamped
// to the current level's xp band.
const startXp = useMemo(() => {
const sx = {};
for (const s of relevant){
const lo = SP.xpAt(base[s]), hi = base[s] < 99 ? SP.xpAt(base[s] + 1) - 1 : SP.xpAt(99);
const u = startXpUser[s];
sx[s] = (u != null && isFinite(u)) ? Math.max(lo, Math.min(hi, u)) : lo;
}
return sx;
}, [combatType, startXpUser, base.attack, base.strength, base.defence, base.ranged, base.magic]);
const computePlan = () => {
try {
return SP.buildPlan(base, { metric, targets, startXp, pool, futureWeapons, lockGear, sustained, maxLevels:600 });
} catch (e) { return { ok:false, error: String(e && e.message || e) }; }
};
// Debounced: each recompute is ~300ms, so running it synchronously on every
// keystroke makes the controls feel laggy. Compute once up front, then settle
// ~180ms after the last change.
const [plan, setPlan] = useState(computePlan);
const planFirst = useRef(true);
useEffect(() => {
if (planFirst.current){ planFirst.current = false; return; }
// Paused: skip the recompute and just flag the shown plan as stale.
if (paused){ setStale(true); return; }
const id = setTimeout(() => { setPlan(computePlan()); setStale(false); }, 180);
return () => clearTimeout(id);
}, [base, metric, JSON.stringify(targets), JSON.stringify(startXp), JSON.stringify(pool), futureWeapons, lockGear, sustained, paused]);
const recomputeNow = () => { setPlan(computePlan()); setStale(false); };
const mm = metricMeta(metric);
if (!plan || !plan.ok) {
return
Planner error: {plan?.error || 'unknown'}
;
}
const noWork = plan.phases.length === 0;
const startEquipNote = (() => {
const cfg = plan.start.cfg;
const curW = base.weapon;
if (combatType !== 'magic' && cfg.weapon && cfg.weapon !== curW)
return `Equip ${cfg.weaponName} now (best in your pool at current stats).`;
return null;
})();
const SK = SP.SKILL_LABEL;
const skillColor = (s) => ({ strength:'var(--red)', attack:'var(--teal)', defence:'var(--blue)',
ranged:'var(--green)', magic:'var(--violet)' }[s] || 'var(--text-2)');
return (
{/* controls */}
Training planner{base.monster?.name || '—'} · {combatType}
Optimize forEff. XP/hr
{combatType !== 'magic' && }
set && set('sustained', v)} label="Avg over session" />
XP is defaulted to the start of each current level. If you're partway through a level, type your real XP in the xp box — the plan then charges only the XP left to your next level.
🔒 Lock freezes a skill at its current level and hides gear that needs more of it.
Only current gear plans around your equipped setup — no weapon/armour swaps.
setShowPool(v => !v)}>
{showPool ? '▾' : '▸'} Gear poolitems the planner may equip · tap to {showPool ? 'hide' : 'edit'}
{showPool && }
{/* notes */}
· ↑ unlock = a level requirement is met and a new item becomes equippable. ⇄ crossover = a weapon you could already use becomes the highest-DPS choice as a stat climbs (e.g. rune scimitar overtaking a dragon longsword once Strength is high enough that the faster speed wins).
· 🔒 Lock a skill to freeze it at its current level — it won't be recommended for training and the planner won't offer gear that needs more of it (lock Defence for a pure account; lock Defence at 45 by training it there first, then locking).
· Decisions use {mm.label} per XP, so Defence is credited for tankiness (less food → higher trip efficiency) and for the gear it unlocks (d'hide / splitbark / rune armour at 40 Def), not just raw DPS. The current-XP fields let a part-trained level cost only its remaining XP.
· Armour each level is the most defensive (or, for ranged/magic, the highest-attack) equippable item in your pool; the weapon/spell is chosen by simulating every pool candidate. Lookahead lets the planner climb Attack toward a distant weapon instead of pouring everything into Strength.
· Avg over session models potions as a decaying average (drink → peak → repot). A full running-boost timeline (max hit stepping down between sips) is a deeper change to the engine — flagged as a follow-up.