489 lines
38 KiB
TypeScript
489 lines
38 KiB
TypeScript
'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 };
|
||
type TravelProjection = GameView & { dealTravelStatus?: Record<string, DealTravelStatus> };
|
||
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);
|
||
}
|
||
|
||
/** 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 waitingForOtherVotes = !!travel && parties.length > 2 && publicDealTravelActor(deal) === game.me &&
|
||
parties.some(id => id !== game.me && !accepted.includes(id));
|
||
if (deal.status === 'offered' && participant && deal.from !== game.me && !accepted.includes(game.me)) {
|
||
const groupTraveler = !!travel && parties.length > 2 && publicDealTravelActor(deal) === 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]);
|
||
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[]): 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' || !targets.includes(travel.actor) :
|
||
travelKeys !== 'answer,kind,minimum,territory') ||
|
||
(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;
|
||
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 } : {};
|
||
return targets.length === 1
|
||
? { type: 'dealOffer', target: targets[0], terms: text, ...offeredPayment, ...offeredAdditional, ...offeredImmediate, ...offeredTravel }
|
||
: { type: 'dealOffer', targets: [...targets], terms: text, ...offeredPayment, ...offeredAdditional, ...offeredImmediate, ...offeredTravel };
|
||
}
|
||
|
||
/** 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 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;
|
||
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 = !!travel && participants.length > 2 && game.me === travelActor &&
|
||
participants.some(participant => participant !== travelActor && !accepted.includes(participant));
|
||
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>}
|
||
{travel && participants.length > 2 && deal.status === 'offered' && <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 [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} : {}),
|
||
...(travelTurn > game.turn ? {dueTurn:travelTurn} : {})} : undefined;
|
||
const offer = legalSelection && paymentValid && (!includeTravel || travelDueValid)
|
||
? publicDealOfferAction(selected, terms, payment, me?.id, game.turn, travel, additionalPayments, additionalImmediatePayments) : 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)} />
|
||
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. The sole recipient commits to travel in a two-party deal. In a group deal, choose one recipient to commit; they accept last after all other recipients. 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 accept before the traveler gives final consent.</p>
|
||
{selected.length > 1 && <label>Committed traveler
|
||
<select value={selected.includes(travelActor) ? travelActor : ''} disabled={disabled}
|
||
onChange={event => setTravelActor(event.target.value)}>
|
||
<option value="">Choose a recipient</option>
|
||
{selectedPlayers.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>
|
||
<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>}
|
||
<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>;
|
||
}
|