diff --git a/components/bribe-expression-promises.tsx b/components/bribe-expression-promises.tsx index b5a91ae3..0d45ab75 100644 --- a/components/bribe-expression-promises.tsx +++ b/components/bribe-expression-promises.tsx @@ -2,6 +2,7 @@ import type { Action, GameView } from '@/game/engine'; import { bribeExpressionRecipients, bribeExpressionText, liveBribeExpressionPromises } from '@/game/bribe-expression-promises'; +import { liveBribePromises } from '@/game/bribe-promises'; import { BribePromiseGuideButton } from './bribe-promises'; type BribeExpressionPromiseProps = { game: GameView; busy: boolean; send: (action: Action) => void }; @@ -37,6 +38,6 @@ export function BribeExpressionPromises(props: BribeExpressionPromiseProps) { ? 'Late payments still honor this turn’s answers; their recipients collect at next turn’s Mentat opening.' : 'Your next Mentat opening is still ahead. Accepted payments count now and their recipients collect at that opening.'} {' '}No stays binding until the actual turn ends; opening collection does not end it.

} - {!game.bribePromises.some(promise => promise.player === game.me) && } + {live && !liveBribePromises(game.bribePromises, game.me, game.turn).length && } ; } diff --git a/components/bribe-promises.tsx b/components/bribe-promises.tsx index 7b54775c..006cc4bd 100644 --- a/components/bribe-promises.tsx +++ b/components/bribe-promises.tsx @@ -25,7 +25,9 @@ export function BribePromiseGuideButton(props: BribePromiseProps) { current.bribePromiseGuide === guide && current.bribePromiseGuide.action === action && JSON.stringify(action) === signature && action.type === 'bribe' && typeof event === 'string' && (liveBribePromises(current.bribePromises, actor, turn).some(promise => promise.event === event) || - liveBribeExpressionPromises(current.bribeExpressionPromises, actor, turn).some(promise => promise.event === event)) && + liveBribeExpressionPromises(current.bribeExpressionPromises, actor, turn).some(promise => promise.event === event) || + current.mixedBribePromises.some(promise => promise.event === event && promise.player === actor && promise.turn === turn && + !promise.fulfilled && !promise.released)) && !!me && !me.autopilot && !!target && target.id !== actor && target.id !== me.ally && options.blocked === null && Number.isSafeInteger(options.available) && typeof action.amount === 'number' && action.amount <= options.available && @@ -64,6 +66,6 @@ export function BribePromises(props: BribePromiseProps) { Ordinary bribes can be paid out of turn when the current bribe controls permit them; original timing and payment rules still apply. {' '}Bribe promise rules.

- + {liveBribePromises(own, props.game.me, props.game.turn).length > 0 && } ; } diff --git a/components/game-table.tsx b/components/game-table.tsx index 405d2568..28ab5b7c 100644 --- a/components/game-table.tsx +++ b/components/game-table.tsx @@ -29,6 +29,7 @@ import { ShipmentPromises } from './shipment-promises'; import { AlliancePromises } from './alliance-promises'; import { BribePromises } from './bribe-promises'; import { BribeExpressionPromises } from './bribe-expression-promises'; +import { MixedBribePromises } from './mixed-bribe-promises'; import { RevivalPromises } from './revival-promises'; import { RevivalExpressionPromises } from './revival-expression-promises'; import { LeaderRevivalPromises } from './leader-revival-promises'; @@ -2043,6 +2044,7 @@ export function GameTable({ )} {g.status === 'playing' && } {g.status === 'playing' && } + {g.status === 'playing' && } {g.status === 'playing' && } {g.status === 'playing' && } {g.status === 'playing' && } diff --git a/components/mixed-action-fields.tsx b/components/mixed-action-fields.tsx new file mode 100644 index 00000000..abd4ae21 --- /dev/null +++ b/components/mixed-action-fields.tsx @@ -0,0 +1,180 @@ +'use client'; + +import type { ReactElement, ReactNode } from 'react'; +import type { GameView } from '@/game/engine'; +import { parseMixedActionExpression, type MixedActionExpression } from '@/game/mixed-action-question'; +import type { TruthFact } from '@/game/truthtrance'; +import { truthFactExpressionError } from '@/game/truth-fact-expression'; +import { TruthFactFields, invalidTruthFact } from './mixed-shipment-fields'; +import { Button } from './ui/button'; + +export type MixedActionConfig = { + prefix: string; + legend: string; + actionLabel: string; + actionTiming: string; + actionHelp: ReactNode; + fallbackError: string; + maxLeaves: number; + maxDepth: number; + newAction: () => A; + parseAction: (value: unknown, game: GameView, target: string) => A; + renderAction: (props: { value: A; id: string; game: GameView; target: string; + disabled: boolean; onChange: (action: A) => void }) => ReactNode; +}; + +const newFact = (): MixedActionExpression => ({ kind: 'fact', fact: { kind: 'hand', name: 'Shield' } }); +const newFactLeaf = (): TruthFact => ({ kind: 'hand', name: 'Shield' }); +function factSize(fact: TruthFact): { leaves: number; depth: number } { + if (fact.kind !== 'and' && fact.kind !== 'or') return { leaves: 1, depth: 0 }; + const sizes = fact.terms.map(factSize); + return { leaves: sizes.reduce((sum, child) => sum + child.leaves, 0), depth: 1 + Math.max(0, ...sizes.map(child => child.depth)) }; +} +function sizeOf(node: MixedActionExpression): { leaves: number; depth: number } { + if (node.kind === 'fact') return factSize(node.fact); + if (node.kind === 'action') return { leaves: 1, depth: 0 }; + const sizes = node.terms.map(sizeOf); + return { leaves: sizes.reduce((sum, child) => sum + child.leaves, 0), depth: 1 + Math.max(0, ...sizes.map(child => child.depth)) }; +} +function structuralError(node: MixedActionExpression, config: MixedActionConfig): string | null { + const size = sizeOf(node); + if (size.leaves > config.maxLeaves || size.depth > config.maxDepth) + return 'Use at most sixteen conditions and four levels of grouping.'; + if (node.kind === 'fact') return truthFactExpressionError(node.fact); + if (node.kind === 'action') return null; + if (node.terms.length < 2) return 'Join two or more conditions with AND or OR.'; + for (const term of node.terms) { + const error = structuralError(term, config); + if (error) return error; + } + return null; +} + +/** Current-fact eligibility and each action family's parser share one envelope. */ +export function mixedActionInputError(value: unknown, game: GameView, target: string, + config: MixedActionConfig): string | null { + try { + parseMixedActionExpression(value, input => { + const fact = input as TruthFact; + const error = truthFactExpressionError(fact); + if (error) throw new Error(error); + if (invalidTruthFact(fact, game, target)) throw new Error('Resolve the marked current-fact fields.'); + return fact; + }, input => config.parseAction(input, game, target), { maxDepth: config.maxDepth, maxLeaves: config.maxLeaves }); + return null; + } catch (error) { + return error instanceof Error ? error.message : config.fallbackError; + } +} + +/** Preserve the complete original tree, including incomplete numeric drafts. + * Structural changes never evaluate current facts or select a future branch. */ +export function MixedActionFields({ value, game, target, disabled, onChange, config }: { + value: MixedActionExpression; + game: GameView; + target: string; + disabled: boolean; + onChange: (expression: MixedActionExpression) => void; + config: MixedActionConfig; +}) { + const newAction = (): MixedActionExpression => ({ kind: 'action', action: config.newAction() }); + const attrs = (suffix: string, value: string) => ({ [`data-${config.prefix}-${suffix}`]: value }); + const size = sizeOf(value), error = mixedActionInputError(value, game, target, config); + const commit = (next: MixedActionExpression) => { + if (!disabled && !structuralError(next, config)) onChange(next); + }; + const renderFact = (fact: TruthFact, path: string, replace: (next: TruthFact) => MixedActionExpression, + remove?: () => MixedActionExpression): ReactElement => { + const allowed = (next: TruthFact) => !disabled && !structuralError(replace(next), config); + const change = (next: TruthFact) => commit(replace(next)); + const wrap = (kind: 'and' | 'or'): TruthFact => ({ kind, terms: [fact, newFactLeaf()] }); + return
+ {fact.kind === 'and' || fact.kind === 'or' ? `Current-fact group ${path}` : `Current fact ${path}`} + {fact.kind === 'and' || fact.kind === 'or' ? <> + + + {fact.terms.map((term, index) => renderFact(term, `${path}.${index + 1}`, + next => replace({ ...fact, terms: fact.terms.map((old, i) => i === index ? next : old) }), + () => { + const terms = fact.terms.filter((_, i) => i !== index); + return replace(terms.length === 1 ? terms[0] : { ...fact, terms }); + }))} + + : } +
+ {(['and', 'or'] as const).map(kind => )} + {remove && } +
+
; + }; + const render = (node: MixedActionExpression, path: string, replace: (next: MixedActionExpression) => MixedActionExpression, + remove?: () => MixedActionExpression): ReactElement => { + const id = `truth-${config.prefix}-${path}`; + const allowed = (next: MixedActionExpression) => !disabled && !structuralError(replace(next), config); + const change = (next: MixedActionExpression) => commit(replace(next)); + const wrap = (kind: 'and' | 'or'): MixedActionExpression => ({ kind, terms: [node, node.kind === 'fact' ? newAction() : newFact()] }); + return
+ {node.kind === 'and' || node.kind === 'or' ? `Mixed group ${path} · ${node.kind.toUpperCase()}` : `Mixed condition ${path}`} + {node.kind === 'and' || node.kind === 'or' ? <> + + + {node.terms.map((term, index) => render(term, `${path}.${index + 1}`, + next => replace({ ...node, terms: node.terms.map((old, i) => i === index ? next : old) }), + () => { + const terms = node.terms.filter((_, i) => i !== index); + return replace(terms.length === 1 ? terms[0] : { ...node, terms }); + }))} + + : <> + + + {node.kind === 'fact' ? renderFact(node.fact, path, fact => replace({ kind: 'fact', fact })) : node.kind === 'action' ? config.renderAction({ value: node.action, id, game, target, disabled, + onChange: action => change({ ...node, action }) }) : null} + } +
+ {(['and', 'or'] as const).map(kind => )} + {remove && } +
+
; + }; + return
+ {config.legend} +

Current facts are evaluated when the player answers. They create no promise to keep cards, spice or forces afterward. + AND requires every condition; OR requires at least one. No makes the whole grouped claim false, not necessarily every condition. + Only the aggregate answer is shared; an unknown current fact can still allow a definite whole answer.

+

{config.actionHelp}

+

App input limits: {config.maxLeaves} conditions and {config.maxDepth} levels of grouping. + These are input limits, not additional printed rules.

+

{size.leaves} / {config.maxLeaves} conditions · {size.depth} / {config.maxDepth} levels of grouping

+ {error &&

{error}

} + {render(value, '1', next => next)} +
; +} diff --git a/components/mixed-bribe-fields.tsx b/components/mixed-bribe-fields.tsx new file mode 100644 index 00000000..b9171265 --- /dev/null +++ b/components/mixed-bribe-fields.tsx @@ -0,0 +1,64 @@ +'use client'; + +import type { GameView } from '@/game/engine'; +import type { MixedActionExpression } from '@/game/mixed-action-question'; +import { BRIBE_EXPRESSION_MAX_DEPTH, BRIBE_EXPRESSION_MAX_LEAVES } from '@/game/bribe-expression-promises'; +import { parseBribePaymentClaim, type BribePaymentClaim } from '@/game/mixed-bribe-question'; +import { MixedActionFields, mixedActionInputError, type MixedActionConfig } from './mixed-action-fields'; +import { Input } from './ui/input'; + +const recipients = (game: GameView, target: string) => { + const player = game.players.find(player => player.id === target); + return player ? game.players.filter(recipient => recipient.id !== target && recipient.id !== player.ally) : []; +}; +const config: MixedActionConfig = { + prefix: 'mixed-bribe', + legend: 'Mixed current-fact / future ordinary bribe claim', + actionLabel: 'ordinary bribe condition', + actionTiming: 'Future ordinary bribes · this turn', + actionHelp: <>Count cumulative future ordinary bribe payments after the answer this turn; smaller payments to the same recipient add together. + Prior payments, gifts and ally aid do not count. The sender pays immediately; the recipient collects at the next Mentat opening. + Payments made during Mentat Pause wait until the start of next turn's Mentat Pause. Original payment and timing rules still apply., + fallbackError: 'Choose a current fact and a future ordinary bribe condition.', + maxLeaves: BRIBE_EXPRESSION_MAX_LEAVES, + maxDepth: BRIBE_EXPRESSION_MAX_DEPTH, + newAction: () => ({ recipient: '', minimum: 1 }), + parseAction: (value, game, target) => { + const action = parseBribePaymentClaim(value); + if (!recipients(game, target).some(recipient => recipient.id === action.recipient)) + throw new Error('Choose a public non-allied recipient for the future ordinary bribe.'); + return action; + }, + renderAction: ({ value, id, game, target, disabled, onChange }) => { + const choices = recipients(game, target), validRecipient = choices.some(recipient => recipient.id === value.recipient); + return <> + + + + onChange({ ...value, minimum: event.currentTarget.valueAsNumber })} /> + ; + }, +}; + +export function mixedBribeInputError(value: unknown, game: GameView, target: string): string | null { + return mixedActionInputError(value, game, target, config); +} +export function MixedBribeFields(props: { + value: MixedActionExpression; + game: GameView; + target: string; + disabled: boolean; + onChange: (expression: MixedActionExpression) => void; +}) { + return MixedActionFields({ ...props, config }); +} diff --git a/components/mixed-bribe-promises.tsx b/components/mixed-bribe-promises.tsx new file mode 100644 index 00000000..b729a9a7 --- /dev/null +++ b/components/mixed-bribe-promises.tsx @@ -0,0 +1,60 @@ +'use client'; + +import type { Action, GameView } from '@/game/engine'; +import type { MixedActionExpression } from '@/game/mixed-action-question'; +import type { BribePaymentClaim } from '@/game/mixed-bribe-question'; +import { liveBribePromises } from '@/game/bribe-promises'; +import { liveBribeExpressionPromises } from '@/game/bribe-expression-promises'; +import { truthQuestionText } from '@/game/truthtrance'; +import { CHEAP_HERO_TRAITOR } from '@/game/traitors'; +import { BribePromiseGuideButton } from './bribe-promises'; + +function recipients(mixed: MixedActionExpression): string[] { + const found = new Set(); + const visit = (node: MixedActionExpression): void => { + if (node.kind === 'action') found.add(node.action.recipient); + else if (node.kind === 'and' || node.kind === 'or') node.terms.forEach(visit); + }; + visit(mixed); + return [...found]; +} + +/** Only the original question, aggregate answer and cumulative payments are + * public. Never evaluate facts or inspect the private compiled commitment. */ +export function MixedBribePromises(props: { game: GameView; busy: boolean; send: (action: Action) => void }) { + const game = props.game, own = game.mixedBribePromises.filter(promise => promise.player === game.me); + if (!own.length) return null; + const name = (id: string) => game.players.find(player => player.id === id)?.name ?? 'the named recipient'; + const live = own.some(promise => promise.turn === game.turn && !promise.fulfilled && !promise.released); + const sharedGuideElsewhere = liveBribePromises(game.bribePromises, game.me, game.turn).length > 0 || + liveBribeExpressionPromises(game.bribeExpressionPromises, game.me, game.turn).length > 0; + return
+

Your mixed bribe promises

+
    {own.map(promise =>
  • + Turn {promise.turn}: You answered {promise.answer ? 'Yes' : 'No'} to {truthQuestionText({ kind: 'mixedBribe', target: promise.player, + turn: promise.turn, mixed: promise.mixed }, id => id === CHEAP_HERO_TRAITOR ? 'Cheap Hero / Heroine' + : game.allLeaders.find(leader => leader.id === id)?.name ?? id, + id => game.combatLocations.find(location => location.id === id)?.name ?? id, name)} + {' '}Recorded future ordinary payments: {recipients(promise.mixed).map(recipient => + `${name(recipient)}: ${promise.progress.find(progress => progress.recipient === recipient)?.amount ?? 0} spice`).join('; ')}. + {promise.released ? ' Released: this whole commitment is no longer possible.' + : promise.fulfilled ? ' Fulfilled: this whole commitment is complete.' : ' This whole answer is binding for this turn.'} +
    • )}
+

Current facts are evaluated at the answer. They create no promise to keep cards, spice or forces afterward. + Only the aggregate answer is shared. Individual fact answers and any reduced future branch remain private. + AND requires every condition; OR requires at least one. No negates the whole expression, not each condition separately. + Legal alternatives remain available; no fixed branch is selected for you.

+

Smaller payments to the same recipient add together after the answer. Prior payments, gifts and ally aid do not count. + Preserve the spendable spice needed for your Yes answers. + The sender pays immediately. The recipient collects the payment at the next Mentat opening. + Payments made during Mentat Pause wait until the start of next turn's Mentat Pause. + Collection does not count the payment a second time. + Ordinary bribes can be paid out of turn when the current bribe controls permit them; original timing and payment rules still apply. + {' '}Mixed bribe rules.

+ {live &&

{game.phase === 8 + ? 'Late payments still honor this turn’s answers; their recipients collect at next turn’s Mentat opening.' + : 'Your next Mentat opening is still ahead. Accepted payments count now and their recipients collect at that opening.'} + {' '}No stays binding until the actual turn ends; opening collection does not end it.

} + {live && !sharedGuideElsewhere && } +
; +} diff --git a/components/mixed-movement-fields.tsx b/components/mixed-movement-fields.tsx index e39ad057..65b2788f 100644 --- a/components/mixed-movement-fields.tsx +++ b/components/mixed-movement-fields.tsx @@ -1,181 +1,52 @@ 'use client'; -import type { ReactElement } from 'react'; import type { GameView } from '@/game/engine'; import { TERRITORIES } from '@/game/board'; -import { parseMixedActionExpression, type MixedActionExpression } from '@/game/mixed-action-question'; +import type { MixedActionExpression } from '@/game/mixed-action-question'; import { MOVEMENT_EXPRESSION_MAX_DEPTH, MOVEMENT_EXPRESSION_MAX_LEAVES } from '@/game/movement-expression-promises'; import { parseMovementClaim, type MovementClaim } from '@/game/movement-promises'; -import type { TruthFact } from '@/game/truthtrance'; -import { truthFactExpressionError } from '@/game/truth-fact-expression'; -import { TruthFactFields, invalidTruthFact } from './mixed-shipment-fields'; -import { Button } from './ui/button'; +import { MixedActionFields, mixedActionInputError, type MixedActionConfig } from './mixed-action-fields'; import { Input } from './ui/input'; type MixedMovementExpression = MixedActionExpression; -const newFact = (): MixedMovementExpression => ({ kind: 'fact', fact: { kind: 'hand', name: 'Shield' } }); -const newMove = (): MixedMovementExpression => ({ kind: 'action', action: { territory: 'carthag', minimum: 1 } }); -const newFactLeaf = (): TruthFact => ({ kind: 'hand', name: 'Shield' }); -function factSize(fact: TruthFact): { leaves: number; depth: number } { - if (fact.kind !== 'and' && fact.kind !== 'or') return { leaves: 1, depth: 0 }; - const sizes = fact.terms.map(factSize); - return { leaves: sizes.reduce((sum, child) => sum + child.leaves, 0), depth: 1 + Math.max(0, ...sizes.map(child => child.depth)) }; -} -function sizeOf(node: MixedMovementExpression): { leaves: number; depth: number } { - if (node.kind === 'fact') return factSize(node.fact); - if (node.kind === 'action') return { leaves: 1, depth: 0 }; - const sizes = node.terms.map(sizeOf); - return { leaves: sizes.reduce((sum, child) => sum + child.leaves, 0), depth: 1 + Math.max(0, ...sizes.map(child => child.depth)) }; -} -function structuralError(node: MixedMovementExpression): string | null { - const size = sizeOf(node); - if (size.leaves > MOVEMENT_EXPRESSION_MAX_LEAVES || size.depth > MOVEMENT_EXPRESSION_MAX_DEPTH) - return 'Use at most sixteen conditions and four levels of grouping.'; - if (node.kind === 'fact') return truthFactExpressionError(node.fact); - if (node.kind === 'action') return null; - if (node.terms.length < 2) return 'Join two or more conditions with AND or OR.'; - for (const term of node.terms) { - const error = structuralError(term); - if (error) return error; - } - return null; -} +const config: MixedActionConfig = { + prefix: 'mixed-movement', + legend: 'Mixed current-fact / future ground-movement claim', + actionLabel: 'ground-movement condition', + actionTiming: 'Future ground move · this turn', + actionHelp: <>Each movement condition needs one actual future ground move after the answer, before your Movement turn ends this round. + Smaller moves never add together. Prior moves and shipments do not count. The claim grants no extra movement opportunity., + fallbackError: 'Choose a current fact and a future ground-movement condition.', + maxLeaves: MOVEMENT_EXPRESSION_MAX_LEAVES, + maxDepth: MOVEMENT_EXPRESSION_MAX_DEPTH, + newAction: () => ({ territory: 'carthag', minimum: 1 }), + parseAction: parseMovementClaim, + renderAction: ({ value, id, disabled, onChange }) => <> + + + + 20} + onChange={event => onChange({ ...value, minimum: event.currentTarget.valueAsNumber })} /> + , +}; -/** Draft feedback reuses the existing fact fields. The server remains the - * authority for current-fact eligibility and legal future movement routes. */ +/** Keep the movement API and rendered control identifiers stable. */ export function mixedMovementInputError(value: unknown, game: GameView, target: string): string | null { - try { - parseMixedActionExpression(value, input => { - const fact = input as TruthFact; - const error = truthFactExpressionError(fact); - if (error) throw new Error(error); - if (invalidTruthFact(fact, game, target)) throw new Error('Resolve the marked current-fact fields.'); - return fact; - }, parseMovementClaim); - return null; - } catch (error) { - return error instanceof Error ? error.message : 'Choose a current fact and a future ground-movement condition.'; - } + return mixedActionInputError(value, game, target, config); } - -/** Preserve the complete original tree, including incomplete numeric drafts. - * Structural changes never evaluate current facts or select a future branch. */ -export function MixedMovementFields({ value, game, target, disabled, onChange }: { +export function MixedMovementFields(props: { value: MixedMovementExpression; game: GameView; target: string; disabled: boolean; onChange: (expression: MixedMovementExpression) => void; }) { - const size = sizeOf(value), error = mixedMovementInputError(value, game, target); - const commit = (next: MixedMovementExpression) => { - if (!disabled && !structuralError(next)) onChange(next); - }; - const renderFact = (fact: TruthFact, path: string, replace: (next: TruthFact) => MixedMovementExpression, - remove?: () => MixedMovementExpression): ReactElement => { - const allowed = (next: TruthFact) => !disabled && !structuralError(replace(next)); - const change = (next: TruthFact) => commit(replace(next)); - const wrap = (kind: 'and' | 'or'): TruthFact => ({ kind, terms: [fact, newFactLeaf()] }); - return
- {fact.kind === 'and' || fact.kind === 'or' ? `Current-fact group ${path}` : `Current fact ${path}`} - {fact.kind === 'and' || fact.kind === 'or' ? <> - - - {fact.terms.map((term, index) => renderFact(term, `${path}.${index + 1}`, - next => replace({ ...fact, terms: fact.terms.map((old, i) => i === index ? next : old) }), - () => { - const terms = fact.terms.filter((_, i) => i !== index); - return replace(terms.length === 1 ? terms[0] : { ...fact, terms }); - }))} - - : } -
- {(['and', 'or'] as const).map(kind => )} - {remove && } -
-
; - }; - const render = (node: MixedMovementExpression, path: string, replace: (next: MixedMovementExpression) => MixedMovementExpression, - remove?: () => MixedMovementExpression): ReactElement => { - const id = `truth-mixed-movement-${path}`; - const allowed = (next: MixedMovementExpression) => !disabled && !structuralError(replace(next)); - const change = (next: MixedMovementExpression) => commit(replace(next)); - const wrap = (kind: 'and' | 'or'): MixedMovementExpression => ({ kind, terms: [node, node.kind === 'fact' ? newMove() : newFact()] }); - return
- {node.kind === 'and' || node.kind === 'or' ? `Mixed group ${path} · ${node.kind.toUpperCase()}` : `Mixed condition ${path}`} - {node.kind === 'and' || node.kind === 'or' ? <> - - - {node.terms.map((term, index) => render(term, `${path}.${index + 1}`, - next => replace({ ...node, terms: node.terms.map((old, i) => i === index ? next : old) }), - () => { - const terms = node.terms.filter((_, i) => i !== index); - return replace(terms.length === 1 ? terms[0] : { ...node, terms }); - }))} -
- - - {(['and', 'or'] as const).map(kind => { - const next: MixedMovementExpression = { ...node, terms: [...node.terms, { kind, terms: [newFact(), newMove()] }] }; - return ; - })} -
- : <> - - - {node.kind === 'fact' ? renderFact(node.fact, path, fact => replace({ kind: 'fact', fact })) : node.kind === 'action' ? <> - - - - 20} - onChange={event => change({ ...node, action: { ...node.action, minimum: event.currentTarget.valueAsNumber } })} /> - : null} - } -
- {(['and', 'or'] as const).map(kind => )} - {remove && } -
-
; - }; - return
- Mixed current-fact / future ground-movement claim -

Current facts are evaluated when the player answers. They create no promise to keep cards, spice or forces afterward. - AND requires every condition; OR requires at least one. No makes the whole grouped claim false, not necessarily every condition. - Only the aggregate answer is shared; an unknown current fact can still allow a definite whole answer.

-

Each movement condition needs one actual future ground move after the answer, before your Movement turn ends this round. - Smaller moves never add together. Prior moves and shipments do not count. The claim grants no extra movement opportunity.

-

App input limits: {MOVEMENT_EXPRESSION_MAX_LEAVES} conditions and {MOVEMENT_EXPRESSION_MAX_DEPTH} levels of grouping. - These are input limits, not additional printed rules.

-

{size.leaves} / {MOVEMENT_EXPRESSION_MAX_LEAVES} conditions · {size.depth} / {MOVEMENT_EXPRESSION_MAX_DEPTH} levels of grouping

- {error &&

{error}

} - {render(value, '1', next => next)} -
; + return MixedActionFields({ ...props, config }); } diff --git a/components/truthtrance.tsx b/components/truthtrance.tsx index 142c63f9..4c5486b0 100644 --- a/components/truthtrance.tsx +++ b/components/truthtrance.tsx @@ -1,5 +1,7 @@ 'use client'; +import { MixedBribeFields, mixedBribeInputError } from './mixed-bribe-fields'; +import type { BribePaymentClaim } from '@/game/mixed-bribe-question'; import { MixedMovementFields, mixedMovementInputError } from './mixed-movement-fields'; import type { MixedActionExpression } from '@/game/mixed-action-question'; import { MovementExpressionFields, movementExpressionInputError } from './movement-expression-fields'; @@ -73,7 +75,7 @@ export function Truthtrance({ g.players.find((p) => p.id !== me.id)!.id, ); const [kind, setKind] = useState< - 'fact' | 'freeform' | 'battlePlan' | 'shipment' | 'mixedShipment' | 'movement' | 'traitorCall' | 'bid' | 'revival' | 'bribe' | 'alliance' | 'leaderRevival' | 'revivalExpression' | 'bribeExpression' | 'movementExpression' | 'mixedMovement' + 'fact' | 'freeform' | 'battlePlan' | 'shipment' | 'mixedShipment' | 'movement' | 'traitorCall' | 'bid' | 'revival' | 'bribe' | 'alliance' | 'leaderRevival' | 'revivalExpression' | 'bribeExpression' | 'movementExpression' | 'mixedMovement' | 'mixedBribe' >('fact'); const [revivalLeader, setRevivalLeader] = useState(g.allLeaders.find(leader => leader.faction === g.players.find(player => player.id === target)?.faction)?.id ?? ''); @@ -116,6 +118,11 @@ export function Truthtrance({ { kind: 'action', action: { territory: 'carthag', minimum: 1 } }, ] }); const mixedMovementError = mixedMovementInputError(mixedMovement, g, target); + const [mixedBribe, setMixedBribe] = useState>({ kind: 'and', terms: [ + { kind: 'fact', fact: { kind: 'spice', compare: 'gte', value: 10 } }, + { kind: 'action', action: { recipient: g.me, minimum: 3 } }, + ] }); + const mixedBribeError = mixedBribeInputError(mixedBribe, g, target); const [shipment, setShipment] = useState({ territory: 'carthag', minimum: 6 }); const [mixed, setMixed] = useState({ kind: 'and', @@ -158,6 +165,7 @@ export function Truthtrance({ : kind === 'revivalExpression' ? { kind, target, turn: g.turn, claim: revivalExpression } : kind === 'leaderRevival' ? { kind, target, ...leaderRevivalClaim } : kind === 'alliance' ? { kind, target, ...allianceClaim } + : kind === 'mixedBribe' ? { kind, target, turn: g.turn, mixed: mixedBribe } : kind === 'bribeExpression' ? { kind, target, turn: g.turn, claim: bribeExpression } : kind === 'bribe' ? { kind, target, ...bribeClaim } : kind === 'revival' ? { kind, target, ...revivalClaim } @@ -290,6 +298,13 @@ export function Truthtrance({ {button(answer === 'unknown' ? 'I don’t know yet' : `Answer ${answer === 'yes' ? 'Yes' : 'No'}`, { type: 'truthAnswer', answer })} )} + ) : w.question!.kind === 'mixedBribe' ? ( + <> +

This answers the whole current-fact and future-payment question. Facts freeze at this answer; later spending does not rewrite them. Unknown facts require a guaranteed whole answer. Only actual future ordinary payer payments count; receipts remain deferred until their next Mentat opening. Individual fact answers and reduced obligations are not published.

+ {(g.truthMixedBribeAnswers ?? []).map(answer =>
+ {button(answer === 'unknown' ? 'I don’t know yet' : `Answer ${answer === 'yes' ? 'Yes' : 'No'}`, { type: 'truthAnswer', answer })} +
)} + ) : w.question!.kind === 'bribeExpression' ? ( <>

Yes requires the whole AND/OR question to become true through your future ordinary payments. No keeps the whole expression false, and may permit some payments. Earlier payments and later recipient collection do not count. Keep the funds needed by every answer; late Mentat receipts wait for next turn's opening.

@@ -454,6 +469,7 @@ export function Truthtrance({ + @@ -498,6 +514,14 @@ export function Truthtrance({ {!g.truthAllianceTargets.includes(target) &&

Choose a supported participant in a quiet open ordinary Nexus. Optional modules and broader alliance questions remain unfinished.

}

{truthQuestionText(question, leaderName, locationName, name)}

+ ) : kind === 'mixedBribe' ? ( + <> + +

Current facts freeze when answered. Later ordinary payer payments add together until this turn ends. No negates the whole mixed question. Current funds and earlier promises stay available; late Mentat receipts wait until next turn's opening.

+ {!g.truthMixedBribeTargets.includes(target) &&

Choose a supported quiet native window and finish pending decisions. Optional modules remain unfinished.

} +

{mixedBribeError ?? truthQuestionText(question, leaderName, locationName, name)}

+ ) : kind === 'bribeExpression' ? ( <> `; a payment leaf contains only +`{recipient,minimum}`. Quiet native Basic/Advanced phases0–8 retain the existing +[ordinary payment](TRUTHTRANCE_BRIBE_EXPRESSIONS.md) scope and all mode gates. + +## Authority and snapshot meaning + +Reuse the [mixed-movement composition](TRUTHTRANCE_MIXED_MOVEMENT.md), recorded +[publisher November2020 FAQp8](https://www.gf9games.com/dune/wp-content/uploads/2020/11/Dune-FAQ-Nov-2020.pdf) +current-turn/AND/OR authority and supplied Advanced physical39/printed37 public +answer/compliance/release/unknown text. Existing [Mentat timing](MENTAT_BRIBES.md) +and cumulative native payer accounting remain. No source supplies a complete +online solver; current-funded witnesses, snapshot/unknown and accepted-order +release remain provisional under standing14October priority. + +Facts freeze at the actual answer. A current-spice fact at10 stays that +answer-time fact after promised payments reduce the same purse to5. Later +spending/card changes create no new fact answer. No negates the entire mixed +expression. Unknown takes false for a definite Yes and true for No, then the +remaining owned payment completion must guarantee the aggregate. Correlations +between unknown predicates are not inferred. When neither definite completion +is known, unknown/save/change-question remains available. + +A true held Shield OR payment can settle Yes immediately; false held Hajr AND +payment can settle No immediately. Otherwise the action-only residual uses the +existing cumulative native payment ledger. Smaller payments after the answer +add together per named recipient. Prior payments, gifts, allied aid and later +recipient collection do not count. Different questions keep their own future +intervals; repeated recipient thresholds share actual payer progress. + +## Shared implementation and controls + +`game/mixed-bribe-question.ts` rejects leaf metadata/extra keys and reuses scalar +recipient/minimum decoding. The generic mixed parser validates every subtree +and shares one16-leaf/depth4 budget with nested current facts. A positive safe +whole minimum has no artificial extra cap. Server context validates every +recipient as another current nonally, including below decisive fact branches. +Public frozen constants or compiled fields are not accepted. + +The existing compiler eagerly reads all current facts before folding known +constants/identity children/singletons. A remaining payment tree binds the +original bribe-expression ledger and accepted order; raw `mixedBribeQuestions` +metadata links the original question to that event. A constant aggregate has no +native payment binding. There is no second payment/debit/receipt implementation. +Native quotes preserve earlier scalar, grouped, revival, bid, shipment, +movement and battle budgets using the same current uncommitted purse. + +Own raw question, aggregate status and recorded payer totals are projected. +Compiled residuals are excluded from the public pure-expression ledger; raw +internal metadata and frozen per-fact values remain unprojected. The common +exact event/phase payment guide can belong to scalar, grouped or mixed answers. +Uniform existing Yes readiness reopening applies even to decisive constants, +so no immediate compiled-branch readiness flag is added. Required aggregate +release and public actual payments retain their original information. + +`components/mixed-action-fields.tsx` shares full add/wrap/nest/switch/remove/ +collapse editing and current-fact controls. Movement retains its public API, +IDs/data attributes and callback traversal through a thin adapter. Bribe fields +supply public recipient choices and uniquely identified per-leaf numeric inputs; +invalid numeric/empty-recipient drafts remain repairable. Preview/Ask keep the +complete original tree. Scalar/grouped/mixed panels choose exactly one guide +using live ownership rather than fulfilled historical rows. Four minimal +policies answer and pay legally; strategy/calibration remain deferred. + +Payer spice is spent now. Recipient shares remain deferred until the next actual +Mentat opening; late Mentat payments wait for next turn's opening. Existing ally, +pending-choice, Inflation Double and Bureaucrat guards remain. Yes cannot evade +Mentat Ready; No remains binding through collection until actual turn advance. +A known automatic Double closure retains the earlier Collection deadline. +New mixed discard signatures bind metadata/residual without altering older +record signatures. No historical answer is reactivated or database rewritten. + +## Evidence and remaining gates + +Source cases: `tests/fixture-truth-mixed-bribe.ts`, +`tests/truth-mixed-bribe-runtime.test.ts`, +`tests/truth-mixed-bribe-funding.test.ts`. +Controlled shared editing/guide cases: `tests/truth-mixed-bribe-controls.test.tsx`; +existing mixed-movement controls retain their scope. Nineteen native,two native +funding and nine controlled cases supplement existing generic/scalar/grouped/ +movement coverage in the frozen **21-file,216/216** union. Types/lint, production +build and ten native paths pass on the same unchanged source. Actual GameTable +SSR renders33 times;13 guide callbacks submit native packets. Two editor +meaning callbacks (payment and retained movement adapter) preserve their whole +raw questions through native Ask. Four minimal profiles actually answer and pay +on both Basic/Advanced original sources. + +| Original source | Prefix actions | Further actions | Actual result | +| --- | ---: | ---: | --- | +| Basic frozen spice | 20 | 22 | H3/A2 reduces E10→5; both exact opening receipts | +| Advanced frozen spice | 23 | 22 | Same answer-time snapshot/native payment/receipt | +| Basic edited true OR | 20 | 20 | Real AND→OR editor/Ask; immediate Yes, no payment binding | +| Basic false AND | 20 | 21 | Immediate No permits an actual ordinary payment | +| Basic unknown OR Yes | 20 | 21 | Unknown forecast requires actual payment | +| Basic unknown AND No | 20 | 21 | Cumulative payments remain below the qualifying minimum | +| Basic late-ready mixed | 32 | 37 | Only payer reopens; receipts wait for next real opening | +| Basic shared leader, bribe first | 102 | 16 | H1/A1 then native leader2 at T0; both obligations fulfilled | +| Basic shared leader, revival first | 102 | 16 | Same real purse in opposite accepted order | +| Basic shared movement editor | 20 | 5 | Retained movement IDs/callbacks edit/Ask the same raw tree | + +The first frozen batch passes after updating one old assertion to live scalar +ownership. The passing source snapshot is +`ae77b288d097191c4b1f1ecdea123d564184532a9e06b7555f4b2e3fe79a9d0d` +(3162 files). Final evidence prose is a separate three-document overlay. +Frozen proof/report/manifest: +`/home/quintine/.local/share/dune/checkpoints/20261026-truth-mixed-bribe-proof-v1/`; +journeys/HTML: adjacent `20261026-truth-mixed-bribe-runtime/`. +SSR/editor/guide callbacks are local engine/control evidence, not DOM, +hydration, browser/mobile or deployed acceptance. + +Original H/A/E base33 Basic20/Advanced23 and late Mentat32/35 sources supply +E10, its printed Shield and both original H Truths. H/A/T Ix47 sources supply +actual T4/dead native leader2 for shared-funding orders. No played clock, +purse, hand, payment, fact answer, promise or progress is installed. Controlled +views keep those labels rather than claiming original acquisition histories. + +Other action families, correlated unknowns, future owned income/preparations, +optional modules, broader faction/card/funding composition and final rules/ +recovery/privacy/custody/browser/mobile/deployed acceptance remain required. +No complete mode is certified. No saved-game/database/server/reset/restart/ +deployment operation is performed by this batch. diff --git a/docs/TRUTHTRANCE_MIXED_MOVEMENT.md b/docs/TRUTHTRANCE_MIXED_MOVEMENT.md index db133820..4d65f228 100644 --- a/docs/TRUTHTRANCE_MIXED_MOVEMENT.md +++ b/docs/TRUTHTRANCE_MIXED_MOVEMENT.md @@ -1,5 +1,9 @@ # Truthtrance current facts and future ground movement +The [mixed ordinary-payment follow-up](TRUTHTRANCE_MIXED_BRIBES.md) reuses +this compiler and extracts the editor into `components/mixed-action-fields.tsx`. +The movement wrapper retains its public API, IDs, callbacks and native behavior. + ## Mixed aggregate prototype — 26 October 2026 **Prototyped / Partial.** The packet is diff --git a/game/bots.ts b/game/bots.ts index 560741c6..c534246d 100644 --- a/game/bots.ts +++ b/game/bots.ts @@ -1332,6 +1332,10 @@ function policyActions(g: GameView): Action[] { const answer = g.truthAllianceAnswers?.find(answer => answer !== 'unknown') ?? g.truthAllianceAnswers?.[0]; return answer ? [{ type: 'truthAnswer', answer }] : []; } + if (w.question.kind === 'mixedBribe') { + const answer = g.truthMixedBribeAnswers?.[0]; + return answer ? [{ type: 'truthAnswer', answer }] : []; + } if (w.question.kind === 'bribeExpression') { const answer = g.truthBribeExpressionAnswers?.[0]; return answer ? [{ type: 'truthAnswer', answer }] : []; diff --git a/game/engine.ts b/game/engine.ts index 7a0944ad..79db16f6 100644 --- a/game/engine.ts +++ b/game/engine.ts @@ -1,9 +1,10 @@ +import type { BribePaymentClaim, MixedBribeClaim } from './mixed-bribe-question'; import { compileMixedActionExpression, MixedActionQuestionError, type CompiledMixedAction } from './mixed-action-question'; import { MovementExpressionPromiseError, liveMovementExpressionPromises, recordMovementExpressionEvent, validateMovementExpressionPromises, type MovementExpression, type MovementExpressionClaim, type MovementExpressionPromise } from './movement-expression-promises'; import { BribeExpressionPromiseError, bribeExpressionRecipients, bribeCompletionCandidates, liveBribeExpressionPromises, recordBribeExpressionPayment, validateBribeExpressionPromises, - type BribeExpressionClaim, type BribeExpressionPromise } from './bribe-expression-promises'; + type BribeExpression, type BribeExpressionClaim, type BribeExpressionPromise } from './bribe-expression-promises'; import { RevivalExpressionPromiseError, liveRevivalExpressionPromises, revivalExpressionBranches, evaluateRevivalExpression, recordRevivalExpressionReturn, validateRevivalExpressionPromises, type RevivalExpression, type RevivalExpressionClaim, type RevivalExpressionPromise, type RevivalExpressionReturn } from './revival-expression-promises'; @@ -2162,6 +2163,10 @@ export type Game = { revivalPromiseSequence?: string[]; bribePromises?: BribePromise[]; bribeExpressionPromises?: BribeExpressionPromise[]; + /** Public original mixed questions; native residuals own physical payment rules. */ + mixedBribeQuestions?: (MixedBribeClaim & { + event: string; player: string; asker: string; answer: boolean; binding: boolean; + })[]; bribePromiseSequence?: string[]; alliancePromises?: AlliancePromise[]; movementPromises?: MovementPromise[]; @@ -6908,6 +6913,9 @@ function truthtranceDiscardSignature(g: Game, next: TruthDiscardContinuation) { battle: g.battle, shipmentPromises: g.shipmentPromises, movementPromises: g.movementPromises, + ...(next.record.question.kind === 'mixedBribe' ? { + mixedBribeQuestions: g.mixedBribeQuestions, bribeExpressionPromises: g.bribeExpressionPromises, + } : {}), ...(next.record.question.kind === 'mixedMovement' ? { mixedMovementQuestions: g.mixedMovementQuestions, movementExpressionPromises: g.movementExpressionPromises, } : {}), @@ -15194,6 +15202,54 @@ function bindBribeExpressionTruth(g: Game, p: Player, claim: BribeExpressionClai (g.bribePromiseSequence ??= []).push(promise.event); reopenBribePayer(g, p, answer); } +function compileMixedBribe(g: Game, p: Player, claim: MixedBribeClaim, answer: boolean) { + const compiled = compileMixedActionExpression(claim.mixed, + fact => truthFactAnswer(p, fact, truthKnowledgeOf(g, p)), answer); + if (compiled.kind === 'constant') return { constant: compiled.value }; + const payments = (node: CompiledMixedAction): BribeExpression => { + if (node.kind === 'action') return { kind: 'payment', ...node.action }; + requireRule(node.kind !== 'constant', 'Retain the full privately compiled mixed-bribe obligation.'); + return { kind: node.kind, terms: node.terms.map(payments) }; + }; + return { residual: { turn: claim.turn, claim: payments(compiled) } }; +} +function mixedBribeTruthAnswers(g: Game, p: Player, claim: MixedBribeClaim): TruthAnswer[] { + if (claim.turn !== g.turn || !bribeQuestionWindow(g)) return []; + const answers: TruthAnswer[] = []; + for (const answer of [true, false]) { + const compiled = compileMixedBribe(g, p, claim, answer); + if (compiled.constant !== undefined ? compiled.constant === answer : + bribeExpressionTruthAnswers(g, p, compiled.residual!).includes(answer ? 'yes' : 'no')) answers.push(answer ? 'yes' : 'no'); + } + return answers.length ? answers : ['unknown']; +} +function bindMixedBribeTruth(g: Game, p: Player, claim: MixedBribeClaim, answer: boolean, asker: string) { + requireRule(mixedBribeTruthAnswers(g, p, claim).includes(answer ? 'yes' : 'no'), + 'Choose a mixed bribe answer compatible with the whole current-fact and payment question.'); + const compiled = compileMixedBribe(g, p, claim, answer); + let event: string; + if (compiled.residual) { + bindBribeExpressionTruth(g, p, compiled.residual, answer, asker); + event = g.bribeExpressionPromises!.at(-1)!.event; + } else { + requireRule(compiled.constant === answer, 'Retain the truthful whole mixed-bribe answer.'); + reopenBribePayer(g, p, answer); + event = crypto.randomUUID(); + } + (g.mixedBribeQuestions ??= []).push({ turn: claim.turn, mixed: structuredClone(claim.mixed), + event, player: p.id, asker, answer, binding: !!compiled.residual }); +} +function isMixedBribeEvent(g: Game, event: string): boolean { + return !!g.mixedBribeQuestions?.some(question => question.event === event); +} +function projectedMixedBribePromises(g: Game, player: string) { + return (g.mixedBribeQuestions ?? []).filter(question => question.player === player).map(question => { + const bound = g.bribeExpressionPromises?.find(promise => promise.event === question.event); + return { event: question.event, player: question.player, asker: question.asker, turn: question.turn, + mixed: structuredClone(question.mixed), answer: question.answer, progress: structuredClone(bound?.progress ?? []), + fulfilled: !question.binding || bound?.fulfilled === true, released: bound?.released === true }; + }); +} function reconcileBribePromises(g: Game, voluntary?: { actor: string; action: Action }) { type Promise = BribePromise | BribeExpressionPromise; const pendingPromises: Promise[] = [...(g.bribePromises ?? []), ...(g.bribeExpressionPromises ?? [])] @@ -36455,6 +36511,8 @@ function applyActionInner( bindBribe: bindBribeTruth, bribeExpressionAnswers: bribeExpressionTruthAnswers, bindBribeExpression: bindBribeExpressionTruth, + mixedBribeAnswers: mixedBribeTruthAnswers, + bindMixedBribe: bindMixedBribeTruth, revivalExpressionAnswers: revivalExpressionTruthAnswers, bindRevivalExpression: bindRevivalExpressionTruth, leaderRevivalAnswers: leaderRevivalTruthAnswers, @@ -40319,7 +40377,11 @@ export function viewGame(state: Game, id: string) { truthBribeExpressionTargets: bribeQuestionWindow(g) ? g.players.map(player => player.id) : [], truthBribeExpressionAnswers: g.truthtrance?.stage === 'answer' && g.truthtrance.question?.target === id && g.truthtrance.question.kind === 'bribeExpression' ? bribeExpressionTruthAnswers(g, me, g.truthtrance.question) : null, - bribeExpressionPromises: (g.bribeExpressionPromises ?? []).filter(promise => promise.player === id).map(promise => structuredClone(promise)), + bribeExpressionPromises: (g.bribeExpressionPromises ?? []).filter(promise => promise.player === id && !isMixedBribeEvent(g, promise.event)).map(promise => structuredClone(promise)), + truthMixedBribeTargets: bribeQuestionWindow(g) ? g.players.map(player => player.id) : [], + truthMixedBribeAnswers: g.truthtrance?.stage === 'answer' && g.truthtrance.question?.target === id && + g.truthtrance.question.kind === 'mixedBribe' ? mixedBribeTruthAnswers(g, me, g.truthtrance.question) : null, + mixedBribePromises: projectedMixedBribePromises(g, id), truthRevivalTargets: revivalQuestionWindow(g) ? g.players.filter(player => revivalOpportunity(g, player.id)).map(player => player.id) : [], truthRevivalAnswers: g.truthtrance?.stage === 'answer' && g.truthtrance.question?.target === id && g.truthtrance.question.kind === 'revival' ? revivalTruthAnswers(g, me, g.truthtrance.question) : null, diff --git a/game/mixed-bribe-question.ts b/game/mixed-bribe-question.ts new file mode 100644 index 00000000..874f337c --- /dev/null +++ b/game/mixed-bribe-question.ts @@ -0,0 +1,15 @@ +import { BribePromiseError, parseBribeClaim, type BribeClaim } from './bribe-promises'; +import type { MixedActionExpression } from './mixed-action-question'; + +export type BribePaymentClaim = Pick; +export type MixedBribeClaim = { turn: number; mixed: MixedActionExpression }; + +/** Reuse scalar recipient/minimum decoding without accepting question metadata. + * The neutral turn validates only this leaf; engine owns the actual interval. */ +export function parseBribePaymentClaim(value: unknown): BribePaymentClaim { + if (!value || typeof value !== 'object' || Array.isArray(value) || + Object.keys(value).sort().join(',') !== 'minimum,recipient') + throw new BribePromiseError('Supply only an exact ordinary-payment recipient and positive spice minimum.'); + const { recipient, minimum } = parseBribeClaim({ ...value, turn: 1 }); + return { recipient, minimum }; +} diff --git a/game/reference.ts b/game/reference.ts index 6daf8e54..d1f6fb1e 100644 --- a/game/reference.ts +++ b/game/reference.ts @@ -3258,6 +3258,31 @@ export const RULE_TOPICS: RuleTopic[] = [ { area: 'Verification', status: 'Partial', detail: 'Focused pure, original deal/payment/Mentat/next-turn runtime and controlled/native UI evidence. Native alliance campaigns, optional compositions, future preparations and final browser/deployed acceptance remain open.', evidence: ['tests/fixture-mentat-bribes.ts', 'tests/mentat-bribes-runtime.test.ts', 'tests/fixture-truth-bribe.ts', 'tests/truth-bribe-runtime.test.ts', 'tests/truth-bribe-controls.test.tsx'] }, ], }, + { + id: 'truthtrance-mixed-bribe', + title: 'Truthtrance: current facts and ordinary payments', + category: 'Cards', + coverage: 'Partial', + developmentStage: 'Prototyped', + summary: 'Combine answer-time facts with cumulative future ordinary payments while keeping one native purse, deferred receipts and the private aggregate.', + steps: [ + 'Choose Combine current facts and ordinary payments. Build full AND/OR groups with at least one current fact and one named non-allied recipient/minimum condition. One16-leaf/depth4 software budget includes nested fact groups.', + 'Current facts freeze when answered. If you truthfully hold at least10 spice then promise payments totaling5, the fact remains the answer-time fact after your supply drops to5. Later spending or card custody creates no new factual answer.', + 'Only the complete yes/no answer and original question are public. A definite Yes cannot rely on an unknown fact being true; No cannot rely on it being false. The remaining funded payment obligation must guarantee the aggregate. If neither definite answer is currently supportable, the unanswered card may be saved or asked differently.', + 'A fact can already settle the whole answer, needing no later payment. Otherwise actual ordinary payer payments after the answer add together per recipient; earlier payments, gifts, allied aid and later Mentat collection do not count. No negates the whole mixed expression.', + 'Remaining payments use the original scalar/grouped bribe system, current uncommitted funds, nonally restrictions, previous budgets and accepted order. Dynamic OR recipients remain available. Answering grants no spice and pays nobody.', + 'Recipient shares stay deferred to the next actual Mentat opening; a late Mentat payment waits for next turn’s opening. Yes cannot evade by finishing Mentat; No remains binding until actual turn advance. Existing known Inflation Double closure retains its earlier Collection deadline.', + 'Full shared editing, guarded raw preview/Ask, private answers, own cumulative progress and one exact native payment guide connect to four minimal policies. Historical fulfilled panels do not duplicate or hide a new live guide. Native Basic/Advanced phases0–8 retain their existing quiet supported scope; other action families, correlated unknowns and optional compositions remain unfinished.', + ], + related: ['card-truthtrance', 'truthtrance-bribe-expression', 'truthtrance-bribe', 'truthtrance-mixed-movement', 'implementation-checklist'], + checklist: [ + { area: 'Implementation', status: 'Partial', detail: 'Generic answer-time compilation binds only a necessary native payment expression; raw aggregate projection hides compiled clauses and keeps native funding/receipt rules.', evidence: ['game/mixed-action-question.ts', 'game/mixed-bribe-question.ts', 'game/truthtrance.ts', 'game/engine.ts'] }, + { area: 'Player controls', status: 'Partial', detail: 'Reusable mixed editor serves movement/payments with stable movement controls; raw aggregate panel and one shared exact payment guide are connected.', evidence: ['components/mixed-action-fields.tsx', 'components/mixed-bribe-fields.tsx', 'components/mixed-bribe-promises.tsx', 'components/bribe-promises.tsx', 'components/truthtrance.tsx', 'components/game-table.tsx'] }, + { area: 'AI', status: 'Partial', detail: 'Four minimal profiles answer the aggregate and pay through exact native guides. Strategy/calibration remain deferred.', evidence: ['game/bots.ts', 'tests/truth-mixed-bribe-runtime.test.ts'] }, + { area: 'Documentation', status: 'Implemented', detail: 'Snapshot/unknown composition, original current-purse/receipt/deadline and remaining gates are explicit.', evidence: ['docs/TRUTHTRANCE_MIXED_BRIBES.md', 'docs/RULE_DECISIONS.md'] }, + { area: 'Verification', status: 'Partial', detail: 'Original native payment/receipt/funding and controlled shared editor/guide cases supplement existing scalar and grouped proof; wider composition/final deployed acceptance remain open.', evidence: ['tests/fixture-truth-mixed-bribe.ts', 'tests/truth-mixed-bribe-runtime.test.ts', 'tests/truth-mixed-bribe-funding.test.ts', 'tests/truth-mixed-bribe-controls.test.tsx', 'tests/truth-mixed-movement-controls.test.tsx'] }, + ], + }, { id: 'truthtrance-bribe-expression', title: 'Truthtrance: combined ordinary bribe payments', @@ -3401,7 +3426,7 @@ export const RULE_TOPICS: RuleTopic[] = [ related: ['card-truthtrance', 'truthtrance-fact-expression', 'truthtrance-movement-expression', 'truthtrance-movement', 'implementation-checklist'], checklist: [ { area: 'Implementation', status: 'Partial', detail: 'Strict generic mixed parser/compiler freezes facts conservatively and binds only the resulting native movement obligation; immediate aggregate answers create none.', evidence: ['game/mixed-action-question.ts', 'game/truthtrance.ts', 'game/engine.ts'] }, - { area: 'Player controls', status: 'Partial', detail: 'Full mixed editor with reused fact controls, guarded raw preview/Ask, private answers, aggregate panel and shared exact guide.', evidence: ['components/mixed-movement-fields.tsx', 'components/mixed-movement-promises.tsx', 'components/movement-expression-promises.tsx', 'components/truthtrance.tsx', 'components/game-table.tsx'] }, + { area: 'Player controls', status: 'Partial', detail: 'Full mixed editor with reused fact controls, guarded raw preview/Ask, private answers, aggregate panel and shared exact guide.', evidence: ['components/mixed-action-fields.tsx', 'components/mixed-movement-fields.tsx', 'components/mixed-movement-promises.tsx', 'components/movement-expression-promises.tsx', 'components/truthtrance.tsx', 'components/game-table.tsx'] }, { area: 'AI', status: 'Partial', detail: 'Four minimal profiles answer the aggregate and follow native movement guides. Strategy/calibration remain deferred.', evidence: ['game/bots.ts', 'tests/truth-mixed-movement-runtime.test.ts'] }, { area: 'Documentation', status: 'Implemented', detail: 'Snapshot, conservative unknown semantics, original physical obligations and remaining gates are explicit.', evidence: ['docs/TRUTHTRANCE_MIXED_MOVEMENT.md', 'docs/RULE_DECISIONS.md'] }, { area: 'Verification', status: 'Partial', detail: 'Focused generic, controlled editor/guide and original native known/unknown/Hajr/Charity cases. Broader composition and final browser/deployed acceptance remain open.', evidence: ['tests/mixed-action-question.test.ts', 'tests/fixture-truth-mixed-movement.ts', 'tests/truth-mixed-movement-runtime.test.ts', 'tests/truth-mixed-movement-controls.test.tsx'] }, @@ -3595,6 +3620,7 @@ export const RULE_TOPICS: RuleTopic[] = [ 'An ordinary-bid question can bind one new qualifying bid in the current lot for a supported active or waiting bidder. Yes requires that declaration while possible; No forbids it to lot close. A bid need not win to fulfill Yes, but a winning bid still follows its original payment rules. See the current-lot guide for funding, expiry and unfinished configurations.', 'A current-Nexus alliance question binds actual final membership with a named partner at that Nexus close. Yes uses existing partnership or an actual invitation; offers alone do not form alliances. No may require a later break before Ready. Unknown can save the card until consent exists. Other players retain their original withdrawal/break rights. See the alliance-promise guide for its provisional interval and scope.', 'A bribe-payment question binds cumulative future ordinary spice paid to one named non-allied recipient during this turn. Only the real payer action counts; the recipient still spends its receipt at Mentat. Split payments add together, and earlier obligations retain their funding. See the ordinary-bribe guide for the funded prototype and unfinished preparations.', + 'A mixed current-fact and ordinary-payment question freezes facts before later debits and keeps only the funded native payment obligation needed by the whole answer. The recipient still waits for its original Mentat opening; individual frozen clauses remain private. See the mixed payment guide for its provisional scope.', 'A mixed current-fact and ground-movement question freezes the fact at answer time and keeps only the native movement obligation needed for the whole answer. Later card disposal does not rewrite the fact, and unknown clauses require a guaranteed aggregate. See the mixed movement guide for its provisional scope.', 'A grouped ground-movement question combines future physical group minima with full AND/OR. One move must meet each leaf; smaller moves never add together. Actual owned entitlements can fulfill several leaves over several moves, while No negates the whole expression. See the combined movement guide for its provisional opportunity and scope.', 'A grouped ordinary-bribe question combines named future payment minima with full AND/OR. No negates the whole question; real payments rebuild legal funded alternatives, and next-opening recipient collection adds no new progress. See the combined bribe guide for its provisional interval and scope.', @@ -3625,6 +3651,7 @@ export const RULE_TOPICS: RuleTopic[] = [ 'truthtrance-revival-expression', 'truthtrance-bribe', 'truthtrance-bribe-expression', + 'truthtrance-mixed-bribe', 'truthtrance-alliance', 'richese-no-field', 'card-reinforcements', diff --git a/game/truthtrance.ts b/game/truthtrance.ts index bdba3f53..06d43ac0 100644 --- a/game/truthtrance.ts +++ b/game/truthtrance.ts @@ -1,3 +1,4 @@ +import { parseBribePaymentClaim, type MixedBribeClaim } from './mixed-bribe-question'; import { parseMixedActionExpression, mixedActionExpressionText, type MixedActionExpression } from './mixed-action-question'; import { parseMovementExpressionClaim, movementExpressionText, type MovementExpressionClaim } from './movement-expression-promises'; import { parseBribeExpressionClaim, bribeExpressionRecipients, bribeExpressionText, @@ -70,6 +71,7 @@ export type TruthFact = | { kind: 'and' | 'or'; terms: TruthFact[] }; export type MixedMovementClaim = { turn: number; mixed: MixedActionExpression }; export type TruthQuestion = + | ({ kind: 'mixedBribe'; target: string } & MixedBribeClaim) | ({ kind: 'mixedMovement'; target: string } & MixedMovementClaim) | ({ kind: 'movementExpression'; target: string } & MovementExpressionClaim) | ({ kind: 'bribeExpression'; target: string } & BribeExpressionClaim) @@ -260,6 +262,20 @@ function parseQuestion(g: Game, asker: string, value: unknown): TruthQuestion { 'Choose the current ordinary Nexus and another named partner in a supported table.'); return { kind: 'alliance', target: v.target, ...claim }; } + if (v.kind === 'mixedBribe') { + check(Object.keys(v).sort().join(',') === 'kind,mixed,target,turn' && v.turn === g.turn && + bribePromiseModeSupported(g) && g.status === 'playing' && g.phase >= 0 && g.phase <= 8 && + !g.response && !g.decision && !g.phaseOpening && !g.pendingTreacheryDiscard && !g.pendingKarama, + 'Supply the current turn, complete mixed bribe question and a supported quiet native window.'); + const respondent = g.players.find(player => player.id === v.target)!; + const mixed = parseMixedActionExpression(v.mixed, fact => parseFact(g, fact, respondent), input => { + const action = parseBribePaymentClaim(input); + check(action.recipient !== respondent.id && action.recipient !== respondent.ally && + g.players.some(player => player.id === action.recipient), 'Choose another current non-allied ordinary bribe recipient.'); + return action; + }); + return { kind: 'mixedBribe', target: v.target as string, turn: g.turn, mixed }; + } if (v.kind === 'bribeExpression') { check(Object.keys(v).sort().join(',') === 'claim,kind,target,turn', 'Supply the current turn, complete bribe expression and respondent.'); @@ -578,6 +594,8 @@ export function truthQuestionText( return `you currently hold ${f.compare === 'eq' ? 'exactly' : f.compare === 'gte' ? 'at least' : 'at most'} ${f.value} spice`; return `(${f.terms.map(clause).join(f.kind === 'and' ? ' AND ' : ' OR ')})`; }; + if (q.kind === 'mixedBribe') return `Is it true that ${mixedActionExpressionText(q.mixed, clause, + action => `you ${bribeExpressionText({ kind: 'payment', ...action }, playerName)} from now until this turn ends`)}?`; if (q.kind === 'mixedMovement') return `Is it true that ${mixedActionExpressionText(q.mixed, clause, action => `you ${movementClaimText(action)} before your Movement opportunity ends`)}?`; return `Is it true that ${q.kind === 'mixedShipment' @@ -612,6 +630,8 @@ export function resolveTruthAction( bindMovement?: (g: Game, p: Player, claim: MovementClaim, answer: boolean, asker: string) => void; allianceAnswers?: (g: Game, p: Player, claim: AllianceClaim) => TruthAnswer[]; bindAlliance?: (g: Game, p: Player, claim: AllianceClaim, answer: boolean, asker: string) => void; + mixedBribeAnswers?: (g: Game, p: Player, claim: MixedBribeClaim) => TruthAnswer[]; + bindMixedBribe?: (g: Game, p: Player, claim: MixedBribeClaim, answer: boolean, asker: string) => void; bribeExpressionAnswers?: (g: Game, p: Player, claim: BribeExpressionClaim) => TruthAnswer[]; bindBribeExpression?: (g: Game, p: Player, claim: BribeExpressionClaim, answer: boolean, asker: string) => void; bribeAnswers?: (g: Game, p: Player, claim: BribeClaim) => TruthAnswer[]; @@ -757,6 +777,9 @@ export function resolveTruthAction( if (w.question.kind === 'movementExpression') check(effects.movementExpressionAnswers?.(g, g.players.find(other => other.id === w.question!.target)!, w.question).length, 'Choose a supported whole ground-movement question.'); + if (w.question.kind === 'mixedBribe') + check(effects.mixedBribeAnswers?.(g, g.players.find(other => other.id === w.question!.target)!, w.question).length, + 'Choose a mixed current-fact and ordinary-payment question compatible with earlier answers.'); if (w.question.kind === 'bribeExpression') check(effects.bribeExpressionAnswers?.(g, g.players.find(other => other.id === w.question!.target)!, w.question).length, 'Choose a whole bribe expression compatible with earlier answers.'); @@ -845,6 +868,11 @@ export function resolveTruthAction( 'Choose an answer consistent with actual alliance consent and earlier commitments.'); if (a.answer !== 'unknown') effects.bindAlliance(g, p, q, a.answer === 'yes', current.player); } + if (q.kind === 'mixedBribe') { + check(effects.mixedBribeAnswers && effects.bindMixedBribe && effects.mixedBribeAnswers(g, p, q).includes(a.answer), + 'Choose a whole mixed-bribe answer compatible with current facts, funds and earlier commitments.'); + if (a.answer !== 'unknown') effects.bindMixedBribe(g, p, q, a.answer === 'yes', current.player); + } if (q.kind === 'bribeExpression') { check(effects.bribeExpressionAnswers && effects.bindBribeExpression && effects.bribeExpressionAnswers(g, p, q).includes(a.answer), 'Choose a whole bribe answer consistent with actual funding and earlier promises.'); diff --git a/tests/fixture-truth-mixed-bribe.ts b/tests/fixture-truth-mixed-bribe.ts new file mode 100644 index 00000000..1f5fe4e7 --- /dev/null +++ b/tests/fixture-truth-mixed-bribe.ts @@ -0,0 +1,88 @@ +import assert from 'node:assert/strict'; +import { viewGame, type Action, type Game } from '../game/engine'; +import type { MixedActionExpression } from '../game/mixed-action-question'; +import type { TruthFact } from '../game/truthtrance'; +import { + actTruthBribeExpression, advanceTruthBribeExpression, completeTruthBribeExpression, + createTruthBribeExpressionFixture, declareTruthBribeExpression, finishTruthBribeExpression, + nextTruthBribeExpression, settleTruthBribeExpression, truthBribeExpressionBalances, + truthBribeExpressionClean, truthBribeExpressionDeferred, truthBribeExpressionInventory, + truthBribeExpressionPlayer, type TruthBribeExpressionStep, type TruthBribeExpressionTransition, +} from './fixture-truth-bribe-expression'; + +export type TruthMixedBribeExpression = MixedActionExpression<{ recipient: string; minimum: number }>; +export type TruthMixedBribeStep = TruthBribeExpressionStep; +export type TruthMixedBribeTransition = TruthBribeExpressionTransition; +export const actTruthMixedBribe = actTruthBribeExpression; +export const advanceTruthMixedBribe = advanceTruthBribeExpression; +export const finishTruthMixedBribe = finishTruthBribeExpression; +export const nextTruthMixedBribe = nextTruthBribeExpression; +export const settleTruthMixedBribe = settleTruthBribeExpression; +export const truthMixedBribeBalances = truthBribeExpressionBalances; +export const truthMixedBribeClean = truthBribeExpressionClean; +export const truthMixedBribeDeferred = truthBribeExpressionDeferred; +export const truthMixedBribeInventory = truthBribeExpressionInventory; +export const truthMixedBribePlayer = truthBribeExpressionPlayer; + +export const truthMixedBribeFact = (fact: TruthFact): TruthMixedBribeExpression => ({ kind: 'fact', fact }); +export const truthMixedBribePayment = (recipient: string, minimum = 3): TruthMixedBribeExpression => + ({ kind: 'action', action: { recipient, minimum } }); +export const truthMixedBribeGroup = (kind: 'and' | 'or', ...terms: TruthMixedBribeExpression[]): TruthMixedBribeExpression => + ({ kind, terms }); + +/** Original H/A/E base33 Basic20/Advanced23 prefix, or its actual Collection/ + * Mentat continuation. Only the raw question changes. E retains its original + * Shield and ten spice; no played clock, purse, hand, answer or promise is set. */ +export function createTruthMixedBribeFixture(options: { + advanced?: boolean; window?: 'waiting' | 'active'; phase?: 3 | 7 | 8; mixed?: TruthMixedBribeExpression; +} = {}) { + const base = createTruthBribeExpressionFixture(options); + const shield = base.setup.deck.find(card => card.kind === 'shield'); + const hajr = base.setup.deck.find(card => card.effect === 'hajr'); + assert.ok(shield && hajr, 'The unopened base33 inventory supplies printed current-fact identities'); + const shieldFact: TruthFact = { kind: 'hand', name: shield.name }; + const hajrFact: TruthFact = { kind: 'hand', name: hajr.name }; + const spiceFact: TruthFact = { kind: 'spice', compare: 'gte', value: 10 }; + const forecastFact: TruthFact = { kind: 'stormForecast', compare: 'gte', value: 1 }; + const mixed = structuredClone(options.mixed ?? truthMixedBribeGroup('and', truthMixedBribeFact(spiceFact), + truthMixedBribePayment(base.asker, 3), truthMixedBribePayment(base.opponent, 2))); + const question = { kind: 'mixedBribe' as const, target: base.target, turn: base.game.turn, mixed }; + return { ...base, bribeSource: base, mixed, question, shieldFact, hajrFact, spiceFact, forecastFact, + questionAction: { type: 'truthAsk', question } satisfies Action, + sourceCounts: { inherited: base.sourceActionCount, basicBidding: 20, advancedBidding: 23, + basicMentat: 32, advancedMentat: 35 }, + sourceDisclosure: `${base.sourceDisclosure} This thin mixed adapter changes only the original raw question: current facts and future ordinary cumulative payments share one AND/OR tree. No frozen answer, compiled residual, promise or progress is installed.` }; +} +export type TruthMixedBribeFixture = ReturnType; + +export function declareTruthMixedBribe(f: TruthMixedBribeFixture, source = f.game, options: { copies?: 1 | 2 } = {}) { + return declareTruthBribeExpression(f.bribeSource, source, options); +} +export function askTruthMixedBribe(game: Game, asker: string, target: string, mixed: TruthMixedBribeExpression, + actions: TruthMixedBribeStep[] = []): Game { + return actTruthMixedBribe(game, asker, { type: 'truthAsk', question: { + kind: 'mixedBribe', target, turn: game.turn, mixed: structuredClone(mixed), + } }, actions); +} +export function answerTruthMixedBribe(game: Game, target: string, answer: 'yes' | 'no', + actions: TruthMixedBribeStep[] = []): Game { + return actTruthMixedBribe(game, target, { type: 'truthAnswer', answer }, actions); +} +export function bindTruthMixedBribe(f: TruthMixedBribeFixture, answer: 'yes' | 'no' = 'yes', + mixed = f.mixed, source = f.game) { + const declared = declareTruthMixedBribe(f, source), actions = [...declared.actions]; + const asked = askTruthMixedBribe(declared.game, f.asker, f.target, mixed, actions); + const game = answerTruthMixedBribe(asked, f.target, answer, actions); + return { game, declared, asked, actions, actionCount: actions.length }; +} +export function completeTruthMixedBribe(f: TruthMixedBribeFixture, source = f.game) { + return completeTruthBribeExpression(f.bribeSource, source); +} + +/** The public original question and whole answer only. This accessor never + * reads private frozen clauses or the internal native residual binding. */ +export function truthMixedBribePromise(game: Game, target = game.truthHistory?.at(-1)?.question.target ?? game.players[0].id) { + const row = viewGame(game, target).mixedBribePromises.find(row => row.player === target); + assert.ok(row, 'The respondent retains the original mixed question and whole-answer status'); + return row; +} diff --git a/tests/truth-bribe-expression-controls.test.tsx b/tests/truth-bribe-expression-controls.test.tsx index 47784f13..28c6cf24 100644 --- a/tests/truth-bribe-expression-controls.test.tsx +++ b/tests/truth-bribe-expression-controls.test.tsx @@ -168,7 +168,8 @@ void test('one shared guide handles scalar and whole promises without duplicatin const game = projected(); assert.match(markup(game), /data-testid="bribe-promise-guide"/); game.bribePromises = [{ event: 'scalar-history', player: 'p', asker: 'a', turn: 1, recipient: 'r', minimum: 1, answer: true, progress: 1, fulfilled: true }]; - assert.doesNotMatch(markup(game), /data-testid="bribe-promise-guide"/); + // Historical scalar records do not own a newly live expression guide. + assert.match(markup(game), /data-testid="bribe-promise-guide"/); const both = renderToStaticMarkup(createElement('div', null, createElement(BribePromises, { game, busy: false, send() {} }), createElement(BribeExpressionPromises, { game, busy: false, send() {} }))); diff --git a/tests/truth-mixed-bribe-controls.test.tsx b/tests/truth-mixed-bribe-controls.test.tsx new file mode 100644 index 00000000..dd7ac04e --- /dev/null +++ b/tests/truth-mixed-bribe-controls.test.tsx @@ -0,0 +1,292 @@ +import assert from 'node:assert/strict'; +import test from 'node:test'; +import { createElement, isValidElement, type ReactElement, type ReactNode } from 'react'; +import { renderToStaticMarkup } from 'react-dom/server'; +import { MixedActionFields, type MixedActionConfig } from '../components/mixed-action-fields'; +import { MixedBribeFields, mixedBribeInputError } from '../components/mixed-bribe-fields'; +import { MixedBribePromises } from '../components/mixed-bribe-promises'; +import { MixedMovementFields } from '../components/mixed-movement-fields'; +import { TruthFactFields } from '../components/mixed-shipment-fields'; +import { BribePromises, BribePromiseGuideButton } from '../components/bribe-promises'; +import { BribeExpressionPromises } from '../components/bribe-expression-promises'; +import { createGame, joinGame, newPlayer, viewGame, type Action, type GameView } from '../game/engine'; +import type { MixedActionExpression } from '../game/mixed-action-question'; +import type { BribePaymentClaim } from '../game/mixed-bribe-question'; +import type { TruthFact } from '../game/truthtrance'; +import { createTechTokens } from '../game/tech-tokens'; + +type Expression = MixedActionExpression; +type ElementProps = { children?: ReactNode; [key: string]: unknown }; +type Element = ReactElement; +const fact = (value: TruthFact = { kind: 'hand', name: 'Shield' }): Expression => ({ kind: 'fact', fact: value }); +const payment = (minimum = 1, recipient = 'r'): Expression => ({ kind: 'action', action: { recipient, minimum } }); +const claim = (): Expression => ({ kind: 'or', terms: [fact(), { kind: 'and', terms: [payment(3), payment(2, 'a')] }] }); +function elements(node: ReactNode): Element[] { + if (Array.isArray(node)) return node.flatMap(elements); + if (!isValidElement(node)) return []; + return [node, ...elements(node.props.children)]; +} +function find(tree: ReactNode, key: string, value: string): Element { + const found = elements(tree).find(element => element.props[key] === value); + assert.ok(found, `${key}=${value}`); return found; +} +const control = (tree: ReactNode, key: string) => find(tree, 'data-mixed-bribe-control', key); +const click = (button: Element) => (button.props.onClick as () => void)(); +function select(tree: ReactNode, path: string, field: string, value: string) { + const input = find(tree, 'id', `truth-mixed-bribe-${path}-${field}`); + (input.props.onChange as (event: { currentTarget: { value: string } }) => void)({ currentTarget: { value } }); +} +function minimum(tree: ReactNode, path: string, valueAsNumber: number) { + const input = find(tree, 'id', `truth-mixed-bribe-${path}-minimum`); + (input.props.onChange as (event: { currentTarget: { valueAsNumber: number } }) => void)({ currentTarget: { valueAsNumber } }); +} +function editFact(tree: ReactNode, path: string, next: TruthFact) { + const scope = find(tree, 'data-mixed-bribe-fact-path', path); + const fields = elements(scope).find(element => element.type === TruthFactFields); + assert.ok(fields, `Current fact fields ${path}`); + (fields.props.onChange as (fact: TruthFact) => void)(next); +} + +/** Controlled personalized projections exercise UI ownership and callbacks. + * Native answer-time snapshots, funding and real payments have separate proof. */ +function projected(phase = 3, advanced = false): GameView { + const source = createGame('TRUTHMIXEDBRIBECONTROLS', newPlayer('p', 'Respondent', 'emperor'), advanced); + joinGame(source, newPlayer('a', 'Asker', 'atreides')); + joinGame(source, newPlayer('r', 'Recipient', 'harkonnen')); + const game = viewGame(source, 'p'); + game.status = 'playing'; game.turn = 2; game.phase = phase; game.active = 'a'; + game.auction = { bid: 0, bidder: null, active: 'a', remaining: 2, card: null, inspectionBlocked: null }; + game.bribeOptions = { available: 8, incoming: 0, blocked: null, + targets: [{ id: 'r', maximum: 6, limitation: null }, { id: 'a', maximum: 8, limitation: null }] }; + game.bribePromises = []; game.bribeExpressionPromises = []; + game.mixedBribePromises = [{ event: 'controlled-mixed-bribe-event', player: 'p', asker: 'a', turn: 2, + mixed: claim(), answer: true, progress: [{ recipient: 'r', amount: 1 }], fulfilled: false, released: false }]; + game.bribePromiseGuide = { action: { type: 'bribe', target: 'r', amount: 2, bribePromiseEvent: 'controlled-mixed-bribe-event' } }; + return game; +} +function editor(initial: Expression, disabled = false, game = projected()) { + let value = initial, changes = 0; + return { + get value() { return value; }, get changes() { return changes; }, + tree: () => MixedBribeFields({ value, game, target: 'p', disabled, onChange(next) { value = next; changes++; } }), + html: () => renderToStaticMarkup(createElement(MixedBribeFields, { value, game, target: 'p', disabled, onChange() {} })), + error: () => mixedBribeInputError(value, game, 'p'), + }; +} +function guide(props: Parameters[0]) { + const button = BribePromiseGuideButton(props); assert.ok(button); return button; +} +const press = (button: ReturnType) => button.props.onClick(); +const markup = (game: GameView) => renderToStaticMarkup(createElement(MixedBribePromises, { game, busy: false, send() {} })); + +void test('shared mixed editor adapts actions and keeps movement wrapper identifiers and fact controls stable', () => { + type Probe = { token: string }; + let value: MixedActionExpression = { kind: 'fact', fact: { kind: 'hand', name: 'Shield' } }; + const game = projected(); let parsed = 0; + const config: MixedActionConfig = { + prefix: 'mixed-probe', legend: 'Probe claim', actionLabel: 'probe condition', actionTiming: 'Future probe', + actionHelp: 'Probe mechanics', fallbackError: 'Choose a probe', maxLeaves: 16, maxDepth: 4, + newAction: () => ({ token: 'exact-token' }), + parseAction: input => { parsed++; return input as Probe; }, + renderAction: props => , + }; + const tree = () => MixedActionFields({ value, game, target: 'p', disabled: false, config, onChange(next) { value = next; } }); + click(find(tree(), 'data-mixed-probe-control', 'or-1')); + assert.deepEqual(value, { kind: 'or', terms: [fact(), { kind: 'action', action: { token: 'exact-token' } }] }); + find(tree(), 'htmlFor', 'truth-mixed-probe-1.2-token'); assert.ok(parsed > 0); + let movementChanges = 0; + const movement = MixedMovementFields({ value: { kind: 'and', terms: [{ kind: 'fact', fact: { kind: 'hand', name: 'Shield' } }, + { kind: 'action', action: { territory: 'carthag', minimum: 2 } }] }, game, target: 'p', disabled: false, + onChange() { movementChanges++; } }); + find(movement, 'id', 'truth-mixed-movement-1.2-territory'); + find(movement, 'data-mixed-movement-fact-path', '1.1'); + click(find(movement, 'data-mixed-movement-control', 'nested-or-1')); assert.equal(movementChanges, 1); +}); + +void test('mixed bribe editor preserves sixteen clauses, public recipients, unique IDs and safe integer minima without a spice cap', () => { + const e = editor(fact()); click(control(e.tree(), 'or-1')); select(e.tree(), '1.2', 'recipient', 'r'); + for (let count = 3; count <= 16; count++) { + click(control(e.tree(), 'add-action-1')); minimum(e.tree(), `1.${count}`, count); + select(e.tree(), `1.${count}`, 'recipient', count % 2 ? 'r' : 'a'); + } + assert.ok(e.value.kind === 'or'); assert.equal(e.value.terms.length, 16); assert.equal(e.error(), null); + minimum(e.tree(), '1.16', Number.MAX_SAFE_INTEGER); assert.equal(e.error(), null); + const html = e.html(), ids = [...html.matchAll(/ id="([^"]+)"/g)].map(match => match[1]); + assert.equal(new Set(ids).size, ids.length); assert.match(html, /16 \/ 16 conditions/); + assert.equal((html.match(/Minimum future ordinary bribe payments in spice/g) ?? []).length, 15); + assert.match(html, /max="9007199254740991"/); + const before = structuredClone(e.value), changes = e.changes; + for (const key of ['add-fact-1', 'add-action-1', 'nested-and-1', 'nested-or-1', 'and-1.1', 'fact-or-1.1', 'or-1']) { + assert.equal(control(e.tree(), key).props.disabled, true); click(control(e.tree(), key)); + } + assert.equal(e.changes, changes); assert.deepEqual(e.value, before); + const game = projected(); game.players.find(player => player.id === 'p')!.ally = 'r'; + const allied = editor({ kind: 'and', terms: [fact(), payment()] }, false, game); + assert.ok(allied.error()); assert.doesNotMatch(allied.html(), /