/* ═══════════════════════════════════════════════════════
screens-game · Confirm, Session (poker table), Caixa, Result
═══════════════════════════════════════════════════════ */
/* ── Game container ─────────────────────── */
const GameScreen = () => {
const s = useStore();
const game = s.currentGame;
if (!game) return null;
// Always refresh from store games in case state changed
const fresh = s.games.find(x => x.id === game.id) || game;
return (
update({ currentGame: null })}
title={fresh.name}
subtitle={`${fmtDateFull(fresh.date)}${fresh.timeStart ? ' · ' + fresh.timeStart : ''}`}
right={fresh.status === 'open'
?
LIVE
: FECHADA}/>
{fresh.status === 'closed' ? :
s.gameSubTab === 'confirm' ? :
s.gameSubTab === 'session' ? :
s.gameSubTab === 'caixa' ? :
s.gameSubTab === 'result' ? : null}
);
};
const GameTabs = ({ game }) => {
const s = useStore();
const tabs = (game.status === 'closed') ? [{ id: 'result', i: 'chart', l: 'Resultado' }] :
isAdmin()
? [
{ id: 'confirm', i: 'check', l: 'Mesa' },
{ id: 'session', i: 'play', l: 'Sessão' },
{ id: 'caixa', i: 'wallet', l: 'Caixa' },
{ id: 'result', i: 'chart', l: 'Result.' },
]
: [{ id: 'confirm', i: 'check', l: 'Mesa' }];
return (
{tabs.map(t => (
))}
);
};
/* ── CONFIRMACAO ─────────────────────────── */
const ConfirmTab = ({ game }) => {
const s = useStore();
const confirmed = toArr(game.confirmedPlayers);
const waiting = toArr(game.waitingList);
const maxP = game.maxPlayers || 0;
const me = confirmed.find(p => p.uid === s.userUid);
const myWait = waiting.find(p => p.uid === s.userUid);
const limitReached = maxP > 0 && confirmed.length >= maxP;
const myName = getCurrentUserName();
const iAmMens = s.mensalistasList.some(m => m === myName || nameToRankKey(m) === s.userUid);
const confirmMe = async () => {
const entry = { uid: s.userUid, name: myName, confirmedAt: new Date().toISOString() };
const newConfirmed = [...confirmed, entry];
const sess = toArr(game.sessionPlayers);
if (!sess.find(p => p.name === myName)) sess.push(mkPlayer(myName));
await patchGame(game.id, { confirmedPlayers: newConfirmed, sessionPlayers: sess });
toast('Presença confirmada!');
};
const joinWait = async () => {
if (myWait) return;
const wl = [...waiting, { uid: s.userUid, name: myName, requestedAt: new Date().toISOString() }];
await patchGame(game.id, { waitingList: wl });
toast('Adicionado à lista de espera');
};
const cancelMe = async () => {
if (!confirm('Cancelar presença?')) return;
const newConfirmed = confirmed.filter(p => p.uid !== s.userUid);
const sess = toArr(game.sessionPlayers).filter(p => p.name !== me.name);
let wl = toArr(game.waitingList);
if (wl.length > 0 && maxP > 0) {
const promoted = wl.shift();
newConfirmed.push({ uid: promoted.uid, name: promoted.name, confirmedAt: new Date().toISOString(), promotedFromWaiting: true });
if (!sess.find(p => p.name === promoted.name)) sess.push(mkPlayer(promoted.name));
}
await patchGame(game.id, { confirmedPlayers: newConfirmed, sessionPlayers: sess, waitingList: wl });
toast('Presença cancelada');
};
const leaveWait = async () => {
if (!confirm('Sair da lista de espera?')) return;
const wl = waiting.filter(p => p.uid !== s.userUid);
await patchGame(game.id, { waitingList: wl });
toast('Saiu da lista');
};
const adminRemove = async (uid, name) => {
const newConfirmed = confirmed.filter(p => p.uid !== uid);
const sess = toArr(game.sessionPlayers).filter(p => p.name !== name);
await patchGame(game.id, { confirmedPlayers: newConfirmed, sessionPlayers: sess });
};
const adminPromote = async (entry) => {
if (!confirm('Mover ' + entry.name + ' para confirmados?')) return;
const wl = waiting.filter(p => p.uid !== entry.uid);
const newConfirmed = [...confirmed, { uid: entry.uid, name: entry.name, confirmedAt: new Date().toISOString(), promotedFromWaiting: true }];
const sess = toArr(game.sessionPlayers);
if (!sess.find(p => p.name === entry.name)) sess.push(mkPlayer(entry.name));
await patchGame(game.id, { confirmedPlayers: newConfirmed, sessionPlayers: sess, waitingList: wl });
};
return (
EM ABERTO
{fmtDateFull(game.date)}
{game.name}
{game.timeStart &&
{game.timeStart}{game.timeEnd ? ' — ' + game.timeEnd : ''}
}
{game.location && (
{game.location}
)}
{confirmed.length}{maxP > 0 ? ' / ' + maxP : ''} confirmados
{waiting.length > 0 && · {waiting.length} em espera}
{game.notes &&
{game.notes}
}
{/* My status */}
{me ? (
<>
Você está dentro!
) : myWait ? (
<>
Lista de espera — posição {waiting.indexOf(myWait) + 1}
) : limitReached ? (
<>
Vagas esgotadas
) : (
<>
{iAmMens ? 'Confirmar minha presença?' : 'Visitante — entrar na lista?'}
{!iAmMens &&
Mensalistas têm prioridade na mesa.
}
)}
Confirmados
{confirmed.length}{maxP > 0 ? '/' + maxP : ''}
{confirmed.length === 0 && (
Nenhuma confirmação ainda.
)}
{confirmed.map(p => {
const myEntry = p.uid === s.userUid;
return (
{getDisplayName(p.name)} {myEntry && · você}
{p.promotedFromWaiting && 🔼}
{isAdmin() && !myEntry && (
)}
);
})}
{waiting.length > 0 && (
<>
Lista de espera
{waiting.length}
{waiting.map((p, i) => (
{i + 1}º
{getDisplayName(p.name)}
{isAdmin() ? (
<>
) : }
))}
)}
{isAdmin() &&
}
);
};
const AdminAddPlayer = ({ game, confirmed }) => {
const s = useStore();
const [name, setName] = useState('');
const [sel, setSel] = useState('');
const confirmedNames = confirmed.map(c => c.name);
const added = new Set();
const opts = [];
s.allUsers.slice().sort((a, b) => (a.displayName || a.email).localeCompare(b.displayName || b.email))
.filter(u => !u.disabled).forEach(u => {
const disp = u.displayName || ((u.email || '').split('@')[0]);
if (!confirmedNames.includes(disp) && !added.has(disp)) { added.add(disp); opts.push({ value: disp, label: disp }); }
});
s.mensalistasList.forEach(n => {
if (!confirmedNames.includes(n) && !added.has(n)) { added.add(n); opts.push({ value: n, label: n }); }
});
const doAdd = async () => {
const n = (name.trim() || sel).trim();
if (!n) { toast('Selecione ou digite um nome', 'error'); return; }
if (confirmedNames.includes(n)) { toast(n + ' já está confirmado', 'error'); return; }
const entry = { uid: 'admin_' + genId().slice(0, 6), name: n, confirmedAt: new Date().toISOString(), addedByAdmin: true };
const sess = toArr(game.sessionPlayers);
if (!sess.find(p => p.name === n)) sess.push(mkPlayer(n));
await patchGame(game.id, {
confirmedPlayers: [...confirmed, entry],
sessionPlayers: sess,
});
setName(''); setSel('');
toast(n + ' adicionado');
};
return (
);
};
/* ── SESSION (poker table view) ────────── */
const SessionTab = ({ game }) => {
const s = useStore();
const players = toArr(game.sessionPlayers);
const [activeIdx, setActiveIdx] = useState(0);
const gv = gameValues(game);
const totalEntries = players.reduce((s, p) => s + (p.buyins || 1), 0);
const prize = totalEntries * gv.ret;
const active = players[activeIdx];
if (players.length === 0) {
return (
Nenhum participante na mesa.
Vá em Mesa para adicionar.
{isAdmin() && (
)}
);
}
const adjustBuyins = async delta => {
const upd = [...players];
upd[activeIdx] = { ...upd[activeIdx], buyins: Math.max(1, (upd[activeIdx].buyins || 1) + delta) };
await debouncedSave(clubPath('/games/' + game.id + '.json'), { ...game, sessionPlayers: upd });
const idx = findIdx(S.games, x => x.id === game.id);
if (idx >= 0) S.games[idx].sessionPlayers = upd;
if (S.currentGame?.id === game.id) S.currentGame.sessionPlayers = upd;
notify();
};
const toggleBust = async () => {
const upd = [...players];
const cur = upd[activeIdx];
if (cur.bustedAt) upd[activeIdx] = { ...cur, bustedAt: null };
else upd[activeIdx] = { ...cur, bustedAt: (game.bustOrder || 0) + 1 };
const patch = { sessionPlayers: upd, bustOrder: cur.bustedAt ? (game.bustOrder || 0) : (game.bustOrder || 0) + 1 };
await patchGame(game.id, patch);
toast(cur.bustedAt ? `${cur.name} reativado` : `${cur.name} eliminado 💀`);
};
return (
<>
ATIVOS
!p.bustedAt).length}/>
/{players.length}
{active && (
{getDisplayName(active.name)}
{active.bustedAt && ELIMINADO}
Inv:
{fmtBRL((active.buyins || 1) * gv.cv)}
·
Pilha:
{fmtBRL(chipValue(active.chips || {}))}
{isAdmin() && (
BUY-INS / REBUYS
{active.buyins || 1}
)}
)}
);
};
/* ── Poker table view ──────────────────── */
const PokerTable = ({ players, gv, onPlayerTap, activeIdx }) => {
const arrangement = players.slice(0, 10);
const positions = n => {
const pts = [];
for (let i = 0; i < n; i++) {
const angle = (i / n) * Math.PI * 2 - Math.PI / 2;
const a = 84, b = 78;
pts.push({ x: 50 + (a * Math.cos(angle)) / 2, y: 50 + (b * Math.sin(angle)) / 2 });
}
return pts;
};
const slots = positions(arrangement.length);
const totalChipsInPlay = arrangement.reduce((s, p) => s + chipValue(p.chips || {}), 0);
return (
POT
{arrangement.filter(p => !p.bustedAt).length} ativos
{[0, 1, 2].map(i => (
))}
{arrangement.map((p, i) => {
const slot = slots[i];
const busted = !!p.bustedAt;
const stack = chipValue(p.chips || {});
const active = i === activeIdx;
return (
);
})}
);
};
/* ── CAIXA · counting chips ─────────────── */
const CaixaTab = ({ game }) => {
const players = toArr(game.sessionPlayers);
const setChip = (idx, key, val) => {
const upd = [...players];
const chips = { ...(upd[idx].chips || mkBlankChips()) };
chips[key] = Math.max(0, Number(val) || 0);
upd[idx] = { ...upd[idx], chips };
debouncedSave(clubPath('/games/' + game.id + '.json'), { ...game, sessionPlayers: upd });
const gidx = findIdx(S.games, x => x.id === game.id);
if (gidx >= 0) S.games[gidx].sessionPlayers = upd;
if (S.currentGame?.id === game.id) S.currentGame.sessionPlayers = upd;
notify();
};
return (
Valores das fichas
{CHIP_DEFS.map(c => (
))}
{players.map((p, i) => {
const total = chipValue(p.chips || {});
const gv = gameValues(game);
const invested = (p.buyins || 1) * gv.cv;
const profit = total - invested;
return (
{getDisplayName(p.name)} {p.bustedAt && 💀}
{p.buyins || 1}x · {fmtBRL(invested)} inv.
= 0 ? 'var(--neon)' : 'var(--red-1)' }}>
{profit >= 0 ? '+' : ''}{fmtBRL(profit)}
{CHIP_DEFS.map(c => (
))}
);
})}
);
};
/* ── RESULT (open game / preview) ──────── */
const ResultTab = ({ game }) => {
const s = useStore();
const [showConfetti, setShowConfetti] = useState(false);
const [busy, setBusy] = useState(false);
const [quebra, setQuebra] = useState(game.quebraRetencao);
const gv = gameValues(game);
const players = toArr(game.sessionPlayers).map(p => ({
...p,
stack: chipValue(p.chips || {}),
invested: (p.buyins || 1) * gv.cv,
lp: chipValue(p.chips || {}) - (p.buyins || 1) * gv.cv,
pay: chipValue(p.chips || {}) - (p.buyins || 1) * gv.buyin,
}));
const active = players.filter(p => !p.bustedAt).sort((a, b) => {
const roeA = a.invested > 0 ? a.lp / a.invested * 100 : 0;
const roeB = b.invested > 0 ? b.lp / b.invested * 100 : 0;
if (Math.abs(roeB - roeA) > 0.01) return roeB - roeA;
return b.invested - a.invested;
});
const busted = players.filter(p => !!p.bustedAt).sort((a, b) => a.bustedAt - b.bustedAt);
const ranked = active.concat(busted);
const totalE = players.reduce((s, p) => s + (p.buyins || 1), 0);
const prize = totalE * gv.ret;
const prizeRanking = Math.round(prize * s.prizeSplitRanking / 100 * 100) / 100;
const prizeFinal = Math.round(prize * s.prizeSplitFinal / 100 * 100) / 100;
const totalChipsIn = players.reduce((s, p) => s + p.invested, 0);
const totalChipsOut = players.reduce((s, p) => s + p.stack, 0);
const calcQuebra = Math.round((totalChipsIn - totalChipsOut) * 100) / 100;
/* settlement */
const payers = ranked.filter(p => p.pay < -0.01).map(p => ({ name: p.name, amt: -p.pay }));
const recvs = ranked.filter(p => p.pay > 0.01).map(p => ({ name: p.name, amt: p.pay }));
const txs = [];
let pi = 0, ri = 0;
while (pi < payers.length && ri < recvs.length) {
const a = Math.min(payers[pi].amt, recvs[ri].amt);
if (a > 0.01) txs.push({ from: payers[pi].name, to: recvs[ri].name, amt: a });
payers[pi].amt -= a; recvs[ri].amt -= a;
if (payers[pi].amt < 0.01) pi++;
if (recvs[ri].amt < 0.01) ri++;
}
const closeAndRegister = async () => {
if (!confirm('Fechar partida e registrar pontuação no ranking?')) return;
setBusy(true);
let totalInv = 0, prz = 0;
let mensPos = 0;
const closedPs = ranked.map((p, i) => {
const rawName = resolveAlias(p.name || '');
const key = nameToRankKey(rawName);
const isMens = S.mensalistasList.some(m => {
const mk = nameToRankKey(m);
return mk === key || m === rawName || m === p.name || mk === S.allUsers.find(u => u.displayName === p.name)?.uid;
});
const pts = isMens ? (mensPos < PTS.length ? PTS[mensPos] : 0) : 0;
if (isMens) mensPos++;
totalInv += p.invested;
prz += (p.buyins || 1) * gv.ret;
return {
name: p.name,
uid: key !== p.name ? key : undefined,
buyins: p.buyins || 1, position: i + 1,
profit: p.lp, cashout: p.stack, invested: p.invested,
points: pts, isMensalista: isMens,
roe: p.invested > 0 ? p.lp / p.invested * 100 : 0,
bustedAt: p.bustedAt || null,
};
});
try {
await closeGame(game, closedPs, prz, totalInv, quebra != null ? Number(quebra) : calcQuebra);
setShowConfetti(true);
toast('Partida fechada! Pontuação registrada 🏆');
} catch (e) { toast('Erro ao fechar: ' + e.message, 'error'); }
setBusy(false);
};
if (ranked.length === 0) {
return (
Adicione jogadores na Mesa para ver o resultado.
);
}
const champion = ranked[0];
return (
{/* Champion */}
Líder atual
{getDisplayName(champion.name)}
STACK
{fmtBRL(champion.stack || 0)}
L/P
= 0 ? 'var(--neon)' : 'var(--red-1)', fontSize: 14, fontWeight: 700 }}>
{champion.lp >= 0 ? '+' : ''}{fmtBRL(champion.lp)}
{/* Split */}
{/* Quebra de retenção */}
{isAdmin() && (
Quebra de retenção
Distribuído: {fmtBRL(totalChipsIn)} · Recolhido: {fmtBRL(totalChipsOut)}
setQuebra(e.target.value)}
style={{ width: 90, padding: '6px 8px', textAlign: 'center' }}/>
)}
{/* Ranking */}
Classificação
{(() => {
let mensIdx = 0;
return ranked.map((p, i) => {
const rawName = resolveAlias(p.name || '');
const key = nameToRankKey(rawName);
const isMens = S.mensalistasList.some(m => {
const mk = nameToRankKey(m);
return mk === key || m === rawName || m === p.name;
});
const mr = isMens ? mensIdx++ : -1;
return ;
});
})()}
{/* Settlements */}
{txs.length > 0 && (
<>
Acertos da mesa
{txs.length}
{txs.map((t, i) => (
{(getDisplayName(t.from) || '').split(' ')[0]}
{' -> '}
{(getDisplayName(t.to) || '').split(' ')[0]}
{fmtBRL(t.amt)}
))}
)}
);
};
const ResultRow = ({ p, i, gv }) => {
const isWin = p.lp > 0.01;
const isLoss = p.lp < -0.01;
const top = i < 3 && !p.bustedAt;
const colors = ['var(--gold-1)', '#c2c2c2', '#c87030'];
const medal = top ? ['🥇', '🥈', '🥉'][i] : p.bustedAt ? '💀' : `${i + 1}º`;
// Correct pts: use stored value if available, else compute from mensRank
const isMens = p.isMensalista != null ? p.isMensalista : (() => {
const raw = resolveAlias(p.name || ''); const key = nameToRankKey(raw);
return S.mensalistasList.some(m => { const mk = nameToRankKey(m); return mk === key || m === raw || m === p.name; });
})();
const pts = p.points != null ? p.points :
(isMens && p.mensRank != null && p.mensRank >= 0 && p.mensRank < PTS.length ? PTS[p.mensRank] : 0);
return (
{medal}
{getDisplayName(p.name)}
{p.buyins || 1}x ent.
{isMens
? {pts} pts
: CONVIDADO
}
{p.lp >= 0 ? '+' : ''}{fmtBRL(p.lp)}
L/P
);
};
/* ── RESULT (closed game) ──────────────── */
const ResultClosedTab = ({ game }) => {
const gv = gameValues(game);
const closed = toArr(game.closedPlayers);
const active = closed.filter(p => !p.bustedAt);
const busted = closed.filter(p => !!p.bustedAt).sort((a, b) => a.bustedAt - b.bustedAt);
const rawPlayers = active.concat(busted);
const totalEntries = rawPlayers.reduce((s, p) => s + (p.buyins || 1), 0);
const colors = ['var(--gold-1)', '#c2c2c2', '#c87030'];
// Recompute mensalista-aware points (fixes games closed before convidado fix)
let mensIdx = 0;
const players = rawPlayers.map(p => {
const rawName = resolveAlias(p.name || '');
const key = p.uid || nameToRankKey(rawName); // uid stored on close = resilient to name changes
const isMens = p.isMensalista != null ? p.isMensalista :
S.mensalistasList.some(m => { const mk = nameToRankKey(m); return mk === key || m === rawName || m === p.name; });
const pts = isMens ? (mensIdx < PTS.length ? PTS[mensIdx] : 0) : 0;
if (isMens) mensIdx++;
return { ...p, _isMens: isMens, _pts: pts };
});
return (
{game.quebraRetencao != null && (
)}
Classificação final
{players.map((p, i) => {
const invested = p.invested || (p.buyins || 1) * gv.cv;
const cashout = p.cashout != null ? p.cashout : (p.profit || 0) + invested;
const roe = invested > 0 ? (p.profit || 0) / invested * 100 : 0;
const pay = cashout - (p.buyins || 1) * gv.buyin;
const top = i < 3 && !p.bustedAt;
const medal = top ? ['🥇', '🥈', '🥉'][i] : p.bustedAt ? '💀' : `${i + 1}º`;
// Determine mensalista status
const isMens = p._isMens;
const pts = p._pts;
const rawName = resolveAlias(p.name || '');
const key = nameToRankKey(rawName);
const avatarSrc = getUserAvatar(key) || getUserAvatar(p.name);
return (
= 0 ? 'var(--neon)' : 'var(--red)') : 'var(--border)'}`,
opacity: p.bustedAt ? 0.8 : 1,
background: top && !p.bustedAt ? `${colors[i]}0a` : 'var(--surface)',
}}>
{/* Header */}
{medal}
{getDisplayName(p.name)}
{(p.buyins || 1)}x entrada{(p.buyins || 1) > 1 ? 's' : ''} · {fmtBRL(invested)} inv.
{isMens ? (
{pts} pts
) : (
CONVIDADO
)}
{/* Stats grid 2×3 */}
{[
{ label: 'FICHAS INV', val: fmtBRL(invested), color: 'var(--ink-2)' },
{ label: 'CASHOUT', val: fmtBRL(cashout), color: cashout > invested ? 'var(--neon)' : 'var(--red-1)' },
{ label: 'L/P', val: (p.profit >= 0 ? '+' : '') + fmtBRL(p.profit || 0), color: (p.profit || 0) >= 0 ? 'var(--neon)' : 'var(--red-1)' },
{ label: 'ROE', val: (roe >= 0 ? '+' : '') + Math.round(roe) + '%', color: roe >= 0 ? 'var(--neon)' : 'var(--red-1)' },
{ label: 'PAGAR/REC', val: (pay >= 0 ? '+' : '') + fmtBRL(pay), color: pay >= 0 ? 'var(--neon)' : 'var(--red-1)' },
{ label: 'ENTRADAS', val: (p.buyins || 1) + 'x', color: 'var(--ink-2)' },
].map(cell => (
))}
);
})}
);
};
/* ── Share QR Sheet ───────────────────── */
const ShareQRSheet = () => {
const s = useStore();
const club = s.clubInfo;
if (!club) return null;
return (
update({ sheet: null })}>
Convide para o clube
{club.name}
Compartilhe esse código com amigos.
);
};
Object.assign(window, {
GameScreen, GameTabs, ConfirmTab, SessionTab, CaixaTab, ResultTab, ResultClosedTab,
PokerTable, AdminAddPlayer, ResultRow, ShareQRSheet,
});