{#each rule.clauses as clause, clauseIndex} {@const conditionBand = readCurrentHealthPercentBand(clause.if)} {@const eventFieldCondition = readEventFieldComparison(clause.if)} {@const registeredPredicateField = selectedEventPredicateField(clause)} {@const registeredPredicateFields = eventPredicateFields(clause)} {@const statePoolCondition = readStatePoolThreshold(clause.if)}

{String(clauseIndex + 1).padStart(2, '0')}BRANCH LABEL updateClause(clauseIndex,{label:event.currentTarget.value,key:slug(event.currentTarget.value)})}/>

setRule({...rule,clauses:rule.clauses.filter((_,index) => index !== clauseIndex)})}>REMOVE BRANCH

DIRECT EVENT setClauseEvent(clauseIndex,value)}/>

MATCH POLICY{reducerItems.find((item) => item.id === clause.reducer.kind)?.name ?? clause.reducer.kind}

COOLDOWN · SECONDS updateClause(clauseIndex,{cooldownSeconds:event.currentTarget.value ? Number(event.currentTarget.value) : undefined})}/>

setConditionModel(clauseIndex,values[0])} /> {#if conditionBand}

FROM · HEALTH % updateHealthBand(clauseIndex,'minimum',event.currentTarget.value)}/>Inclusive; leave blank for zero. BELOW · HEALTH % updateHealthBand(clauseIndex,'maximum',event.currentTarget.value)}/>Exclusive; exact values do not match.

{:else if eventFieldCondition}

{#if registeredPredicateFields.length && registeredPredicateField} ({value:field.path,label:field.label.toUpperCase()}))} value={registeredPredicateField.path} onchange={(values) => setRegisteredEventField(clauseIndex,values[0])} /> {:else} EVENT FIELD PATH updateEventFieldComparison(clauseIndex,{path:event.currentTarget.value})}/> {/if} updateEventFieldComparison(clauseIndex,{operator:values[0] as PredicateComparisonOperator})} /> {#if !registeredPredicateField} setEventFieldScalarType(clauseIndex,values[0])} /> {/if} {#if typeof eventFieldCondition.value === 'number'} COMPARE VALUE updateEventFieldComparison(clauseIndex,{value:Number(event.currentTarget.value)})}/> {:else if typeof eventFieldCondition.value === 'boolean'} updateEventFieldComparison(clauseIndex,{value:values[0] === 'true'})} /> {:else} COMPARE VALUE updateEventFieldComparison(clauseIndex,{value:event.currentTarget.value})}/> {/if}

{:else if statePoolCondition}

STATE POOL ({id:pool.key,name:pool.label}))} mode="single" compact subjectLabel="STATE POOL" value={statePoolCondition.pool} onvaluechange={(value) => updateStatePoolThreshold(clauseIndex,{pool:value})} />

updateStatePoolThreshold(clauseIndex,{operator:values[0] as PredicateComparisonOperator})} /> THRESHOLD updateStatePoolThreshold(clauseIndex,{value:Number(event.currentTarget.value)})}/>

{:else if conditionModel(clause) === 'advanced'}

This saved condition remains active and is preserved unchanged. Use the generated mechanic preview to inspect it.

{/if} {#if allowAssignedAbility}

updateClause(clauseIndex,{requiresAssignedAbilityActive:values[0] === 'true' ? true : undefined})} /> PROC CHANCE · % updateClause(clauseIndex,{procChancePercent:event.currentTarget.value ? Number(event.currentTarget.value) : undefined})}/>Rolls after conditions and cooldown checks, before mutations.

{:else} PROC CHANCE · % updateClause(clauseIndex,{procChancePercent:event.currentTarget.value ? Number(event.currentTarget.value) : undefined})}/>Rolls after conditions and cooldown checks, before mutations. {/if}

({value:item.id,label:item.name.replace(' matches','').replace(' within a time window',' window').toUpperCase()}))} value={clause.reducer.kind} columns={4} onchange={(values) => reducerKind(clauseIndex,values[0])} /> {#if ['count','distinct_count','consecutive_count','sliding_count'].includes(clause.reducer.kind)} THRESHOLD setReducerNumber(clauseIndex,'threshold',event.currentTarget.value)}/> {/if} {#if ['distinct_count','sliding_count'].includes(clause.reducer.kind)} WINDOW · SECONDS setReducerNumber(clauseIndex,'windowSeconds',event.currentTarget.value)}/> {/if} {#if clause.reducer.kind === 'duration'} DURATION · SECONDS setReducerNumber(clauseIndex,'seconds',event.currentTarget.value)}/> {:else if clause.reducer.kind === 'periodic'} INTERVAL · SECONDS setReducerNumber(clauseIndex,'intervalSeconds',event.currentTarget.value)}/> {:else if clause.reducer.kind === 'derived_scalar'} setDerivedScalarModel(clauseIndex,values[0])} /> {#if derivedScalarModel(clause) === 'event'} ({value:field.path,label:field.label.toUpperCase()}))} value={readEventFieldNumericExpression(clause.reducer.value) ?? ''} columns={Math.min(3,numericEventFields(clause).length)} onchange={(values) => setDerivedScalarEventField(clauseIndex,values[0])} /> {:else if derivedScalarModel(clause) === 'static'} DERIVED VALUE setReducerNumber(clauseIndex,'value',event.currentTarget.value)}/> {/if} {/if}

STATE CHANGES{clause.mutations.length}

addMutation(clauseIndex)} disabled={!rule.pools.length}>ADD STATE CHANGE ＋{#if allowAssignedAbility} addAbilityDurationExtension(clauseIndex)}>EXTEND ABILITY ＋{/if} addCooldownOnMax(clauseIndex)} disabled={rule.pools.filter((pool) => pool.max && pool.max > 0).length < 2}>ADD MAX COOLDOWN ＋

{#each clause.mutations as mutation, mutationIndex} {#if mutation.kind === 'extend_duration'}

OPERATIONEXTEND ASSIGNED ABILITY

SECONDS updateAbilityDurationExtension(clauseIndex,mutationIndex,event.currentTarget.value)}/>Applies only while the assigned ability remains active. updateClause(clauseIndex,{mutations:clause.mutations.filter((_,index) => index !== mutationIndex)})}>REMOVE

{:else if mutation.kind === 'start_cooldown_on_max'}

OPERATIONSTART COOLDOWN ON MAX

pool.max && pool.max > 0).map((pool) => ({value:pool.key,label:pool.label.toUpperCase()}))} value={mutation.stackPool} onchange={(values) => updateCooldownOnMax(clauseIndex,mutationIndex,{stackPool:values[0]})}/> pool.scope === 'agent' && pool.expiresAfterSeconds && pool.key !== mutation.stackPool).map((pool) => ({value:pool.key,label:pool.label.toUpperCase()}))} value={mutation.cooldownPool} onchange={(values) => updateCooldownOnMax(clauseIndex,mutationIndex,{cooldownPool:values[0]})}/> updateClause(clauseIndex,{mutations:clause.mutations.filter((_,index) => index !== mutationIndex)})}>REMOVE

{:else}

updateMutation(clauseIndex,mutationIndex,values[0] as 'add'|'set'|'consume'|'derive'|'clear')} /> ({value:pool.key,label:pool.label.toUpperCase()}))} value={'pool' in mutation ? mutation.pool : rule.pools[0]?.key ?? ''} columns={Math.min(4,Math.max(1,rule.pools.length))} onchange={(values) => updateMutation(clauseIndex,mutationIndex,mutation.kind === 'clear' ? 'clear' : mutation.kind === 'derive' ? 'derive' : mutation.kind === 'set' || mutation.kind === 'consume' ? mutation.kind : 'add',values[0])} /> {#if mutation.kind !== 'clear' && mutation.kind !== 'derive'} VALUE updateMutation(clauseIndex,mutationIndex,mutation.kind === 'set' || mutation.kind === 'consume' ? mutation.kind : 'add',undefined,Number(event.currentTarget.value))}/> {:else if mutation.kind === 'derive'}

VALUEDERIVED SCALAR

{/if} {#if 'pool' in mutation && rule.pools.find((pool) => pool.key === mutation.pool)?.scope === 'target'} updateMutationEntity(clauseIndex,mutationIndex,values[0] as 'event_target'|'event_actor')} /> {/if} updateClause(clauseIndex,{mutations:clause.mutations.filter((_,index) => index !== mutationIndex)})}>REMOVE

{/if} {:else}

This branch emits outcomes without changing shared state.

{/each}

OUTCOMES{clause.outcomes.length}

updateClause(clauseIndex,{outcomes:[...clause.outcomes,blankOutcome(clause.outcomes.length)]})}>ADD OUTCOME ＋

{#each clause.outcomes as outcome, outcomeIndex}

LABEL updateOutcome(clauseIndex,outcomeIndex,{label:event.currentTarget.value,key:slug(event.currentTarget.value)})}/> setOutcomeKind(clauseIndex,outcomeIndex,values[0] as ConditionalMechanicOutcomeDraft['kind'])}/> DESCRIPTION SLOT updateOutcome(clauseIndex,outcomeIndex,{descriptionSlot:event.currentTarget.value ? Number(event.currentTarget.value) : undefined})}/>

4 ? 4 : scopeOptions.length} onchange={(values) => setOutcomeScope(clauseIndex,outcomeIndex,values[0] as MechanicOutcomeScope)}/> {#if outcome.scope === 'allies' || outcome.scope === 'self_and_allies' || outcome.scope === 'target'}

setOutcomeTargeting(clauseIndex,outcomeIndex,values[0] as MechanicTargetingMode)} /> {#if outcome.targeting} RADIUS (METERS) updateOutcome(clauseIndex,outcomeIndex,{targeting:{...outcome.targeting!,radiusMeters:Number(event.currentTarget.value)}})}/> {#if outcome.targeting.kind === 'event_target_area'}

EVENT TARGET CENTERDamages each valid enemy at or inside the radius once. Runtime events must supply the authoritative target sample.

{/if} {/if}

{/if} {#if outcome.kind === 'attribute_modifier'} {:else if outcome.kind === 'restoration' || outcome.kind === 'resource_cost'} updateOutcome(clauseIndex,outcomeIndex,{resource:values[0] as 'health'|'armor'|'ammo'|'signature_ability_charge'})}/> {/if} {#if outcome.kind === 'restoration'}

updateOutcome(clauseIndex,outcomeIndex,{ delivery: values[0] === 'continuous' ? 'continuous' : undefined, durationSeconds: values[0] === 'continuous' ? outcome.durationSeconds ?? 3 : undefined })} /> {#if outcome.delivery === 'continuous'} DURATION (SECONDS) updateOutcome(clauseIndex,outcomeIndex,{durationSeconds:Number(event.currentTarget.value)})}/> {/if}

{/if} {#if outcome.kind === 'direct_damage' || outcome.kind === 'restoration' || outcome.kind === 'resource_cost'} updateOutcome(clauseIndex,outcomeIndex,{basis:values[0] as OutcomeBasis})}/> {/if} setOutcomeValueModel(clauseIndex,outcomeIndex,values[0] as OutcomeValueModel,values[0] === 'event' ? 'values.enemyCount' : values[0] === 'scenario' ? rule.scenarioInputs[0]?.key ?? '' : '')} /> {#if outcomeValueModel(outcome) === 'event'} setOutcomeValueModel(clauseIndex,outcomeIndex,'event',values[0])} /> {:else if outcomeValueModel(outcome) === 'scenario' && rule.scenarioInputs.length} ({value:input.key,label:input.label.toUpperCase()}))} value={outcomeReference(outcome,'scenario')} columns={Math.min(4,rule.scenarioInputs.length)} onchange={(values) => setOutcomeValueModel(clauseIndex,outcomeIndex,'scenario',values[0])} /> {:else if outcomeValueModel(outcome) === 'attribute' || outcomeValueModel(outcome) === 'attribute_value'} setOutcomeValueModel(clauseIndex,outcomeIndex,outcomeValueModel(outcome),value)} /> {/if} {#if rule.pools.length}

({value:pool.key,label:pool.label.toUpperCase()}))]} value={outcome.statePool ?? ''} columns={Math.min(4,rule.pools.length + 1)} onchange={(values) => updateOutcome(clauseIndex,outcomeIndex,{statePool:values[0] || undefined,perStack:values[0] ? outcome.perStack ?? true : false,minStacks:values[0] ? outcome.minStacks : undefined,maxStacks:values[0] ? outcome.maxStacks : undefined})} /> {#if outcome.statePool} updateOutcome(clauseIndex,outcomeIndex,{perStack:values[0] === 'true'})}/> MIN STACK updateOutcome(clauseIndex,outcomeIndex,{minStacks:event.currentTarget.value ? Number(event.currentTarget.value) : undefined})}/> MAX STACK updateOutcome(clauseIndex,outcomeIndex,{maxStacks:event.currentTarget.value ? Number(event.currentTarget.value) : undefined})}/> {/if}

{/if}

{#each valueColumns as column} {column.label} VALUE updateVariant(clauseIndex,outcomeIndex,column.variantKey,event.currentTarget.value)}/> {/each}

OUTCOME CHANCE · % updateOutcome(clauseIndex,outcomeIndex,{probabilityPercent:event.currentTarget.value ? Number(event.currentTarget.value) : undefined})}/>Each eligible outcome rolls independently. Maximum Potential resolves each nonzero chance as successful.

updateOutcome(clauseIndex,outcomeIndex,{phase:values[0] as OutcomePhase})}/> updateClause(clauseIndex,{outcomes:clause.outcomes.filter((_,index) => index !== outcomeIndex)})}>REMOVE OUTCOME

{:else}

This branch has no outcomes yet.

{/each}

{/each} setRule({...rule,clauses:[...rule.clauses,blankClause()]})}>ADD DIRECT EVENT BRANCH ＋