Files
Dune/components/public-deals.tsx
T
Quintine d7d0f89625
Verify and publish checkpoint container / container (push) Canceled after 0s
Support multiple travel terms in public deals
2026-11-16 15:19:10 +11:00

597 lines
47 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
'use client';
import { useEffect, useRef, useState } from 'react';
import { faction } from '@/game/catalog';
import { TERRITORIES } from '@/game/board';
import { publicDealAcceptVotes, publicDealParticipants, publicDealTravelActor, publicDealTravelDueTurn } from '@/game/public-deals';
import { areCoalitionAllies } from '@/game/coalition-alliance';
import type { Action, GameView } from '@/game/engine';
import { Button } from '@/components/ui/button';
type Deal = GameView['deals'][number];
type ImmediateBribe = { kind: 'immediateBribe'; payer: string; recipient: string; amount: number };
type DeferredBribe = { kind: 'deferredBribe'; payer: string; recipient: string; amount: number; dueTurn: number };
type DealPayment = ImmediateBribe | DeferredBribe;
type DealTravel = { kind: 'ship' | 'move'; territory: string; minimum: number; answer: boolean; actor?: string; dueTurn?: number };
type DealTravelStatus = 'scheduled' | 'pending' | 'fulfilled' | 'void' | 'released';
type TravelDeal = Deal & { travel?: DealTravel; additionalTravel?: DealTravel[] };
type TravelProjection = GameView & { dealTravelStatus?: Record<string, DealTravelStatus>;
dealAdditionalTravelStatus?: Record<string, DealTravelStatus[]> };
type AdditionalTravelDraft = {key:number; actor:string; kind:'ship'|'move'; territory:string;
minimum:string; answer:boolean; dueTurn:string};
type DeferredPaymentStatus = 'pending' | 'paid' | 'void' | 'released';
type AdditionalPayment = { payment: DeferredBribe; paymentStatus?: DeferredPaymentStatus };
type AdditionalPaymentDraft = { key: number; payer: string; recipient: string; amount: string; dueTurn: string };
type AdditionalImmediateDraft = { key: number; payer: string; recipient: string; amount: string };
type DeferredPaymentProjection = GameView & {
deferredDealPaymentOptions?: Record<string, { blocked: string | null }>;
};
/** Alliance membership is public. Scalar links retain legacy pair behavior;
* a staged group uses the same coalition quote as authoritative rules. */
function allied(game: GameView, a: GameView['players'][number], b: GameView['players'][number]): boolean {
return a.ally === b.id || b.ally === a.id ||
!!game.coalitionState && areCoalitionAllies(game.players, game.coalitionState, a.id, b.id);
}
/** Additional travelers consent after non-traveling invitees, without making
* multiple travelers wait on each other. Single-term offers retain their
* existing final-traveler rule. */
function travelVoteWaiting(deal: Deal, actor: string, parties: string[], accepted: string[]): boolean {
const {travel,additionalTravel = []} = deal as TravelDeal;
if (!travel || parties.length <= 2 || actor === deal.from) return false;
if (!additionalTravel.length) return publicDealTravelActor(deal) === actor &&
parties.some(id => id !== actor && !accepted.includes(id));
const travelers = new Set([publicDealTravelActor(deal), ...additionalTravel.map(term => term.actor)]);
return travelers.has(actor) && parties.some(id => id !== deal.from && !travelers.has(id) && !accepted.includes(id));
}
/** Requests are local to the active seat; an owed payment is as important to
* surface as a pending invitation or a request to release an agreement. */
export function publicDealRequests(game: GameView): string[][] {
if (game.status !== 'playing') return [];
return game.deals.flatMap(deal => {
const requests: string[][] = [];
const parties = publicDealParticipants(deal), accepted = publicDealAcceptVotes(deal);
const participant = parties.includes(game.me);
const travel = (deal as TravelDeal).travel;
const extraTravel = (deal as TravelDeal).additionalTravel ?? [];
const waitingForOtherVotes = travelVoteWaiting(deal,game.me,parties,accepted);
if (deal.status === 'offered' && participant && deal.from !== game.me && !accepted.includes(game.me)) {
const groupTraveler = !!travel && parties.length > 2 &&
(publicDealTravelActor(deal) === game.me || extraTravel.some(term => term.actor === game.me));
requests.push(groupTraveler ? ['offer', deal.id, waitingForOtherVotes ? 'waiting' : 'ready'] : ['offer', deal.id]);
}
if (deal.status === 'active' && participant && !deal.releaseVotes.includes(game.me) && deal.releaseVotes.length > 0)
requests.push(['release', deal.id, ...deal.releaseVotes]);
const pending = deal as unknown as { payment?: DealPayment; paymentStatus?: DeferredPaymentStatus };
if (deal.status === 'active' && pending.payment?.kind === 'deferredBribe' &&
pending.payment.payer === game.me && pending.paymentStatus === 'pending' && pending.payment.dueTurn <= game.turn)
requests.push(['payment', deal.id]);
const additional = (deal as unknown as { additionalPayments?: AdditionalPayment[] }).additionalPayments ?? [];
if (deal.status === 'active') additional.forEach((term, index) => {
if (term.payment.payer === game.me && term.paymentStatus === 'pending' && term.payment.dueTurn <= game.turn)
requests.push(['payment', deal.id, String(index)]);
});
if (deal.status === 'active' && travel && publicDealTravelActor(deal) === game.me &&
(game as TravelProjection).dealTravelStatus?.[deal.id] === 'pending')
requests.push(['travel', deal.id]);
if (deal.status === 'active') extraTravel.forEach((term,index) => {
if (term.actor === game.me && (game as TravelProjection).dealAdditionalTravelStatus?.[deal.id]?.[index] === 'pending')
requests.push(['travel',deal.id,String(index)]);
});
return requests;
});
}
/** Keep the legacy single-recipient wire packet when only one seat is chosen. */
export function publicDealOfferAction(targets: readonly string[], terms: string, payment?: DealPayment, proposer?: string, currentTurn?: number, travel?: DealTravel, additionalPayments?: readonly DeferredBribe[], additionalImmediatePayments?: readonly ImmediateBribe[], additionalTravel?: readonly DealTravel[]): Action | null {
const text = terms.trim();
if (!targets.length || targets.length > 5 || new Set(targets).size !== targets.length || !text || text.length > 500) return null;
if (payment && (!proposer || (payment.kind !== 'immediateBribe' && payment.kind !== 'deferredBribe') || payment.payer === payment.recipient ||
![proposer, ...targets].includes(payment.payer) || ![proposer, ...targets].includes(payment.recipient) ||
!Number.isSafeInteger(payment.amount) || payment.amount < 1 ||
(payment.kind === 'deferredBribe' && (!Number.isSafeInteger(payment.dueTurn) || payment.dueTurn < 1 ||
(currentTurn !== undefined && (!Number.isSafeInteger(currentTurn) || currentTurn < 1 || payment.dueTurn < currentTurn)))))) return null;
if (additionalPayments && (additionalPayments.length > 12 || additionalPayments.some(term =>
!proposer || term.kind !== 'deferredBribe' || term.payer === term.recipient ||
![proposer, ...targets].includes(term.payer) || ![proposer, ...targets].includes(term.recipient) ||
!Number.isSafeInteger(term.amount) || term.amount < 1 || !Number.isSafeInteger(term.dueTurn) || term.dueTurn < 1 ||
currentTurn !== undefined && (!Number.isSafeInteger(currentTurn) || currentTurn < 1 || term.dueTurn < currentTurn)))) return null;
if (additionalImmediatePayments && (additionalImmediatePayments.length > 12 || additionalImmediatePayments.some(term =>
!proposer || term.kind !== 'immediateBribe' || term.payer === term.recipient ||
![proposer, ...targets].includes(term.payer) || ![proposer, ...targets].includes(term.recipient) ||
!Number.isSafeInteger(term.amount) || term.amount < 1))) return null;
const groupTravel = !!travel && targets.length > 1;
const travelKeys = travel ? Object.keys(travel).filter(key => key !== 'dueTurn').sort().join(',') : '';
const travelDeadline = travel && Object.hasOwn(travel, 'dueTurn') ? travel.dueTurn : undefined;
if (travel && (!proposer || targets.includes(proposer) ||
(groupTravel ? travelKeys !== 'actor,answer,kind,minimum,territory' ||
typeof travel.actor !== 'string' || ![proposer, ...targets].includes(travel.actor) :
travelKeys !== 'answer,kind,minimum,territory' &&
(travelKeys !== 'actor,answer,kind,minimum,territory' || travel.actor !== proposer)) ||
(Object.hasOwn(travel, 'dueTurn') && (!Number.isSafeInteger(travelDeadline) || (travelDeadline as number) < 1 ||
(currentTurn !== undefined && (!Number.isSafeInteger(currentTurn) || currentTurn < 1 || (travelDeadline as number) < currentTurn)))) ||
!['ship', 'move'].includes(travel.kind) || !TERRITORIES.some(territory => territory.id === travel.territory) ||
!Number.isSafeInteger(travel.minimum) || travel.minimum < 1 || travel.minimum > 20 ||
typeof travel.answer !== 'boolean')) return null;
if (additionalTravel?.length && (!travel || !proposer || additionalTravel.length > 12 || additionalTravel.some(term => {
const keys = Object.keys(term).filter(key => key !== 'dueTurn').sort().join(',');
return keys !== 'actor,answer,kind,minimum,territory' || !term.actor || ![proposer,...targets].includes(term.actor) ||
!['ship','move'].includes(term.kind) || !TERRITORIES.some(territory => territory.id === term.territory) ||
!Number.isSafeInteger(term.minimum) || term.minimum < 1 || term.minimum > 20 || typeof term.answer !== 'boolean' ||
Object.hasOwn(term,'dueTurn') && (!Number.isSafeInteger(term.dueTurn) || term.dueTurn! < 1 ||
currentTurn !== undefined && term.dueTurn! < currentTurn);
}))) return null;
const offeredPayment = payment ? { payment } : {};
const offeredAdditional = additionalPayments?.length
? { additionalPayments: additionalPayments.map(term => ({kind:term.kind, payer:term.payer,
recipient:term.recipient, amount:term.amount, dueTurn:term.dueTurn})) } : {};
const offeredImmediate = additionalImmediatePayments?.length
? { additionalImmediatePayments: additionalImmediatePayments.map(term => ({kind:term.kind, payer:term.payer,
recipient:term.recipient, amount:term.amount})) } : {};
const normalizedTravel = travel ? {...travel} : undefined;
if (normalizedTravel && travelDeadline === currentTurn) delete normalizedTravel.dueTurn;
const offeredTravel = normalizedTravel ? { travel: normalizedTravel } : {};
const offeredExtraTravel = additionalTravel?.length ? { additionalTravel: additionalTravel.map(term => {
const result = {...term};
if (result.dueTurn === currentTurn) delete result.dueTurn;
return result;
}) } : {};
return targets.length === 1
? { type: 'dealOffer', target: targets[0], terms: text, ...offeredPayment, ...offeredAdditional, ...offeredImmediate, ...offeredTravel, ...offeredExtraTravel }
: { type: 'dealOffer', targets: [...targets], terms: text, ...offeredPayment, ...offeredAdditional, ...offeredImmediate, ...offeredTravel, ...offeredExtraTravel };
}
/** The whole table can read an offer and its history; only its parties act. */
export function PublicDealList({ game, act, disabled }: {
game: GameView;
act: (action: Action) => void;
disabled: boolean;
}) {
const name = (id: string) => {
const player = game.players.find(candidate => candidate.id === id);
return player ? `${player.name} (${faction(player.faction).name})` : 'Unknown player';
};
const canAct = game.status === 'playing' && !game.players.find(player => player.id === game.me)?.bot;
const deals: Deal[] = game.deals ?? [];
if (!deals.length) return <p>No public deals have been proposed.</p>;
return <ol>
{deals.map(deal => {
const participants = publicDealParticipants(deal);
const accepted = publicDealAcceptVotes(deal);
const party = participants.includes(game.me);
const voted = deal.releaseVotes.includes(game.me);
const recipient = party && game.me !== deal.from;
const seats = participants.map(id => game.players.find(player => player.id === id));
const eligible = seats.every((player, index) => player && seats.slice(index + 1).every(other =>
other && !allied(game, player, other)));
const payment = (deal as unknown as { payment?: DealPayment }).payment;
const paymentStatus = (deal as unknown as { paymentStatus?: DeferredPaymentStatus }).paymentStatus;
const additional = (deal as unknown as { additionalPayments?: AdditionalPayment[] }).additionalPayments ?? [];
const additionalImmediate = (deal as unknown as { additionalImmediatePayments?: ImmediateBribe[] }).additionalImmediatePayments ?? [];
const travel = (deal as TravelDeal).travel;
const extraTravel = (deal as TravelDeal).additionalTravel ?? [];
const travelActor = travel ? publicDealTravelActor(deal) : undefined;
const travelStatus = (game as TravelProjection).dealTravelStatus?.[deal.id];
const travelTurn = travel ? publicDealTravelDueTurn(deal) : undefined;
const travelExpired = travelTurn !== undefined && game.turn > travelTurn ||
extraTravel.some(term => game.turn > (term.dueTurn ?? deal.turn));
const travelDestination = travel && TERRITORIES.find(territory => territory.id === travel.territory)?.name;
const finalAcceptance = recipient && !accepted.includes(game.me) && accepted.length === participants.length - 1;
const travelActorWaiting = travelVoteWaiting(deal,game.me,participants,accepted);
const paymentBlocked = finalAcceptance && (payment?.kind === 'immediateBribe' && payment.payer === game.me ||
additionalImmediate.some(term => term.payer === game.me)) ? game.bribeOptions?.blocked : null;
const paymentExpired = payment?.kind === 'deferredBribe' && game.turn > payment.dueTurn ||
additional.some(term => game.turn > term.payment.dueTurn);
const deferredOption = (game as DeferredPaymentProjection).deferredDealPaymentOptions?.[deal.id];
const mayPay = payment?.kind === 'deferredBribe' && deal.status === 'active' && paymentStatus === 'pending' &&
payment.payer === game.me && canAct;
return <li key={deal.id}>
<p><strong>{name(deal.from)} → {participants.filter(id => id !== deal.from).map(name).join(', ')}</strong> · Turn {deal.turn} · {deal.status}</p>
<p>{deal.terms}</p>
{payment?.kind === 'immediateBribe' && <p><strong>Immediate payment term:</strong> {name(payment.payer)} pays {payment.amount} spice to {name(payment.recipient)} on final acceptance. The payer loses the gross amount immediately; the recipient collects their share at the next Mentat opening. A Bureaucrat may divert two spice to the bank before that share is allocated. Releasing the deal later does not refund the payment.</p>}
{additionalImmediate.map((term, index) => <p key={`immediate-${index}`}><strong>Additional immediate payment {index + 1}:</strong> {name(term.payer)} pays {term.amount} spice to {name(term.recipient)} on final acceptance. The recipient collects their share at the next Mentat opening; a Bureaucrat may redirect two spice to the bank.</p>)}
{payment?.kind === 'immediateBribe' && travel && <p>The recipient cannot spend this payment before its next Mentat collection; after collection it can fund travel in a later turn.</p>}
{payment?.kind === 'deferredBribe' && <p><strong>Deferred payment term:</strong> {name(payment.payer)} pays exactly {payment.amount} spice to {name(payment.recipient)} on or before the end of turn {payment.dueTurn}. The recipient collects their share at the next Mentat opening; a Bureaucrat may divert two spice to the bank. {paymentStatus ? `Payment status: ${paymentStatus}.` : 'Payment becomes binding on final acceptance.'}</p>}
{additional.map((term, index) => {
const option = (game as DeferredPaymentProjection).deferredDealPaymentOptions?.[`${deal.id}:payment:${index}`];
const canPay = deal.status === 'active' && term.paymentStatus === 'pending' &&
term.payment.payer === game.me && canAct;
return <div key={index}>
<p><strong>Additional payment {index + 1}:</strong> {name(term.payment.payer)} pays exactly {term.payment.amount} spice to {name(term.payment.recipient)} on or before the end of turn {term.payment.dueTurn}. {term.paymentStatus ? `Payment status: ${term.paymentStatus}.` : 'Payment becomes binding on final acceptance.'}</p>
{canPay && <div>
{option?.blocked && <p>Payment is unavailable: {option.blocked}</p>}
<Button type="button" disabled={disabled || !option || !!option.blocked}
onClick={() => act({type:'dealPay',deal:deal.id,paymentIndex:index})}>Pay additional payment {index + 1}</Button>
</div>}
</div>;
})}
{travel && <p><strong>{travelTurn === deal.turn ? 'Current-turn travel term:' : 'Travel term:'}</strong> {name(travelActor!)} {deal.status === 'offered' || deal.status === 'declined' || deal.status === 'withdrawn' ? 'would' : 'agrees to'} {travel.answer ? 'make' : 'avoid'} {travel.kind === 'ship' ? 'a reserve shipment' : 'a ground movement'} of at least {travel.minimum} physical forces in one action to {travelDestination ?? travel.territory} during turn {travelTurn}. {travelStatus ? `Travel status: ${travelStatus}.` : deal.status === 'offered' ? 'The term becomes binding on final acceptance.' : deal.status === 'declined' || deal.status === 'withdrawn' ? 'The term did not become binding.' : 'Travel status is unavailable.'}</p>}
{travel && travelTurn !== undefined && travelTurn > deal.turn && <p>Before turn {travelTurn}, this term reserves no forces or spice. Its status and legal options update during that turn.</p>}
{extraTravel.map((term,index) => {
const turn = term.dueTurn ?? deal.turn;
const destination = TERRITORIES.find(territory => territory.id === term.territory)?.name ?? term.territory;
const status = (game as TravelProjection).dealAdditionalTravelStatus?.[deal.id]?.[index];
return <p key={`travel-${index}`}><strong>Additional travel {index + 1}:</strong> {name(term.actor!)} {deal.status === 'offered' || deal.status === 'declined' || deal.status === 'withdrawn' ? 'would' : 'agrees to'} {term.answer ? 'make' : 'avoid'} {term.kind === 'ship' ? 'a reserve shipment' : 'a ground movement'} of at least {term.minimum} physical forces in one action to {destination} during turn {turn}. {status ? `Travel status: ${status}.` : deal.status === 'offered' ? 'The term becomes binding on final acceptance.' : deal.status === 'declined' || deal.status === 'withdrawn' ? 'The term did not become binding.' : 'Travel status is unavailable.'}{turn > deal.turn ? ` Before turn ${turn}, this term reserves no forces or spice.` : ''}</p>;
})}
{travel && extraTravel.length > 0 && participants.length > 2 && deal.status === 'offered' &&
<p>Invited participants without a travel term accept first. Invited travelers may then accept in any order. The proposer consents by making the offer; anyone invited may decline at any time.</p>}
{travel && extraTravel.length === 0 && participants.length > 2 && deal.status === 'offered' && (travelActor === deal.from
? <p>The proposer already consented to their own travel term by making this offer. All invited participants must accept; anyone invited may decline at any time.</p>
: <p>{name(travelActor!)} must accept last, after the other recipients. Anyone invited may decline at any time.</p>)}
{deal.status === 'offered' && <p>
Accepted by {accepted.map(name).join(', ')}. Waiting for {participants.filter(id => !accepted.includes(id)).map(name).join(', ')}.
</p>}
{deal.status === 'offered' && !eligible && <p>Acceptance is unavailable while any participants are allied; the offer may still be declined or withdrawn.</p>}
{deal.status === 'offered' && paymentBlocked && <p>Final acceptance must wait: {paymentBlocked} The offer may still be declined or withdrawn.</p>}
{deal.status === 'offered' && paymentExpired && <p>The payment’s due turn has passed. The offer may still be declined or withdrawn.</p>}
{deal.status === 'offered' && travelExpired && <p>The travel term’s turn has passed. The offer may still be declined or withdrawn.</p>}
{deal.status === 'active' && deal.releaseVotes.length > 0 && <p>
Release requested by {deal.releaseVotes.map(name).join(', ')}. All parties must agree to release the deal.
</p>}
{canAct && deal.status === 'offered' && recipient && <div className="flex flex-wrap gap-2">
{!accepted.includes(game.me) && <Button type="button" disabled={disabled || !eligible || !!paymentBlocked || !!paymentExpired || travelExpired || travelActorWaiting} onClick={() => act({ type: 'dealRespond', deal: deal.id, accept: true })}>Accept deal</Button>}
<Button type="button" variant="outline" disabled={disabled} onClick={() => act({ type: 'dealRespond', deal: deal.id, accept: false })}>Decline deal</Button>
</div>}
{canAct && deal.status === 'offered' && deal.from === game.me && <Button type="button" variant="outline" disabled={disabled}
onClick={() => act({ type: 'dealWithdraw', deal: deal.id })}>Withdraw offer</Button>}
{canAct && deal.status === 'active' && party && <Button type="button" variant="outline" disabled={disabled}
onClick={() => act({ type: 'dealRelease', deal: deal.id, agree: !voted })}>
{voted ? 'Withdraw release request' : deal.releaseVotes.length > 0 ? 'Agree to release deal' : 'Request release of deal'}
</Button>}
{mayPay && <div>
{deferredOption?.blocked && <p>Payment is unavailable: {deferredOption.blocked}</p>}
<Button type="button" disabled={disabled || !deferredOption || !!deferredOption.blocked}
onClick={() => act({ type: 'dealPay', deal: deal.id })}>Pay agreed amount</Button>
</div>}
</li>;
})}
</ol>;
}
export function PublicDeals({ game, act, busy }: {
game: GameView;
act: (action: Action) => void;
busy: boolean;
}) {
const [selected, setSelected] = useState<string[]>([]);
const [terms, setTerms] = useState('');
const [includePayment, setIncludePayment] = useState(false);
const [includeTravel, setIncludeTravel] = useState(false);
const [travelKind, setTravelKind] = useState<'ship' | 'move'>('ship');
const [travelTerritory, setTravelTerritory] = useState('');
const [travelMinimum, setTravelMinimum] = useState('1');
const [travelAnswer, setTravelAnswer] = useState(true);
const [travelActor, setTravelActor] = useState('');
const [paymentKind, setPaymentKind] = useState<'immediateBribe' | 'deferredBribe'>('immediateBribe');
const [payer, setPayer] = useState('');
const [paymentRecipient, setPaymentRecipient] = useState('');
const [paymentAmount, setPaymentAmount] = useState('1');
const [additionalDrafts, setAdditionalDrafts] = useState<AdditionalPaymentDraft[]>([]);
const nextAdditionalKey = useRef(0);
const [additionalImmediateDrafts, setAdditionalImmediateDrafts] = useState<AdditionalImmediateDraft[]>([]);
const nextAdditionalImmediateKey = useRef(0);
const [additionalTravelDrafts, setAdditionalTravelDrafts] = useState<AdditionalTravelDraft[]>([]);
const nextAdditionalTravelKey = useRef(0);
const [deadlineDraft, setDeadlineDraft] = useState(() => ({ value: String(game.turn), turn: game.turn }));
const [travelDeadlineDraft, setTravelDeadlineDraft] = useState(() => ({ value: String(game.turn), turn: game.turn }));
const previousDeadline = Number(deadlineDraft.value);
const paymentDueTurn = deadlineDraft.turn !== game.turn && deadlineDraft.value.trim() !== '' &&
Number.isSafeInteger(previousDeadline) && previousDeadline < game.turn
? String(game.turn) : deadlineDraft.value;
const previousTravelDeadline = Number(travelDeadlineDraft.value);
const travelDueTurn = travelDeadlineDraft.turn !== game.turn && travelDeadlineDraft.value.trim() !== '' &&
Number.isSafeInteger(previousTravelDeadline) && previousTravelDeadline < game.turn
? String(game.turn) : travelDeadlineDraft.value;
const requests = publicDealRequests(game);
const needsResponse = requests.length > 0;
const paymentDue = requests.some(request => request[0] === 'payment');
const travelDue = requests.some(request => request[0] === 'travel');
const requestKey = JSON.stringify(requests);
const panel = useRef<HTMLDetailsElement>(null);
useEffect(() => { if (requestKey !== '[]' && panel.current) panel.current.open = true; }, [requestKey]);
if (game.status !== 'playing' && game.status !== 'finished') return null;
const me = game.players.find(player => player.id === game.me);
const targets = game.players.filter(player => me && player.id !== me.id && !player.bot);
const selectedPlayers = targets.filter(player => selected.includes(player.id));
const legalSelection = !!me && selected.length > 0 && selected.length === selectedPlayers.length &&
selectedPlayers.every((player, index) => !allied(game, me, player) &&
selectedPlayers.slice(index + 1).every(other => !allied(game, player, other)));
const parties = me ? [me, ...selectedPlayers] : [];
const amount = Number(paymentAmount);
const dueTurn = Number(paymentDueTurn);
const dueValid = Number.isSafeInteger(dueTurn) && dueTurn >= game.turn;
const payment: DealPayment | undefined = includePayment
? paymentKind === 'immediateBribe'
? { kind: paymentKind, payer, recipient: paymentRecipient, amount }
: { kind: paymentKind, payer, recipient: paymentRecipient, amount, dueTurn }
: undefined;
const paymentPeopleAndAmountValid = !!me && payer !== paymentRecipient &&
parties.some(player => player.id === payer) && parties.some(player => player.id === paymentRecipient) &&
Number.isSafeInteger(amount) && amount > 0;
const paymentValid = !includePayment || paymentPeopleAndAmountValid && (paymentKind !== 'deferredBribe' || dueValid);
const additionalPayments: DeferredBribe[] = additionalDrafts.map(draft => ({
kind:'deferredBribe', payer:draft.payer, recipient:draft.recipient,
amount:Number(draft.amount), dueTurn:Number(draft.dueTurn),
}));
const additionalImmediatePayments: ImmediateBribe[] = additionalImmediateDrafts.map(draft => ({
kind:'immediateBribe', payer:draft.payer, recipient:draft.recipient, amount:Number(draft.amount),
}));
const travelTurn = Number(travelDueTurn);
const travelDueValid = travelDueTurn.trim() !== '' && Number.isSafeInteger(travelTurn) && travelTurn >= game.turn;
const travel: DealTravel | undefined = includeTravel ? {kind:travelKind, territory:travelTerritory,
minimum:Number(travelMinimum), answer:travelAnswer,
...(selected.length > 1 ? {actor:travelActor} : travelActor === me?.id ? {actor:travelActor} : {}),
...(travelTurn > game.turn ? {dueTurn:travelTurn} : {})} : undefined;
const additionalTravel: DealTravel[] = additionalTravelDrafts.map(draft => ({
actor:draft.actor, kind:draft.kind, territory:draft.territory, minimum:Number(draft.minimum),
answer:draft.answer, dueTurn:Number(draft.dueTurn),
}));
const offer = legalSelection && paymentValid && (!includeTravel || travelDueValid)
? publicDealOfferAction(selected, terms, payment, me?.id, game.turn, travel, additionalPayments, additionalImmediatePayments, additionalTravel) : null;
const disabled = busy || !!game.roomControl?.paused || !!game.roomControl?.closed || !!me?.autopilot;
const mayOffer = game.status === 'playing' && me && !me.bot;
return <details ref={panel} className="notice public-deals-panel">
<summary>Public deals{paymentDue ? ' · payment due' : travelDue ? ' · travel term pending' : needsResponse ? ' · your response requested' : game.deals?.some(deal => deal.status === 'offered' || deal.status === 'active') ? ' · proposals or active deals' : ''}</summary>
<p>Deals are public. Every recipient must accept an offer. Players must honor valid terms; an impossible part is void, and all parties can agree to release a deal. The game records the terms but cannot automatically enforce free-text promises or determine when they become impossible.</p>
<p>Do not trade cards, forces, leaders or faction powers, or make terms that contradict the rules or faction powers. An optional payment uses the ordinary bribe rules; free-text terms do not automatically transfer spice. <a href="/rules?topic=bribes#bribes">Bribe rules</a></p>
{mayOffer && <form onSubmit={event => {
event.preventDefault();
if (!disabled && offer) act(offer);
}}>
<fieldset>
<legend>Deal recipients</legend>
{targets.map(player => {
const checked = selected.includes(player.id);
const conflicts = !!me && (allied(game, me, player) || selectedPlayers.some(other => other.id !== player.id && allied(game, other, player)));
return <label key={player.id} className="checkbox-row">
<input type="checkbox" checked={checked} disabled={disabled || (!checked && conflicts)}
onChange={event => {
const nextChecked = event.target.checked;
if (!nextChecked && travelActor === player.id) setTravelActor('');
setSelected(current => nextChecked
? current.includes(player.id) ? current : [...current, player.id] : current.filter(id => id !== player.id));
}} />
{player.name} · {faction(player.faction).name}{conflicts ? ' (allied with a selected party)' : ''}
</label>;
})}
</fieldset>
<label className="checkbox-row">
<input type="checkbox" checked={includePayment} disabled={disabled}
onChange={event => setIncludePayment(event.target.checked)} />
Include a spice payment
</label>
{includePayment && <fieldset>
<legend>Payment term</legend>
<label>Payment timing
<select value={paymentKind} disabled={disabled} onChange={event =>
setPaymentKind(event.target.value === 'deferredBribe' ? 'deferredBribe' : 'immediateBribe')}>
<option value="immediateBribe">Immediately on final acceptance</option>
<option value="deferredBribe">By the end of a current or future turn</option>
</select>
</label>
<label>Paying participant
<select value={parties.some(player => player.id === payer) ? payer : ''} disabled={disabled}
onChange={event => setPayer(event.target.value)}>
<option value="">Choose a payer</option>
{parties.map(player => <option key={player.id} value={player.id}>{player.name} · {faction(player.faction).name}</option>)}
</select>
</label>
<label>Receiving participant
<select value={parties.some(player => player.id === paymentRecipient) ? paymentRecipient : ''} disabled={disabled}
onChange={event => setPaymentRecipient(event.target.value)}>
<option value="">Choose a recipient</option>
{parties.filter(player => player.id !== payer).map(player => <option key={player.id} value={player.id}>{player.name} · {faction(player.faction).name}</option>)}
</select>
</label>
<label>Gross spice amount
<input type="number" inputMode="numeric" min={1} step={1} value={paymentAmount} disabled={disabled}
onChange={event => setPaymentAmount(event.target.value)} />
</label>
{paymentKind === 'deferredBribe' && <label>Payment due by the end of turn
<input type="number" inputMode="numeric" min={game.turn} step={1} value={paymentDueTurn} disabled={disabled}
required aria-invalid={!dueValid} onChange={event => setDeadlineDraft({ value: event.target.value, turn: game.turn })} />
</label>}
{paymentKind === 'immediateBribe'
? <p className="fine">No spice is reserved before final acceptance. The payer loses the full amount immediately; the recipient collects their share at the next Mentat opening. A Bureaucrat may divert two spice to the bank before the share is allocated. Native payment timing and available funds are checked at final acceptance.</p>
: <p className="fine">After all participants accept, the payer can pay on or before the end of the selected turn while payment remains possible. A separate pay control appears on the active deal; the recipient collects their share at the next Mentat opening. A Bureaucrat may divert two spice to the bank.</p>}
{legalSelection && !paymentPeopleAndAmountValid && <p>Choose two different participants and a positive whole spice amount.</p>}
{paymentKind === 'deferredBribe' && !dueValid && <p role="alert">Choose a whole due turn no earlier than turn {game.turn}.</p>}
</fieldset>}
{additionalImmediateDrafts.map((draft, index) => {
const valid = draft.payer !== draft.recipient && parties.some(player => player.id === draft.payer) &&
parties.some(player => player.id === draft.recipient) && Number.isSafeInteger(Number(draft.amount)) && Number(draft.amount) > 0;
const update = (change: Partial<AdditionalImmediateDraft>) => setAdditionalImmediateDrafts(current =>
current.map(row => row.key === draft.key ? {...row,...change} : row));
return <fieldset key={draft.key}>
<legend>Additional immediate payment {index + 1}</legend>
<label>Paying participant
<select value={parties.some(player => player.id === draft.payer) ? draft.payer : ''} disabled={disabled}
onChange={event => update({payer:event.target.value})}>
<option value="">Choose a payer</option>
{parties.map(player => <option key={player.id} value={player.id}>{player.name} · {faction(player.faction).name}</option>)}
</select>
</label>
<label>Receiving participant
<select value={parties.some(player => player.id === draft.recipient) ? draft.recipient : ''} disabled={disabled}
onChange={event => update({recipient:event.target.value})}>
<option value="">Choose a recipient</option>
{parties.filter(player => player.id !== draft.payer).map(player => <option key={player.id} value={player.id}>{player.name} · {faction(player.faction).name}</option>)}
</select>
</label>
<label>Gross spice amount
<input type="number" inputMode="numeric" min={1} step={1} value={draft.amount} disabled={disabled}
onChange={event => update({amount:event.target.value})} />
</label>
{legalSelection && !valid && <p>Choose two different participants and a positive whole spice amount.</p>}
<Button type="button" variant="outline" disabled={disabled}
onClick={() => setAdditionalImmediateDrafts(current => current.filter(row => row.key !== draft.key))}>Remove immediate payment {index + 1}</Button>
</fieldset>;
})}
<Button type="button" variant="outline" disabled={disabled || additionalImmediateDrafts.length >= 12 || selected.length === 0}
onClick={() => {
const key = nextAdditionalImmediateKey.current++;
setAdditionalImmediateDrafts(current => [...current, {key,payer:'',recipient:'',amount:'1'}]);
}}>Add immediate payment</Button>
{additionalImmediateDrafts.length > 0 && <p className="fine">Immediate payments are processed on final acceptance. A qualifying Bureaucrat may respond to each payment.</p>}
{additionalDrafts.map((draft, index) => {
const valid = draft.payer !== draft.recipient && parties.some(player => player.id === draft.payer) &&
parties.some(player => player.id === draft.recipient) && Number.isSafeInteger(Number(draft.amount)) &&
Number(draft.amount) > 0 && draft.dueTurn.trim() !== '' && Number.isSafeInteger(Number(draft.dueTurn)) &&
Number(draft.dueTurn) >= game.turn;
const update = (change: Partial<AdditionalPaymentDraft>) => setAdditionalDrafts(current =>
current.map(row => row.key === draft.key ? {...row,...change} : row));
return <fieldset key={draft.key}>
<legend>Additional payment {index + 1}</legend>
<label>Paying participant
<select value={parties.some(player => player.id === draft.payer) ? draft.payer : ''} disabled={disabled}
onChange={event => update({payer:event.target.value})}>
<option value="">Choose a payer</option>
{parties.map(player => <option key={player.id} value={player.id}>{player.name} · {faction(player.faction).name}</option>)}
</select>
</label>
<label>Receiving participant
<select value={parties.some(player => player.id === draft.recipient) ? draft.recipient : ''} disabled={disabled}
onChange={event => update({recipient:event.target.value})}>
<option value="">Choose a recipient</option>
{parties.filter(player => player.id !== draft.payer).map(player => <option key={player.id} value={player.id}>{player.name} · {faction(player.faction).name}</option>)}
</select>
</label>
<label>Gross spice amount
<input type="number" inputMode="numeric" min={1} step={1} value={draft.amount} disabled={disabled}
onChange={event => update({amount:event.target.value})} />
</label>
<label>Payment due by the end of turn
<input type="number" inputMode="numeric" min={game.turn} step={1} value={draft.dueTurn} disabled={disabled}
required aria-invalid={!valid} onChange={event => update({dueTurn:event.target.value})} />
</label>
{legalSelection && !valid && <p>Choose two different participants, a positive whole amount and a current or future due turn.</p>}
<Button type="button" variant="outline" disabled={disabled}
onClick={() => setAdditionalDrafts(current => current.filter(row => row.key !== draft.key))}>Remove additional payment {index + 1}</Button>
</fieldset>;
})}
<Button type="button" variant="outline" disabled={disabled || additionalDrafts.length >= 12 || selected.length === 0}
onClick={() => {
const key = nextAdditionalKey.current++;
setAdditionalDrafts(current => [...current, {key,payer:'',recipient:'',amount:'1',dueTurn:String(game.turn)}]);
}}>Add deferred payment</Button>
{additionalDrafts.length > 0 && <p className="fine">Each additional payment has its own deadline and pay control. The recipient collects its share at the next Mentat opening.</p>}
<label className="checkbox-row">
<input type="checkbox" checked={includeTravel} disabled={disabled || !includeTravel && selected.length === 0}
onChange={event => { setIncludeTravel(event.target.checked); if (!event.target.checked) setAdditionalTravelDrafts([]); }} />
Include a travel term
</label>
{!includeTravel && selected.length === 0 && <p className="fine">Select at least one human recipient to add a travel term.</p>}
{includeTravel && <fieldset>
<legend>Travel term</legend>
<p className="fine">This term concerns one physical action during the selected turn. Choose a participant to commit. {additionalTravelDrafts.length ? 'Invited participants without a travel term accept first, then invited travelers may accept in any order.' : 'An invited traveler accepts last after all other recipients.'} A proposer consents to their own travel by making the offer. Written terms remain player-managed.</p>
<p className="fine">A travel term may include an immediate payment or a payment due by the end of a selected turn. Payment and travel may have different participants and turns. The payment recipient collects their share at the next Mentat opening and can use it after collection. All invited parties must accept.</p>
{selected.length > 1 && <label>Committed traveler
<select value={parties.some(player => player.id === travelActor) ? travelActor : ''} disabled={disabled}
onChange={event => setTravelActor(event.target.value)}>
<option value="">Choose a participant</option>
{parties.map(player => <option key={player.id} value={player.id}>{player.name} · {faction(player.faction).name}</option>)}
</select>
</label>}
<p className="fine">Travel terms are available in Basic games with classic factions and no expansions or optional modules. A current-turn term must be possible when accepted. A later-turn term reserves no forces or spice in advance; if no legal completion is found when the travel turn closes, the term may be marked void.</p>
<label>Travel action
<select value={travelKind} disabled={disabled} onChange={event => setTravelKind(event.target.value === 'move' ? 'move' : 'ship')}>
<option value="ship">Reserve shipment</option>
<option value="move">Ground movement</option>
</select>
</label>
<label>Commitment
<select value={travelAnswer ? 'require' : 'avoid'} disabled={disabled} onChange={event => setTravelAnswer(event.target.value === 'require')}>
<option value="require">Make this action</option>
<option value="avoid">Avoid this action</option>
</select>
</label>
<label>Destination territory
<select value={travelTerritory} disabled={disabled} onChange={event => setTravelTerritory(event.target.value)}>
<option value="">Choose a territory</option>
{TERRITORIES.map(territory => <option key={territory.id} value={territory.id}>{territory.name}</option>)}
</select>
</label>
{selected.length === 1 && <label>Committed traveler
<select value={travelActor === me?.id ? travelActor : ''} disabled={disabled}
onChange={event => setTravelActor(event.target.value)}>
<option value="">{selectedPlayers[0]?.name ?? 'Recipient'} · recipient</option>
{me && <option value={me.id}>{me.name} · proposer (you)</option>}
</select>
</label>}
<label>Minimum physical forces in one action
<input type="number" inputMode="numeric" min={1} max={20} step={1} value={travelMinimum} disabled={disabled}
onChange={event => setTravelMinimum(event.target.value)} />
</label>
<label>Travel during turn
<input type="number" inputMode="numeric" min={game.turn} step={1} value={travelDueTurn} disabled={disabled}
required aria-invalid={!travelDueValid} onChange={event => setTravelDeadlineDraft({ value: event.target.value, turn: game.turn })} />
</label>
{!travelDueValid && <p role="alert">Choose a whole travel turn no earlier than turn {game.turn}.</p>}
</fieldset>}
{includeTravel && additionalTravelDrafts.map((draft,index) => {
const valid = parties.some(player => player.id === draft.actor) &&
TERRITORIES.some(territory => territory.id === draft.territory) && draft.minimum.trim() !== '' &&
Number.isSafeInteger(Number(draft.minimum)) && Number(draft.minimum) >= 1 && Number(draft.minimum) <= 20 &&
draft.dueTurn.trim() !== '' && Number.isSafeInteger(Number(draft.dueTurn)) && Number(draft.dueTurn) >= game.turn;
const update = (change:Partial<AdditionalTravelDraft>) => setAdditionalTravelDrafts(current =>
current.map(row => row.key === draft.key ? {...row,...change} : row));
return <fieldset key={draft.key}>
<legend>Additional travel {index + 1}</legend>
<label>Committed traveler
<select value={parties.some(player => player.id === draft.actor) ? draft.actor : ''} disabled={disabled}
onChange={event => update({actor:event.target.value})}>
<option value="">Choose a participant</option>
{parties.map(player => <option key={player.id} value={player.id}>{player.name} · {faction(player.faction).name}</option>)}
</select>
</label>
<label>Travel action
<select value={draft.kind} disabled={disabled} onChange={event => update({kind:event.target.value === 'move' ? 'move' : 'ship'})}>
<option value="ship">Reserve shipment</option><option value="move">Ground movement</option>
</select>
</label>
<label>Commitment
<select value={draft.answer ? 'require' : 'avoid'} disabled={disabled} onChange={event => update({answer:event.target.value === 'require'})}>
<option value="require">Make this action</option><option value="avoid">Avoid this action</option>
</select>
</label>
<label>Destination territory
<select value={draft.territory} disabled={disabled} onChange={event => update({territory:event.target.value})}>
<option value="">Choose a territory</option>
{TERRITORIES.map(territory => <option key={territory.id} value={territory.id}>{territory.name}</option>)}
</select>
</label>
<label>Minimum physical forces in one action
<input type="number" inputMode="numeric" min={1} max={20} step={1} value={draft.minimum} disabled={disabled}
onChange={event => update({minimum:event.target.value})} />
</label>
<label>Travel during turn
<input type="number" inputMode="numeric" min={game.turn} step={1} value={draft.dueTurn} disabled={disabled}
required aria-invalid={!valid} onChange={event => update({dueTurn:event.target.value})} />
</label>
{!valid && <p>Choose a participant, destination, force count and current or future turn.</p>}
<Button type="button" variant="outline" disabled={disabled}
onClick={() => setAdditionalTravelDrafts(current => current.filter(row => row.key !== draft.key))}>Remove additional travel {index + 1}</Button>
</fieldset>;
})}
{includeTravel && <Button type="button" variant="outline" disabled={disabled || additionalTravelDrafts.length >= 12}
onClick={() => {
const key = nextAdditionalTravelKey.current++;
setAdditionalTravelDrafts(current => [...current,{key,actor:'',kind:'ship',territory:'',minimum:'1',answer:true,dueTurn:String(game.turn)}]);
}}>Add travel term</Button>}
<label>Public deal terms
<textarea rows={3} maxLength={500} value={terms} onChange={event => setTerms(event.target.value)} disabled={disabled}
placeholder="Describe the agreement for the table" />
</label>
<p className="fine">Up to 500 characters. Select human recipients who are not allied with each other or with you; AI negotiation is unfinished.</p>
<Button type="submit" disabled={disabled || !offer}>Offer public deal</Button>
{targets.length === 0 && <p>No human recipient is available.</p>}
{selected.length > 0 && !legalSelection && <p>Clear or change any recipient whose seat or alliance is no longer eligible.</p>}
{selected.length > 0 && <Button type="button" variant="outline" disabled={disabled} onClick={() => { setSelected([]); setTravelActor(''); }}>Clear recipients</Button>}
</form>}
<h3>Deal history</h3>
<PublicDealList game={game} act={act} disabled={disabled} />
</details>;
}