collin/mahjong

6e2784f0e22cb28ae3f5b51bdfd2a1ebf4d397a7 / src / game / wall.ts

1	import { STACKS_PER_SIDE, WALL_SIZE, WALL_STACKS } from './tiles';
2	import type { SeatId } from './types';
3
4	/**
5	* What the wall square looks like right now.
6	*
7	* The square is eaten from both ends at once — normal draws come off the front,
8	* kong and flower replacements off the back — so how much of it is left is not
9	* one number but a per-stack question, and two things want the answer: the
10	* drawing of it (ui/WallRing) and the physics (table/geometry), since a stack
11	* still standing is something a thrown tile has to get past.
12	*
13	* Deliberately typed against the fields it reads rather than `GameState`, so it
14	* stays a function of the wall and nothing else.
15	*/
16	export interface WallProgress {
17	drawnFront: number;
18	drawnBack: number;
19	rules: { wallReserve: number };
20	}
21
22	export interface Stack {
23	/** Tiles still in this stack: 2 full, 1 half, 0 spent. */
24	count: 0 \| 1 \| 2;
25	/** Part of the 16-tile 底牌 tail that ends the hand. */
26	dead: boolean;
27	/** The break point — the stack the next draw comes off. */
28	next: boolean;
29	}
30
31	/**
32	* Position 0 is the break point. Stack `i` holds positions `2i` and `2i+1`, and
33	* a position is still there if it is past the front and short of the back.
34	*/
35	export function wallStacks(s: WallProgress): Stack[] {
36	const front = s.drawnFront;
37	const back = WALL_SIZE - s.drawnBack;
38	const deadFrom = back - s.rules.wallReserve;
39
40	return Array.from({ length: WALL_STACKS }, (_, i) => {
41	const a = i * 2;
42	const b = a + 1;
43	const live = (p: number) => p >= front && p < back;
44	const count = ((live(a) ? 1 : 0) + (live(b) ? 1 : 0)) as 0 \| 1 \| 2;
45	return { count, dead: b >= deadFrom, next: front === a \|\| front === b };
46	});
47	}
48
49	/**
50	* Whether a stack is something a thrown tile has to get past.
51	*
52	* A stack of two stands as tall as the tile being thrown at it. One of one is
53	* low enough to sail over, and a spent one is not there at all — so only a full
54	* stack is a barrier. This is the rule behind both halves of the throw: the
55	* colliders the pile bounces off, and whether a seat may flick at all.
56	*/
57	export const isBarrier = (s: Stack) => s.count === 2;
58
59	/** The four sides in the order WallRing lays them out, clockwise from the top. */
60	export const WALL_SIDES = ['top', 'right', 'bottom', 'left'] as const;
61	export type WallSide = (typeof WALL_SIDES)[number];
62
63	/**
64	* Which side of the square sits in front of each seat — the one a seat has to
65	* throw over. Seats run bottom, right, top, left (see ui/rotation.ts) and the
66	* sides are drawn top, right, bottom, left, so the two orders are not the same.
67	*/
68	export const SEAT_WALL_SIDE: Record<SeatId, number> = { 0: 2, 1: 1, 2: 0, 3: 3 };
69
70	/** The stacks making up one quarter of the square as it was built. */
71	export function sideStacks(stacks: Stack[], side: number): Stack[] {
72	return stacks.slice(side * STACKS_PER_SIDE, (side + 1) * STACKS_PER_SIDE);
73	}
74
75	/** How many stacks a side of the square holds, once the middle is measured. */
76	export interface RingCapacity {
77	/** Along the top and the bottom. */
78	h: number;
79	/** Down the left and the right. */
80	v: number;
81	}
82
83	/** Dealt out before anybody looks at the table: sixteen tiles, four ways. */
84	const DEALT = 64;
85	/**
86	* How much wall is left once a hand has been dealt. The square is built to the
87	* whole hundred and forty-four now rather than to this — see `RING` — so this
88	* is only a fact about the wall, and what the tests measure a fresh deal
89	* against.
90	*/
91	export const DEALT_STACKS = WALL_STACKS - DEALT / 2;
92
93	/**
94	* The square is the whole wall: eighteen stacks of two a side, four sides, the
95	* hundred and forty-four tiles, exactly as it is built on a table.
96	*
97	* It used to be rebuilt to what was left after a hand had been dealt — barely
98	* half of it — because eighteen full-size stacks a side wants about 560px and no
99	* ordinary window has that between the top and bottom strips. That bought a
100	* square, at the price of it not being the wall: a side ran out of stacks before
101	* it reached its corner, so the four of them never met.
102	*
103	* What gives instead is the tile. A wall tile is not a hand tile — on a table it
104	* is the same tile, but on a screen the wall has to fit the middle and the hand
105	* has to be readable, and those are two different jobs. See `ringCell`.
106	*/
107	export const RING: RingCapacity = { h: STACKS_PER_SIDE, v: STACKS_PER_SIDE };
108
109	/**
110	* How big a stack may be, to build that square in the middle there is.
111	*
112	* A side of n stacks runs one wall-depth past its own corner — the overlap that
113	* makes the # — so it needs `n * s + d` across, and with `d = s * ratio` that is
114	* `(n + ratio) * s`. Square, so the tighter of the two directions decides.
115	*
116	* `ratio` is the stack's long side over its short one, measured off the element
117	* rather than restated here: it is CSS's business what shape a stack is.
118	*/
119	export function ringCell(
120	space: { w: number; h: number },
121	ratio: number,
122	lap = ratio,
123	): number {
124	// Outer footprint: the opening, plus a wall hanging off each side of it.
125	// opening = ns - laps walls = 2 * ratio*s
126	// outer = (n + 2ratio - lap) s
127	return Math.max(1, Math.min(space.w, space.h) / (STACKS_PER_SIDE + 2 * ratio - lap));
128	}
129
130	/**
131	* The opening the square leaves in the middle — where the discards go.
132	*
133	* A side holds its stacks and then runs `lap` past its own corner: that overlap
134	* is the whole of what makes four straight walls a pinwheel, and it is what the
135	* opening is short by. One wall-depth is the square everyone knows; less draws
136	* the arms in, more throws them out.
137	*/
138	export const ringOpening = (
139	cap: RingCapacity,
140	cell: { s: number; d: number },
141	lap = cell.d,
142	) => ({
143	w: Math.max(cell.s, cap.h * cell.s - lap),
144	h: Math.max(cell.s, cap.v * cell.s - lap),
145	});
146
147	/** A stack and which of the 72 it is — the index is what the physics reads. */
148	export interface Placed {
149	index: number;
150	stack: Stack;
151	}
152
153	/**
154	* Where what is left of the wall actually goes.
155	*
156	* Four walls of eighteen full-size stacks want about 560px a side, and the
157	* middle of the table is nothing like that in both directions at once — so a
158	* square built to the tile is a square that hangs out under the players. What
159	* saves it is that by the time anyone is looking, four hands have been dealt
160	* off the front and there is nothing like a whole wall left: only what is still
161	* standing is drawn, and it is laid out around a ring cut to the middle rather
162	* than to the tile. Players push the remaining stacks about to keep them tidy
163	* for exactly this reason.
164	*
165	* The rebuilt square is the size of the wall as it is dealt, so at the start
166	* the run fills it exactly, and from then on it is simply eaten: the tail is
167	* pinned to the end of the square and normal draws take stacks off the front,
168	* which leaves a growing gap where they were and moves nothing else. Kong and
169	* flower replacements come off the other end and shorten it from there. Both
170	* ends are where they would be on a table, and the square keeps the size it was
171	* built at — a square that shrank every draw would close in on the discards
172	* lying inside it.
173	*/
174	export function ringLayout(stacks: Stack[], cap: RingCapacity): Placed[][] {
175	const sides: Placed[][] = [[], [], [], []];
176	const lengths = [cap.h, cap.v, cap.h, cap.v];
177	const slots = 2 * (cap.h + cap.v);
178	if (slots <= 0) return sides;
179
180	// Each stack has its own place in the square and keeps it: the far end is the
181	// far end of the square, and everything counts back from there. Draws off the
182	// front open a gap at the break point, draws off the tail shorten the other
183	// end, and no tile that is still standing ever has to move.
184	const offset = WALL_STACKS - slots;
185
186	for (let index = 0; index < stacks.length; index++) {
187	const stack = stacks[index];
188	// A wall too long for its square only happens before a hand is dealt, and
189	// then only for the frame it takes to deal it. What falls off the start is
190	// the part about to be drawn anyway.
191	let at = index - offset;
192	if (stack.count === 0 \|\| at < 0 \|\| at >= slots) continue;
193	let side = 0;
194	while (at >= lengths[side]) at -= lengths[side++];
195	sides[side].push({ index, stack });
196	}
197	return sides;
198	}