BlueGit

projects-timfalken-com meteors

Files

meteors / src / miniLayout.js

miniLayout.js

miniLayout.js 12.2 KiB Download Raw
1'use strict';
2
3/**
4 * Opponent miniature layout for online and Offline Strijd
5 * (t1125, t1127, t1129, t1131, t1133).
6 * Wide screens: minis sit beside the field, anchored to the outer
7 * screen edges, filling inward (1 = left outer, 2 = right outer,
8 * 3 = left next inward, …). Extra minis wrap to a new row upward
9 * only when a side's row is full. Narrow / portrait: a row above
10 * the field.
11 */
12
13var MiniLayout = (function ()
14{
15
16var GAP = 12;
17var VGAP = 8;
18var EDGE = 16;
19var MIN_TILE_FOR_SIDES = 18;
20var LABEL_H = 32;
21/* Extra space above the field in the wide (sides) layout so
22 enemy↔player arcs can route around the top edge (t1129). */
23var ARC_TOP_PAD = 100;
24/* Below this width, or in a narrow portrait, keep the top row (t1131). */
25var PORTRAIT_NARROW = 700;
26var PORTRAIT_MAX = 850;
27
28function preferredMini ()
29{
30 return { w: 80, h: 104, outerW: 90, outerH: 104 + LABEL_H };
31}
32
33function canvasSize (n, mode, availH, rows)
34{
35 n = n || 0;
36 if (mode === 'sides')
37 {
38 rows = Math.max(1, rows || 1);
39 if (availH && rows > 1)
40 {
41 var maxOuter = Math.floor((availH - (rows - 1) * VGAP) / rows);
42 var ch = Math.max(40, Math.min(104, maxOuter - LABEL_H));
43 var cw = Math.max(32, Math.round(ch * 10 / 13));
44 return {
45 w: cw,
46 h: ch,
47 outerW: Math.max(cw + 8, 56),
48 outerH: ch + LABEL_H
49 };
50 }
51 return preferredMini();
52 }
53 if (n >= 10)
54 { return { w: 40, h: 52, outerW: 56, outerH: 52 + LABEL_H }; }
55 if (n >= 6)
56 { return { w: 56, h: 73, outerW: 68, outerH: 73 + LABEL_H }; }
57 return { w: 80, h: 104, outerW: 90, outerH: 104 + LABEL_H };
58}
59
60/**
61 * How many minis fit in one row on a side, between the screen edge
62 * and the field: EDGE + n*outerW + n*GAP <= sideWidth.
63 */
64function colsThatFit (sideWidth, mini)
65{
66 if (!mini || !mini.outerW)
67 { return 0; }
68 var stride = mini.outerW + GAP;
69 if (stride <= 0)
70 { return 0; }
71 return Math.max(0, Math.floor((sideWidth - EDGE) / stride));
72}
73
74/**
75 * Place n opponents. Anchored to the OUTER screen edges, filling
76 * inward toward the field (t1133). Row 0 is bottom-aligned with the
77 * field; further rows stack upward only after a side's row is full
78 * (t1127).
79 *
80 * Index 0 → left outer, 1 → right outer, 2 → left next inward, …
81 */
82function sidePositions (n, fieldX, fieldY, fieldW, fieldH, mini, hudH, vw, colsPerSide)
83{
84 var positions = [];
85 if (n <= 0)
86 { return positions; }
87 vw = vw || (fieldX * 2 + fieldW);
88 var leftSpace = fieldX;
89 var rightSpace = vw - (fieldX + fieldW);
90 var colsL = colsPerSide != null ? colsPerSide : Math.max(1, colsThatFit(leftSpace, mini));
91 var colsR = colsPerSide != null ? colsPerSide : Math.max(1, colsThatFit(rightSpace, mini));
92 if (colsL < 1)
93 { colsL = 1; }
94 if (colsR < 1)
95 { colsR = 1; }
96
97 var leftCount = Math.ceil(n / 2);
98 var rightCount = Math.floor(n / 2);
99 var rows = Math.max(
100 Math.ceil(leftCount / colsL),
101 rightCount ? Math.ceil(rightCount / colsR) : 1
102 );
103 var stackH = rows * mini.outerH + Math.max(0, rows - 1) * VGAP;
104 var bottom = fieldY + fieldH;
105 var top = bottom - stackH;
106 if (top < hudH + 4)
107 {
108 top = hudH + 4;
109 bottom = top + stackH;
110 }
111
112 for (var i = 0; i < n; i++)
113 {
114 var isLeft = (i % 2) === 0;
115 var slot = Math.floor(i / 2);
116 var cols = isLeft ? colsL : colsR;
117 var row = Math.floor(slot / cols);
118 var fromOuter = slot % cols;
119 var x = isLeft
120 ? EDGE + fromOuter * (mini.outerW + GAP)
121 : vw - EDGE - mini.outerW - fromOuter * (mini.outerW + GAP);
122 var y = bottom - (row + 1) * mini.outerH - row * VGAP;
123 positions.push({
124 index: i,
125 side: isLeft ? 'left' : 'right',
126 row: row,
127 fromOuter: fromOuter,
128 colsPerSide: cols,
129 x: x,
130 y: y,
131 w: mini.outerW,
132 h: mini.outerH,
133 canvasW: mini.w,
134 canvasH: mini.h
135 });
136 }
137 return positions;
138}
139
140/* ---- t1203: top-row minis scale down so they all fit above the field ---- */
141
142/** Horizontal / vertical gap between top-row minis (px). */
143var TOP_GAP = 8;
144var TOP_VGAP = 4;
145/** Padding above the first top row (matches #minis padding-top). */
146var TOP_PAD = 6;
147/** Largest and smallest mini canvas width in the top row (px). 32 px is
148 * 3.2 px per column: the smallest size that still reads as a field. */
149var TOP_MAX_W = 80;
150var TOP_MIN_W = 32;
151/** Label font: 11 px at full size, never below 9 px. */
152var TOP_FONT_MAX = 11;
153var TOP_FONT_MIN = 9;
154
155/** Size of one top-row mini for a canvas width `w` (px). */
156function topMiniForWidth (w)
157{
158 w = Math.max(TOP_MIN_W, Math.min(TOP_MAX_W, Math.round(w)));
159 var h = Math.round(w * 13 / 10);
160 var font = Math.max(TOP_FONT_MIN, Math.min(TOP_FONT_MAX, Math.round(TOP_FONT_MAX * w / TOP_MAX_W)));
161 var labelH = Math.round(font * 2.9);
162 var outerW = w + Math.max(4, Math.round(10 * w / TOP_MAX_W));
163 return {
164 w: w,
165 h: h,
166 outerW: outerW,
167 outerH: h + labelH + 2,
168 font: font,
169 labelH: labelH,
170 scale: w / TOP_MAX_W
171 };
172}
173
174function topGrid (n, availW, mini)
175{
176 var cols = Math.max(1, Math.floor((availW + TOP_GAP) / (mini.outerW + TOP_GAP)));
177 cols = Math.min(cols, Math.max(1, n));
178 var rows = Math.max(1, Math.ceil(n / cols));
179 // Balance the rows (6 → 3 + 3 rather than 5 + 1).
180 cols = Math.max(1, Math.ceil(n / rows));
181 return { cols: cols, rows: rows, height: rows * mini.outerH + (rows - 1) * TOP_VGAP };
182}
183
184/**
185 * The largest top-row mini so that all `n` fit in `availW` × `bandH`
186 * (t1203). If even TOP_MIN_W does not fit, return the minimum size with
187 * fits = false and `capacity` = how many still fit above the field.
188 */
189function topMiniFit (n, availW, bandH)
190{
191 n = Math.max(0, n || 0);
192 for (var w = TOP_MAX_W; w >= TOP_MIN_W; w--)
193 {
194 var m = topMiniForWidth(w);
195 var g = topGrid(n, availW, m);
196 if (g.height <= bandH)
197 {
198 m.cols = g.cols;
199 m.rows = g.rows;
200 m.fits = true;
201 m.capacity = Math.max(n, g.cols * g.rows);
202 return m;
203 }
204 }
205 var min = topMiniForWidth(TOP_MIN_W);
206 var maxCols = Math.max(1, Math.floor((availW + TOP_GAP) / (min.outerW + TOP_GAP)));
207 var rowsFit = Math.max(1, Math.floor((bandH + TOP_VGAP) / (min.outerH + TOP_VGAP)));
208 min.cols = maxCols;
209 min.rows = Math.ceil(n / maxCols);
210 min.fits = false;
211 min.capacity = maxCols * rowsFit;
212 return min;
213}
214
215/**
216 * Slot per opponent (t1203). When everything fits, slot = index (order
217 * unchanged). Only when they do not fit: alive opponents first, then the
218 * eliminated ones, each group in its original order (stable), so the
219 * ones that end up behind the field are the defeated ones.
220 * @param {boolean[]} eliminated per original index
221 * @return {number[]} slot for each original index
222 */
223function topSlots (eliminated, fits)
224{
225 var n = eliminated.length;
226 var slots = new Array(n);
227 if (fits)
228 {
229 for (var i = 0; i < n; i++)
230 { slots[i] = i; }
231 return slots;
232 }
233 var next = 0;
234 for (var a = 0; a < n; a++)
235 {
236 if (!eliminated[a])
237 { slots[a] = next++; }
238 }
239 for (var e = 0; e < n; e++)
240 {
241 if (eliminated[e])
242 { slots[e] = next++; }
243 }
244 return slots;
245}
246
247/** Viewport position of top-row slot `slot` (rows centred). */
248function topSlotPosition (slot, n, plan)
249{
250 var mini = plan.mini;
251 var cols = mini.cols || 1;
252 var row = Math.floor(slot / cols);
253 var inRow = Math.min(cols, n - row * cols);
254 var rowW = inRow * mini.outerW + (inRow - 1) * TOP_GAP;
255 var x0 = Math.round((plan.vw - rowW) / 2);
256 return {
257 slot: slot,
258 row: row,
259 x: x0 + (slot % cols) * (mini.outerW + TOP_GAP),
260 y: plan.hudH + TOP_PAD + row * (mini.outerH + TOP_VGAP),
261 w: mini.outerW,
262 h: mini.outerH,
263 canvasW: mini.w,
264 canvasH: mini.h,
265 font: mini.font,
266 aboveField: (plan.hudH + TOP_PAD + row * (mini.outerH + TOP_VGAP) + mini.outerH) <= plan.fieldY + 0.5
267 };
268}
269
270/** Positions per original index for the top row (t1203). */
271function topPositions (eliminated, plan)
272{
273 var n = eliminated.length;
274 var slots = topSlots(eliminated, plan.mini && plan.mini.fits);
275 var out = [];
276 for (var i = 0; i < n; i++)
277 {
278 var pos = topSlotPosition(slots[i], n, plan);
279 pos.index = i;
280 pos.eliminated = !!eliminated[i];
281 out.push(pos);
282 }
283 return out;
284}
285
286function isPortraitNarrow (vw, vh)
287{
288 if (vw < PORTRAIT_NARROW)
289 { return true; }
290 if (vw < vh && vw < PORTRAIT_MAX)
291 { return true; }
292 return false;
293}
294
295/**
296 * Compute the field and mini plan for a viewport.
297 * `n` is the number of opponents (0 = solo, no minis).
298 */
299function plan (vw, vh, n, hudH, margin)
300{
301 vw = vw || 320;
302 vh = vh || 480;
303 n = n || 0;
304 hudH = hudH == null ? 56 : hudH;
305 margin = margin == null ? Math.max(6, Math.round(Math.min(vw, vh) * 0.015)) : margin;
306
307 function finish (mode, tile, fieldX, fieldY, miniH, mini, positions, cols)
308 {
309 return {
310 mode: mode,
311 tile: tile,
312 fieldW: tile * 10,
313 fieldH: tile * 13,
314 fieldX: fieldX,
315 fieldY: fieldY,
316 miniH: miniH,
317 mini: mini,
318 positions: positions || [],
319 colsPerSide: cols || 0,
320 n: n
321 };
322 }
323
324 if (n > 0 && !isPortraitNarrow(vw, vh))
325 {
326 var availHSide = Math.max(80, vh - hudH - margin);
327 var probe = preferredMini();
328 var availWSide = Math.max(80, vw - margin * 2 - 2 * (probe.outerW + GAP));
329 var availHForField = Math.max(80, availHSide - ARC_TOP_PAD);
330 var tileSide = Math.max(14, Math.floor(Math.min(availWSide / 10, availHForField / 13)));
331 var fieldWSide = tileSide * 10;
332 var leftover = (vw - fieldWSide) / 2;
333 var cols = colsThatFit(leftover, probe);
334 // If a large mini does not fit, shrink it so a small one still can (t1131).
335 if (cols < 1)
336 {
337 var shrinkStride = leftover - EDGE;
338 if (shrinkStride >= 56 + GAP)
339 {
340 var ow = Math.max(56, shrinkStride - GAP);
341 var oh = Math.round(ow * (104 + LABEL_H) / 90);
342 var ch = Math.max(40, oh - LABEL_H);
343 var cw = Math.max(32, Math.round(ch * 10 / 13));
344 probe = { w: cw, h: ch, outerW: ow, outerH: ch + LABEL_H };
345 cols = colsThatFit(leftover, probe);
346 }
347 }
348 var need = probe.outerW + GAP + EDGE;
349 if (leftover >= need && tileSide >= MIN_TILE_FOR_SIDES && cols >= 1)
350 {
351 var fieldX = Math.floor((vw - fieldWSide) / 2);
352 var fieldHSide = tileSide * 13;
353 var fieldY = hudH + ARC_TOP_PAD
354 + Math.floor((availHForField - fieldHSide) / 2);
355 if (fieldY < hudH + ARC_TOP_PAD)
356 { fieldY = hudH + ARC_TOP_PAD; }
357
358 var leftCount = Math.ceil(n / 2);
359 var rows = Math.max(1, Math.ceil(leftCount / cols));
360 var stackAvail = fieldY + fieldHSide - (hudH + 4);
361 if (rows > 1)
362 {
363 probe = canvasSize(n, 'sides', stackAvail, rows);
364 cols = Math.max(1, colsThatFit(leftover, probe));
365 rows = Math.max(1, Math.ceil(leftCount / cols));
366 }
367
368 return finish('sides', tileSide, fieldX, fieldY, 0, probe,
369 sidePositions(n, fieldX, fieldY, fieldWSide, fieldHSide, probe, hudH, vw, cols),
370 cols);
371 }
372 }
373
374 var miniTop = canvasSize(n, 'top', 0);
375 var miniH = 0;
376 if (n > 0)
377 {
378 var share = n > 6 ? 0.26 : 0.20;
379 miniH = Math.min(n > 6 ? 180 : 150, Math.max(86, Math.round(vh * share)));
380 }
381 var availW = Math.max(80, vw - margin * 2);
382 var availH = Math.max(80, vh - hudH - miniH - margin);
383 var tile = Math.max(14, Math.floor(Math.min(availW / 10, availH / 13)));
384 var fieldW = tile * 10;
385 var fieldH = tile * 13;
386 var fieldX = Math.floor((vw - fieldW) / 2);
387 var topBand = hudH + miniH;
388 var fieldY = topBand + Math.floor((vh - topBand - fieldH - margin / 2) / 2);
389 if (fieldY < topBand)
390 { fieldY = topBand; }
391 if (n > 0)
392 {
393 // t1203: scale the minis so all of them fit in the band above the
394 // field (band = from below the HUD to the top of the field).
395 var bandH = Math.max(0, fieldY - hudH - TOP_PAD - 2);
396 miniTop = topMiniFit(n, Math.max(40, vw - 2 * TOP_GAP), bandH);
397 }
398 var res = finish('top', tile, fieldX, fieldY, miniH, miniTop, [], 0);
399 res.vw = vw;
400 res.hudH = hudH;
401 if (n > 0)
402 {
403 var none = [];
404 for (var k = 0; k < n; k++)
405 { none.push(false); }
406 res.positions = topPositions(none, res);
407 }
408 return res;
409}
410
411var api = {
412 GAP: GAP,
413 VGAP: VGAP,
414 EDGE: EDGE,
415 MIN_TILE_FOR_SIDES: MIN_TILE_FOR_SIDES,
416 ARC_TOP_PAD: ARC_TOP_PAD,
417 PORTRAIT_NARROW: PORTRAIT_NARROW,
418 LABEL_H: LABEL_H,
419 canvasSize: canvasSize,
420 TOP_GAP: TOP_GAP,
421 TOP_VGAP: TOP_VGAP,
422 TOP_PAD: TOP_PAD,
423 TOP_MAX_W: TOP_MAX_W,
424 TOP_MIN_W: TOP_MIN_W,
425 TOP_FONT_MIN: TOP_FONT_MIN,
426 topMiniForWidth: topMiniForWidth,
427 topMiniFit: topMiniFit,
428 topSlots: topSlots,
429 topSlotPosition: topSlotPosition,
430 topPositions: topPositions,
431 colsThatFit: colsThatFit,
432 sidePositions: sidePositions,
433 plan: plan
434};
435
436if (typeof module !== 'undefined' && module.exports)
437{ module.exports = api; }
438else if (typeof globalThis !== 'undefined')
439{ globalThis.MiniLayout = api; }
440
441return api;
442
443})();
444
445if (typeof module !== 'undefined' && module.exports && typeof MiniLayout !== 'undefined')
446{ module.exports = MiniLayout; }