BlueGit

projects-timfalken-com meteors

Files

meteors / src / miniLayout.js

miniLayout.js

miniLayout.js 7.4 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
140function isPortraitNarrow (vw, vh)
141{
142 if (vw < PORTRAIT_NARROW)
143 { return true; }
144 if (vw < vh && vw < PORTRAIT_MAX)
145 { return true; }
146 return false;
147}
148
149/**
150 * Compute the field and mini plan for a viewport.
151 * `n` is the number of opponents (0 = solo, no minis).
152 */
153function plan (vw, vh, n, hudH, margin)
154{
155 vw = vw || 320;
156 vh = vh || 480;
157 n = n || 0;
158 hudH = hudH == null ? 56 : hudH;
159 margin = margin == null ? Math.max(6, Math.round(Math.min(vw, vh) * 0.015)) : margin;
160
161 function finish (mode, tile, fieldX, fieldY, miniH, mini, positions, cols)
162 {
163 return {
164 mode: mode,
165 tile: tile,
166 fieldW: tile * 10,
167 fieldH: tile * 13,
168 fieldX: fieldX,
169 fieldY: fieldY,
170 miniH: miniH,
171 mini: mini,
172 positions: positions || [],
173 colsPerSide: cols || 0,
174 n: n
175 };
176 }
177
178 if (n > 0 && !isPortraitNarrow(vw, vh))
179 {
180 var availHSide = Math.max(80, vh - hudH - margin);
181 var probe = preferredMini();
182 var availWSide = Math.max(80, vw - margin * 2 - 2 * (probe.outerW + GAP));
183 var availHForField = Math.max(80, availHSide - ARC_TOP_PAD);
184 var tileSide = Math.max(14, Math.floor(Math.min(availWSide / 10, availHForField / 13)));
185 var fieldWSide = tileSide * 10;
186 var leftover = (vw - fieldWSide) / 2;
187 var cols = colsThatFit(leftover, probe);
188 // If a large mini does not fit, shrink it so a small one still can (t1131).
189 if (cols < 1)
190 {
191 var shrinkStride = leftover - EDGE;
192 if (shrinkStride >= 56 + GAP)
193 {
194 var ow = Math.max(56, shrinkStride - GAP);
195 var oh = Math.round(ow * (104 + LABEL_H) / 90);
196 var ch = Math.max(40, oh - LABEL_H);
197 var cw = Math.max(32, Math.round(ch * 10 / 13));
198 probe = { w: cw, h: ch, outerW: ow, outerH: ch + LABEL_H };
199 cols = colsThatFit(leftover, probe);
200 }
201 }
202 var need = probe.outerW + GAP + EDGE;
203 if (leftover >= need && tileSide >= MIN_TILE_FOR_SIDES && cols >= 1)
204 {
205 var fieldX = Math.floor((vw - fieldWSide) / 2);
206 var fieldHSide = tileSide * 13;
207 var fieldY = hudH + ARC_TOP_PAD
208 + Math.floor((availHForField - fieldHSide) / 2);
209 if (fieldY < hudH + ARC_TOP_PAD)
210 { fieldY = hudH + ARC_TOP_PAD; }
211
212 var leftCount = Math.ceil(n / 2);
213 var rows = Math.max(1, Math.ceil(leftCount / cols));
214 var stackAvail = fieldY + fieldHSide - (hudH + 4);
215 if (rows > 1)
216 {
217 probe = canvasSize(n, 'sides', stackAvail, rows);
218 cols = Math.max(1, colsThatFit(leftover, probe));
219 rows = Math.max(1, Math.ceil(leftCount / cols));
220 }
221
222 return finish('sides', tileSide, fieldX, fieldY, 0, probe,
223 sidePositions(n, fieldX, fieldY, fieldWSide, fieldHSide, probe, hudH, vw, cols),
224 cols);
225 }
226 }
227
228 var miniTop = canvasSize(n, 'top', 0);
229 var miniH = 0;
230 if (n > 0)
231 {
232 var share = n > 6 ? 0.26 : 0.20;
233 miniH = Math.min(n > 6 ? 180 : 150, Math.max(86, Math.round(vh * share)));
234 }
235 var availW = Math.max(80, vw - margin * 2);
236 var availH = Math.max(80, vh - hudH - miniH - margin);
237 var tile = Math.max(14, Math.floor(Math.min(availW / 10, availH / 13)));
238 var fieldW = tile * 10;
239 var fieldH = tile * 13;
240 var fieldX = Math.floor((vw - fieldW) / 2);
241 var topBand = hudH + miniH;
242 var fieldY = topBand + Math.floor((vh - topBand - fieldH - margin / 2) / 2);
243 if (fieldY < topBand)
244 { fieldY = topBand; }
245 return finish('top', tile, fieldX, fieldY, miniH, miniTop, [], 0);
246}
247
248var api = {
249 GAP: GAP,
250 VGAP: VGAP,
251 EDGE: EDGE,
252 MIN_TILE_FOR_SIDES: MIN_TILE_FOR_SIDES,
253 ARC_TOP_PAD: ARC_TOP_PAD,
254 PORTRAIT_NARROW: PORTRAIT_NARROW,
255 LABEL_H: LABEL_H,
256 canvasSize: canvasSize,
257 colsThatFit: colsThatFit,
258 sidePositions: sidePositions,
259 plan: plan
260};
261
262if (typeof module !== 'undefined' && module.exports)
263{ module.exports = api; }
264else if (typeof globalThis !== 'undefined')
265{ globalThis.MiniLayout = api; }
266
267return api;
268
269})();
270
271if (typeof module !== 'undefined' && module.exports && typeof MiniLayout !== 'undefined')
272{ module.exports = MiniLayout; }