Skill forge: powerful AoE skills + visual identity (element/shape/color/intensity)

Offensive forged skills are now signature-strong AREA skills: routed through the effect
path (category 'spell', adrenaline-gated), every effect scoped area_around_caster (~7
tiles), higher damage clamps (capped). Each skill carries a validated 'visual' block the
coding model fills (element/shape/hex color/intensity). Support skills stay self/ally.
Verified: melee input -> AoE fire-nova spell; self heal stays single-target.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

web/comboBattler.js

@@ -5778,6 +5778,11 @@ function playerActionReason(b, a, action) {
   if (s.cost?.adrenaline && a.adrenaline < s.cost.adrenaline) return "need-adrenaline";
   if (s.cost?.energy && a.energy < s.cost.energy) return "need-energy";
   if (b.t < (a.recharge[s.name] || 0)) return "recharging";
+  const aoe = (s.effects || []).find((e) => e.scope === "area_around_caster");
+  if (aoe) {
+    const r = aoe.range || 180;
+    return b.actors.some((x) => x.alive && x.team !== a.team && dist2(a, x) <= r) ? null : "no-target";
+  }
   if (isAttack(s)) return !foe || edgeGap(a, foe) > reachOf(a) ? "no-target" : null;
   if (!isSupport(s)) return !foe || dist2(a, foe) > SPELL_RANGE ? "no-target" : null;
   return null;

web/engine.js

@@ -1501,6 +1501,11 @@ function playerActionReason(b, a, action) {
   if (s.cost?.adrenaline && a.adrenaline < s.cost.adrenaline) return "need-adrenaline";
   if (s.cost?.energy && a.energy < s.cost.energy) return "need-energy";
   if (b.t < (a.recharge[s.name] || 0)) return "recharging";
+  const aoe = (s.effects || []).find((e) => e.scope === "area_around_caster");
+  if (aoe) {
+    const r = aoe.range || 180;
+    return b.actors.some((x) => x.alive && x.team !== a.team && dist(a, x) <= r) ? null : "no-target";
+  }
   if (isAttack(s)) return !foe || edgeGap(a, foe) > reachOf(a) ? "no-target" : null;
   if (!isSupport(s)) return !foe || dist(a, foe) > SPELL_RANGE ? "no-target" : null;
   return null;

web/skillForge.js

@@ -5,24 +5,27 @@
 // and tiny.js (character sheet).
 import { streamCoding } from '/web/codingModel.js'
 import { stripThinkFinal } from '/web/personaPrompts.js'
-import { validateSkill, SAFE_OPS, SAFE_CONDITIONS } from '/web/skillSchema.js'
+import { validateSkill, SAFE_OPS, SAFE_CONDITIONS, ELEMENTS, SHAPES } from '/web/skillSchema.js'
 import { generatePortrait } from '/web/imagen.js'
 import { getPersona, patchPersona, putSkillIcon } from '/web/personaStore.js'
 import { appendEvent } from '/web/progression.js'
 
 export const FORGE_SYSTEM = [
-  'You are the Skill Forge for a fantasy auto-battler. Author ONE combat skill for a specific',
-  'hero, tailored to their class, story and personality. Respond with a SINGLE fenced ```json',
-  'block (no prose outside it) of the form:',
+  'You are the Skill Forge for a fantasy auto-battler. Author ONE POWERFUL signature skill for a',
+  'specific hero, tailored to their class, story and personality. Respond with a SINGLE fenced',
+  '```json block (no prose outside it) of the form:',
   '{"name": string, "flavor": string (one vivid in-world sentence),',
-  '"category": "melee_attack"|"ranged_attack"|"spell"|"shout"|"stance",',
-  '"target": "foe"|"self"|"ally"|"area", "cost": int, "recharge": int seconds,',
-  '"effects": [ {"op": <op>, ...args} ] }.',
+  '"target": "foe"|"area"|"self"|"ally", "effects": [ {"op": <op>, ...args} ],',
+  '"visual": {"element": <element>, "shape": <shape>, "color": "#rrggbb", "intensity": 1-3} }.',
   `Allowed effect ops: ${SAFE_OPS.join(', ')}.`,
-  'damage/bonus_damage/heal/life_steal take {"amount": int}. apply_condition takes',
-  `{"condition": one of [${SAFE_CONDITIONS.join(', ')}], "duration": int seconds}.`,
-  'knockdown takes {"duration": int}. interrupt and lose_all_adrenaline take no args.',
-  'Use 1-3 effects. Keep it concise, flavourful and balanced. Output ONLY the json block.',
+  'damage/bonus_damage/heal/life_steal take {"amount": int (be generous — these are signature skills)}.',
+  `apply_condition takes {"condition": one of [${SAFE_CONDITIONS.join(', ')}], "duration": int}.`,
+  'knockdown takes {"duration": int}. interrupt and lose_all_adrenaline take no args. Use 1-3 effects.',
+  'MOST skills should be offensive AREA attacks (target "foe"/"area") that strike EVERY enemy nearby —',
+  'make them hit hard. Only use target "self"/"ally" for heals/buffs.',
+  `For "visual", pick an element from [${ELEMENTS.join(', ')}], a shape from [${SHAPES.join(', ')}]`,
+  '(how it manifests), a hex color, and intensity 1-3 — all chosen to match the skill\'s theme so it',
+  'looks unique. Output ONLY the json block.',
 ].join(' ')
 
 export function personaBlock(p) {

web/skillSchema.js

@@ -12,23 +12,41 @@ const NUM = (v, lo, hi, dflt) => {
   return Math.max(lo, Math.min(hi, Math.round(n)))
 }
 const CONDITIONS = ['bleeding', 'poison', 'burning', 'deepWound', 'weakness', 'crippled', 'blind', 'dazed']
-const SCOPES = ['self', 'party', 'nearby', 'area', 'target_and_adjacent', 'adjacent_to_target']
+
+// Forged skills are a hero's signature: signature-strong, and most are AREA — they hit every foe
+// within this radius of the caster (field units, ~7 tiles), routed through the engine's
+// area_around_caster scope. Damage clamps are higher than canon, but capped so they can't trivially
+// melt a Champion boss.
+const AOE_RANGE = 180
 
 const OPS = {
-  damage: (e) => ({ op: 'damage', amount: NUM(e.amount, 1, 60, 15) }),
-  bonus_damage: (e) => ({ op: 'bonus_damage', amount: NUM(e.amount, 1, 40, 12) }),
-  heal: (e) => ({ op: 'heal', amount: NUM(e.amount, 1, 60, 20) }),
-  life_steal: (e) => ({ op: 'life_steal', amount: NUM(e.amount, 1, 40, 12) }),
+  damage: (e) => ({ op: 'damage', amount: NUM(e.amount, 12, 90, 45) }),
+  bonus_damage: (e) => ({ op: 'damage', amount: NUM(e.amount, 12, 90, 40) }), // bonus_damage only works on the attack path; treat as damage for forged AoE
+  heal: (e) => ({ op: 'heal', amount: NUM(e.amount, 1, 80, 30) }),
+  life_steal: (e) => ({ op: 'life_steal', amount: NUM(e.amount, 6, 60, 24) }),
   apply_condition: (e) => CONDITIONS.includes(e.condition)
-    ? { op: 'apply_condition', condition: e.condition, duration: NUM(e.duration, 1, 25, 8), ...(SCOPES.includes(e.scope) ? { scope: e.scope } : {}) }
+    ? { op: 'apply_condition', condition: e.condition, duration: NUM(e.duration, 1, 25, 8) }
     : null,
-  knockdown: (e) => ({ op: 'knockdown', duration: NUM(e.duration, 1, 5, 2) }),
+  knockdown: (e) => ({ op: 'knockdown', duration: NUM(e.duration, 1, 4, 2) }),
   interrupt: () => ({ op: 'interrupt' }),
   lose_all_adrenaline: () => ({ op: 'lose_all_adrenaline' }),
 }
 const CATEGORIES = ['melee_attack', 'ranged_attack', 'spell', 'shout', 'stance']
 const TARGETS = ['foe', 'self', 'ally', 'area']
 
+// Visual identity (cosmetic — drives the in-combat VFX; a bad value just falls back).
+export const ELEMENTS = ['fire', 'ice', 'lightning', 'nature', 'poison', 'shadow', 'holy', 'arcane']
+export const SHAPES = ['nova', 'ring', 'beam', 'pillar', 'projectile', 'shockwave', 'slash']
+const ELEMENT_COLOR = { fire: '#ff6a2a', ice: '#6ad1ff', lightning: '#ffe14d', nature: '#5ad860', poison: '#9be24a', shadow: '#a56cff', holy: '#ffe9a8', arcane: '#c46cff' }
+function validateVisual(v) {
+  v = v && typeof v === 'object' ? v : {}
+  const element = ELEMENTS.includes(v.element) ? v.element : 'arcane'
+  const shape = SHAPES.includes(v.shape) ? v.shape : 'nova'
+  const color = /^#[0-9a-fA-F]{6}$/.test(String(v.color || '')) ? v.color : ELEMENT_COLOR[element]
+  const intensity = Math.max(1, Math.min(3, Math.round(Number(v.intensity)) || 2))
+  return { element, shape, color, intensity }
+}
+
 export const SAFE_OPS = Object.keys(OPS)
 export const SAFE_CONDITIONS = CONDITIONS.slice()
 
@@ -46,17 +64,28 @@ export function validateSkill(raw, { persona, profession } = {}) {
   if (!raw || typeof raw !== 'object') return { ok: false, skill: null, errors: ['not an object'] }
   const name = String(raw.name || '').trim().slice(0, 40)
   if (!name) errors.push('missing name')
-  const category = CATEGORIES.includes(raw.category) ? raw.category : 'melee_attack'
   const target = TARGETS.includes(raw.target) ? raw.target : 'foe'
+  const isSupport = target === 'self' || target === 'ally'
   const rawEffects = Array.isArray(raw.effects) ? raw.effects : []
-  const effects = rawEffects.map((e) => (e && OPS[e.op] ? OPS[e.op](e) : null)).filter(Boolean).slice(0, 3)
+  let effects = rawEffects.map((e) => (e && OPS[e.op] ? OPS[e.op](e) : null)).filter(Boolean).slice(0, 3)
+  // Offensive forged skills are POWERFUL AREA skills: ensure a damage effect and make every
+  // effect hit all foes in range (area_around_caster). Support skills (heal/buff) stay self/ally.
+  if (!isSupport) {
+    if (!effects.some((e) => e.op === 'damage' || e.op === 'life_steal')) effects.unshift({ op: 'damage', amount: 45 })
+    effects = effects.slice(0, 3).map((e) => ({ ...e, scope: 'area_around_caster', range: AOE_RANGE }))
+  } else {
+    if (!effects.length) effects = [{ op: 'heal', amount: 30, scope: 'self' }]
+    effects = effects.map((e) => ({ ...e, scope: e.op === 'heal' ? 'self' : (e.scope || 'self') }))
+  }
   if (!effects.length) errors.push('no valid effects')
-  // Cost: keep it cheap enough to actually fire. Casters pay energy, fighters adrenaline.
-  const isCaster = category === 'spell'
-  const cost = isCaster ? { energy: NUM(raw.cost?.energy ?? raw.cost, 1, 15, 5) }
-    : { adrenaline: NUM(raw.cost?.adrenaline ?? raw.cost, 0, 10, 4) }
-  const recharge = NUM(raw.recharge ?? raw.cooldown, 0, 30, isCaster ? 4 : 0)
+  // Routed through the engine's effect path (not single-target strike): offensive → 'spell',
+  // support → 'shout'. Both gate on adrenaline (built by basic attacks → unleash), so every class
+  // can power them. ATTACK categories (melee_attack) would single-target, so we avoid them here.
+  const category = isSupport ? 'shout' : 'spell'
+  const cost = { adrenaline: NUM(raw.cost?.adrenaline ?? raw.cost, 3, 12, 7) }
+  const recharge = NUM(raw.recharge ?? raw.cooldown, 0, 20, isSupport ? 6 : 2)
   const flavor = String(raw.flavor || raw.description || '').trim().slice(0, 200)
+  const visual = validateVisual(raw.visual)
   if (errors.length) return { ok: false, skill: null, errors }
   const skill = {
     id: nextSkillId(persona),
@@ -64,11 +93,11 @@ export function validateSkill(raw, { persona, profession } = {}) {
     profession: profession || (persona && persona.unitClass) || 'Warrior',
     attribute: 'Forged',
     category, target,
-    cost, cast: isCaster ? NUM(raw.cast, 0, 3, 1) : 0, recharge,
-    requires: category === 'melee_attack' || category === 'ranged_attack' ? ['on_hit'] : [],
+    cost, cast: 0, recharge,
+    requires: [],
     effects,
-    // ── metadata (ignored by the resolver, used by the UI) ──
-    custom: true, flavor,
+    // ── metadata (ignored by the resolver, used by the UI/VFX) ──
+    custom: true, flavor, visual, aoe: !isSupport,
   }
   return { ok: true, skill, errors: [] }
 }
@@ -88,7 +117,8 @@ export function effectSummary(skill) {
       default: return e.op
     }
   })
-  return parts.join(' · ')
+  const s = parts.join(' · ')
+  return skill.aoe ? `AoE · ${s}` : s
 }
 
 // Resolve a persona's equipped skill ids into engine-ready objects (custom objects pass