Ilia Denisov
12d128f1cc
CI / changes (pull_request) Successful in 2s
CI / unit (pull_request) Successful in 9s
CI / integration (pull_request) Successful in 16s
CI / ui (pull_request) Successful in 49s
CI / gate (pull_request) Successful in 0s
CI / deploy (pull_request) Successful in 1m21s
The "waiting for your move" popup was the nudge (chat.nudge), shown without a
sender name. Resolve the nudger's per-game seat name server-side and carry it on
a new NudgeEvent.sender_name field, so:
- the in-app toast reads "<opponent>: Waiting for your move 🤭" (chat.nudgeBy);
- the out-of-app Telegram push names the sender too (render nudgeBy);
falling back to the plain phrase when the name is absent (RU mirrored). The
your_turn toast already named the opponent and is unchanged.
Lobby: when a card transitions into "your turn" or "finished" while the lobby is
open, its status emoji blinks twice (two 1s fades); the opponent's-turn change
stays in place. Blink state is keyed by game id (SvelteSet + per-id nonce/timer)
so overlapping events animate in isolation; suppressed under reduce-motion.
Toast: a per-message seq re-keys Toast.svelte, so the freshest toast cancels the
previous one and replays its entrance, uniformly on every screen.
Tests: notify.Nudge round-trip + render named/fallback (Go), game.Service.SeatName
(integration), codec/i18n/gamePhase/shouldBlink (UI). Docs (FUNCTIONAL +_ru,
UI_DESIGN) + PLAN TODO-7 (deferred FLIP card-relocation animation) updated.
64 lines
2.9 KiB
TypeScript
64 lines
2.9 KiB
TypeScript
// Pure grouping + ordering of the lobby's game list. The lobby shows three
|
|
// sections — games awaiting the caller's move, games awaiting the opponent, and finished
|
|
// games — each ordered by last activity: your-turn oldest-first (the longest-neglected on
|
|
// top), the other two newest-first.
|
|
|
|
import type { GameView } from './model';
|
|
|
|
/** isMyTurn reports whether an active game's seat-to-move belongs to the caller. */
|
|
export function isMyTurn(game: GameView, myId: string): boolean {
|
|
const me = game.seats.find((s) => s.accountId === myId);
|
|
// 'open' (an auto-match game still awaiting an opponent) is in progress like 'active'.
|
|
return (game.status === 'active' || game.status === 'open') && !!me && game.toMove === me.seat;
|
|
}
|
|
|
|
/** LobbyPhase is a game's lobby bucket — which of the three card sections it currently sits in. */
|
|
export type LobbyPhase = 'mine' | 'theirs' | 'finished';
|
|
|
|
/**
|
|
* gamePhase reports a game's lobby bucket for myId: 'finished' for any non-active/open status,
|
|
* else 'mine' when it is the caller's turn, else 'theirs'. It mirrors groupGames' partition and
|
|
* drives the per-card blink, which fires when a card transitions into 'mine' or 'finished'.
|
|
*/
|
|
export function gamePhase(game: GameView, myId: string): LobbyPhase {
|
|
if (game.status !== 'active' && game.status !== 'open') return 'finished';
|
|
return isMyTurn(game, myId) ? 'mine' : 'theirs';
|
|
}
|
|
|
|
/**
|
|
* shouldBlink reports whether a card's bucket change should fire the attention blink: only a
|
|
* transition into 'mine' (it became your turn) or 'finished' (the game ended) does — an
|
|
* opponent's-turn change is in-place. A first observation (prev === undefined) never blinks, so a
|
|
* cold render and games arriving from another screen stay quiet.
|
|
*/
|
|
export function shouldBlink(prev: LobbyPhase | undefined, next: LobbyPhase): boolean {
|
|
return prev !== undefined && prev !== next && (next === 'mine' || next === 'finished');
|
|
}
|
|
|
|
/** LobbyGroups holds the three ordered lobby sections. */
|
|
export interface LobbyGroups {
|
|
yourTurn: GameView[];
|
|
theirTurn: GameView[];
|
|
finished: GameView[];
|
|
}
|
|
|
|
/**
|
|
* groupGames partitions games for myId into the three lobby sections and orders each: the
|
|
* your-turn games by ascending last activity (the longest-waiting first), the opponent-turn
|
|
* and finished games by descending last activity (the most recent first).
|
|
*/
|
|
export function groupGames(games: GameView[], myId: string): LobbyGroups {
|
|
const yourTurn: GameView[] = [];
|
|
const theirTurn: GameView[] = [];
|
|
const finished: GameView[] = [];
|
|
for (const g of games) {
|
|
if (g.status !== 'active' && g.status !== 'open') finished.push(g);
|
|
else if (isMyTurn(g, myId)) yourTurn.push(g);
|
|
else theirTurn.push(g);
|
|
}
|
|
yourTurn.sort((a, b) => a.lastActivityUnix - b.lastActivityUnix);
|
|
theirTurn.sort((a, b) => b.lastActivityUnix - a.lastActivityUnix);
|
|
finished.sort((a, b) => b.lastActivityUnix - a.lastActivityUnix);
|
|
return { yourTurn, theirTurn, finished };
|
|
}
|