{Math.max(0, Math.ceil(hp))}

{sPct > 0 &&

}

); } function MetaRow({ energy, poison, shield, side, canChallenge, onChallenge, isThinking, actions, tutHighlightFn }) { const th = tutHighlightFn || (() => ({})); return (

{Math.round(energy)}/100

{side === 'player' && canChallenge && ( )} {side === 'player' && !canChallenge && ( need full candles )} {side === 'cpu' && isThinking && ( ⚠ ready to raise )}

); } function HandPlate({ holes, community, faceDown }) { if (faceDown || holes.length < 2 || holes.length + community.length < 5) { return (

YOUR BEST

—

DAMAGE

—

); } const ev = Poker.evaluateBest([...holes, ...community]); return (

YOUR BEST

{Poker.HAND_NAME[ev.rank]}

DAMAGE

{Poker.HAND_DAMAGE[ev.rank]}

); } function CommunityRow({ community, bestSet, onTap }) { return (

{Array.from({length: 5}).map((_, i) => { const c = community[i]; if (!c) return

; return ( onTap(c)} /> ); })}

); } // ============================================================================ // Main combat // ============================================================================ const STREET_WINDOW_SECONDS = 10; function ActionRow({ secondsLeft, playerAttackUsed, playerBlockUsed, playerCommit, onAttack, onBlock, gapPositive, tutHighlightFn }) { const th = tutHighlightFn || (() => ({})); const attackDisabled = playerAttackUsed || playerCommit.attack || !gapPositive; const blockDisabled = playerBlockUsed || playerCommit.block; return (

); } function CombatScreen({ persona = 'gambler', playerProfile, onGameOver, onExit, scriptedDeck, scriptedPlayerEnergy, scriptedCpuEnergy, cpuScript, // used in timer interval and respondCpu (wired in next task) tutorialStep, onTutorialAdvance, }) { const [state, setState] = cUseState(() => { const s = makeInitialCombatState( persona, playerProfile?.name || 'You', playerProfile?.title || 'cold hand', playerProfile?.key || 'drifter', ); if (scriptedPlayerEnergy != null) s.playerEnergy = scriptedPlayerEnergy; if (scriptedCpuEnergy != null) s.cpuEnergy = scriptedCpuEnergy; return s; }); const [showBetModal, setShowBetModal] = cUseState(false); const [hitFlash, setHitFlash] = cUseState({ player: false, cpu: false }); const [floats, setFloats] = cUseState([]); const [showBeam, setShowBeam] = cUseState(false); const floatId = cUseRef(0); const tutorialStepRef = cUseRef(tutorialStep); cUseEffect(() => { tutorialStepRef.current = tutorialStep; }, [tutorialStep]); const tutHighlight = (key) => { if (!tutorialStep || tutorialStep.highlight !== key) return {}; return { position: 'relative', zIndex: 51, boxShadow: '0 0 0 9999px rgba(15,8,4,0.82)', }; }; cUseEffect(() => { if (state.phase === 'gameOver' && onGameOver) { const t = setTimeout(() => onGameOver(state.gameWinner, state), 1800); return () => clearTimeout(t); } }, [state.phase]); cUseEffect(() => { if (!state.events || state.events.length === 0) return; const newFloats = []; const flashes = { player: false, cpu: false }; for (const ev of state.events) { if (ev.kind === 'damage') flashes[ev.side] = true; const id = ++floatId.current; newFloats.push({ id, value: ev.value, kind: ev.kind, side: ev.side }); } setHitFlash(flashes); setFloats(f => [...f, ...newFloats]); const t = setTimeout(() => setHitFlash({ player: false, cpu: false }), 500); return () => clearTimeout(t); }, [state.events]); const removeFloat = id => setFloats(f => f.filter(x => x.id !== id)); // ---------- Actions ---------- const onContinueRound = () => { setState(s => ({ ...s, phase: 'preDeal', lastEval: null, foldedRound: null, events: [], })); setTimeout(() => setState(s => s.phase === 'preDeal' ? COMBAT.startRound(s) : s), 250); }; const maybeCpuBet = () => { setTimeout(() => { setState(s => { if (s.bet) return s; if (s.cpuEnergy < COMBAT.CHALLENGE_COST) return s; if (s.hasBet) return s; if (Math.random() < 0.35) return s; const decision = CPU.cpuInitiateBet(s, CPU.CPU_PERSONAS[s.cpuKey]); if (decision.action === 'pass') return s; return COMBAT.initiateBet(s, 'cpu', Math.min(decision.amount, s.cpuHP - 1, s.playerHP - 1)); }); }, 800); }; const onChallenge = () => { setShowBetModal(true); if (tutorialStep?.waitFor === 'challenge-click') onTutorialAdvance?.(); }; const onBetCommit = (amount) => { setShowBetModal(false); setState(s => COMBAT.initiateBet(s, 'player', Math.min(amount, s.playerHP - 1, s.cpuHP - 1))); setTimeout(() => respondCpu(), 1400); if (tutorialStep?.waitFor === 'bet-commit') onTutorialAdvance?.(); }; const onBetCancel = () => setShowBetModal(false); const onCall = () => setState(s => COMBAT.callBet(s)); const onFold = () => setState(s => COMBAT.foldBet(s)); const onRaise = (amount) => { setState(s => COMBAT.raiseBet(s, amount)); setTimeout(() => respondCpu(), 1400); }; const respondCpu = () => { setState(s => { if (!s.bet || s.bet.awaiting !== 'cpu') return s; const cpuPhaseScript = cpuScript?.find(sc => sc.phase === s.phase); if (cpuPhaseScript?.betResponse === 'call') return COMBAT.callBet(s); if (cpuPhaseScript?.betResponse === 'fold') return COMBAT.foldBet(s); const decision = CPU.cpuRespondBet(s, s.bet.currentRaise, CPU.CPU_PERSONAS[s.cpuKey]); if (decision.action === 'fold') return COMBAT.foldBet(s); if (decision.action === 'call') return COMBAT.callBet(s); if (decision.action === 'raise') return COMBAT.raiseBet(s, decision.amount); return s; }); }; cUseEffect(() => { if (state.bet && state.bet.awaiting === 'cpu' && !state.bet.resolved) { const t = setTimeout(respondCpu, 1500); return () => clearTimeout(t); } }, [state.bet?.awaiting, state.bet?.raises]); const [secondsLeft, setSecondsLeft] = cUseState(STREET_WINDOW_SECONDS); const cpuActionPickedAt = cUseRef(null); const streetResolvedRef = cUseRef(false); // Reset resolved flag at start of each new street. cUseEffect(() => { streetResolvedRef.current = false; }, [state.phase]); // Pick CPU commit once per street, at a random offset within the window. cUseEffect(() => { if (!['preFlop','flop','turn','river'].includes(state.phase)) return; if (state.bet && !state.bet.resolved) return; // pause only while bet is pending setSecondsLeft(STREET_WINDOW_SECONDS); cpuActionPickedAt.current = (Math.random() * 6) + 1; // pick between 1s and 7s const interval = setInterval(() => { const ts = tutorialStepRef.current; // Freeze timer when tutorial is waiting for a player action if (ts && ts.waitFor !== 'auto') return; setSecondsLeft(prev => { // Fast-forward during auto steps so the window closes in ~1s const decrement = (ts?.waitFor === 'auto') ? 1.0 : 0.1; const next = prev - decrement; if (cpuActionPickedAt.current != null && next <= cpuActionPickedAt.current) { const cpuPhaseScript = cpuScript?.find(sc => sc.phase === state.phase); const choice = cpuPhaseScript ? { attack: cpuPhaseScript.attack, block: cpuPhaseScript.block } : CPU.cpuDecideActions(state, CPU.CPU_PERSONAS[state.cpuKey] || CPU.CPU_PERSONAS.gambler); setState(s => ({ ...s, cpuCommit: { attack: choice.attack && !s.cpuAttackUsed, block: choice.block && !s.cpuBlockUsed, }, })); cpuActionPickedAt.current = null; } if (next <= 0) { clearInterval(interval); resolveStreet(); return 0; } return next; }); }, 100); return () => clearInterval(interval); }, [state.phase, state.bet]); const resolveStreet = () => { streetResolvedRef.current = true; setState(s => { const resolved = COMBAT.resolveActions(s); // Advance to next street after resolve if (resolved.phase === 'gameOver') return resolved; if (s.phase === 'preFlop') return { ...COMBAT.dealCommunity(resolved, 3), phase: 'flop' }; if (s.phase === 'flop') return { ...COMBAT.dealCommunity(resolved, 1), phase: 'turn' }; if (s.phase === 'turn') return { ...COMBAT.dealCommunity(resolved, 1), phase: 'river' }; if (s.phase === 'river') { // River → showdown after small reveal delay setShowBeam(true); setTimeout(() => setShowBeam(false), 800); setTimeout(() => setState(s2 => COMBAT.resolveShowdown(s2)), 700); return { ...resolved, phase: 'showdown' }; } return resolved; }); }; const onPlayerAttack = () => { if (streetResolvedRef.current) return; setState(s => { if (s.playerAttackUsed || s.playerCommit.attack) return s; if (s.playerStrength <= s.cpuStrength) return s; return { ...s, playerCommit: { ...s.playerCommit, attack: true } }; }); if (tutorialStep?.waitFor === 'attack-click') onTutorialAdvance?.(); }; const onPlayerBlock = () => { if (streetResolvedRef.current) return; setState(s => { if (s.playerBlockUsed || s.playerCommit.block) return s; return { ...s, playerCommit: { ...s.playerCommit, block: true } }; }); if (tutorialStep?.waitFor === 'block-click') onTutorialAdvance?.(); }; // ---------- Derived ---------- const inActiveHand = ['preFlop','flop','turn','river'].includes(state.phase); const canChallenge = state.playerEnergy >= COMBAT.CHALLENGE_COST && inActiveHand && !state.hasBet && !state.bet; const cpuChallengingPlayer = state.bet && state.bet.awaiting === 'player'; const cpuAwaiting = state.bet && state.bet.awaiting === 'cpu'; const showResult = state.phase === 'roundEnd' || (state.phase === 'gameOver' && state.lastEval) || state.foldedRound; const revealCpuCards = state.phase === 'showdown' || state.phase === 'roundEnd' || state.phase === 'gameOver'; const bestSet = cUseMemo(() => { if (!state.lastEval) return new Set(); return new Set(state.lastEval.winnerEval?.cards || []); }, [state.lastEval]); const cpuName = cpuDisplayName(state.cpuKey); const cpuFlag = cpuFlagWord(state.cpuKey); const cpuSub = cpuSubtitle(state.cpuKey); const plFlag = playerFlagWord(state.playerKey); return (

ROUND {romanRound(Math.max(1, state.round))}

{/* ===================== OPPONENT ZONE ===================== */}

= COMBAT.CHALLENGE_COST && !state.hasBet} actions={(state.cpuAttackUsed ? 0 : 1) + (state.cpuBlockUsed ? 0 : 1)} />

— {cpuFlag} —

{cpuName}

{cpuSub}

{state.cpuHole.length === 0 ? ( <>

) : ( state.cpuHole.map((c, i) => ( )) )} {floats.filter(f => f.side === 'cpu').map(f => ( removeFloat(f.id)} /> ))}

{/* ===================== CENTER STAGE ===================== */}

{showBeam &&

}

{phaseTitleText(state.phase, state.bet)}

— {romanRound(state.round)} —

{state.bet ? (

{state.bet.pot} HP

{state.bet.initiator === 'player' ? 'YOU CALLED' : `${cpuName.toUpperCase()} CALLED`}

) : ( )} {}} />

{/* ===================== PLAYER ZONE ===================== */}

{state.playerHole.length === 0 ? ( <>

) : ( state.playerHole.map((c, i) => ( )) )} {floats.filter(f => f.side === 'player').map(f => ( removeFloat(f.id)} /> ))}

— {plFlag} —

{state.playerName}

{state.playerTitle}

{/* ===================== ACTION ===================== */} {state.phase === 'preDeal' && !state.bet && !showResult && ( )} {inActiveHand && (!state.bet || state.bet.resolved) && !showResult && ( state.cpuStrength} tutHighlightFn={tutHighlight} /> )} {/* Modals */} {showBetModal && } {cpuChallengingPlayer && ( )} {cpuAwaiting && state.bet.initiator === 'player' && ( )} {showResult && state.phase !== 'gameOver' && ( )}

); } function romanRound(n) { const map = ['Ø','I','II','III','IV','V','VI','VII','VIII','IX','X','XI','XII','XIII','XIV','XV','XVI','XVII','XVIII','XIX','XX']; return map[Math.min(n, 20)] || String(n); } Object.assign(window, { CombatScreen, makeInitialCombatState, cpuSubtitle, cpuDisplayName });