BlueGit

projects-timfalken-com meteors

Files

meteors / src / miniLayout.js

miniLayout.js

miniLayout.js 4.6 KiB Download Raw
1'use strict';
2
3/**
4 * Opponent miniature layout for online and Offline Strijd (t1125).
5 * Wide screens: alternating left/right of the player's field, extra
6 * rows stacked upward. Narrow screens: a row (wrapping) above the field.
7 */
8
9var MiniLayout = (function ()
10{
11
12var GAP = 12;
13var VGAP = 8;
14var EDGE = 16;
15var MIN_TILE_FOR_SIDES = 18;
16var MIN_VIEWPORT_FOR_SIDES = 960;
17var LABEL_H = 32;
18/* Extra space above the field in the wide (sides) layout so
19 enemy↔player arcs can route around the top edge (t1129). */
20var ARC_TOP_PAD = 100;
21
22function canvasSize (n, mode, availH)
23{
24 n = n || 0;
25 if (mode === 'sides' && availH && n > 0)
26 {
27 var rows = Math.ceil(n / 2);
28 var maxOuter = Math.floor((availH - (rows - 1) * VGAP) / Math.max(1, rows));
29 var ch = Math.max(40, Math.min(104, maxOuter - LABEL_H));
30 var cw = Math.max(32, Math.round(ch * 10 / 13));
31 return {
32 w: cw,
33 h: ch,
34 outerW: Math.max(cw + 8, 64),
35 outerH: ch + LABEL_H
36 };
37 }
38 if (n >= 10)
39 { return { w: 40, h: 52, outerW: 56, outerH: 52 + LABEL_H }; }
40 if (n >= 6)
41 { return { w: 56, h: 73, outerW: 68, outerH: 73 + LABEL_H }; }
42 return { w: 80, h: 104, outerW: 90, outerH: 104 + LABEL_H };
43}
44
45function sidePositions (n, fieldX, fieldY, fieldW, fieldH, mini, hudH)
46{
47 var positions = [];
48 if (n <= 0)
49 { return positions; }
50 var rows = Math.ceil(n / 2);
51 var stackH = rows * mini.outerH + Math.max(0, rows - 1) * VGAP;
52 var bottom = fieldY + fieldH;
53 var top = bottom - stackH;
54 if (top < hudH + 4)
55 {
56 top = hudH + 4;
57 bottom = top + stackH;
58 }
59 for (var i = 0; i < n; i++)
60 {
61 var col = i % 2;
62 var row = Math.floor(i / 2);
63 var x = col === 0
64 ? fieldX - GAP - mini.outerW
65 : fieldX + fieldW + GAP;
66 var y = bottom - (row + 1) * mini.outerH - row * VGAP;
67 positions.push({
68 index: i,
69 side: col === 0 ? 'left' : 'right',
70 row: row,
71 x: x,
72 y: y,
73 w: mini.outerW,
74 h: mini.outerH,
75 canvasW: mini.w,
76 canvasH: mini.h
77 });
78 }
79 return positions;
80}
81
82/**
83 * Compute the field and mini plan for a viewport.
84 * `n` is the number of opponents (0 = solo, no minis).
85 */
86function plan (vw, vh, n, hudH, margin)
87{
88 vw = vw || 320;
89 vh = vh || 480;
90 n = n || 0;
91 hudH = hudH == null ? 56 : hudH;
92 margin = margin == null ? Math.max(6, Math.round(Math.min(vw, vh) * 0.015)) : margin;
93
94 function finish (mode, tile, fieldX, fieldY, miniH, mini, positions)
95 {
96 return {
97 mode: mode,
98 tile: tile,
99 fieldW: tile * 10,
100 fieldH: tile * 13,
101 fieldX: fieldX,
102 fieldY: fieldY,
103 miniH: miniH,
104 mini: mini,
105 positions: positions || [],
106 n: n
107 };
108 }
109
110 if (n > 0)
111 {
112 var availHSide = Math.max(80, vh - hudH - margin);
113 var probe = canvasSize(n, 'sides', availHSide);
114 var availWSide = Math.max(80, vw - margin * 2 - 2 * (probe.outerW + GAP));
115 var availHForField = Math.max(80, availHSide - ARC_TOP_PAD);
116 var tileSide = Math.max(14, Math.floor(Math.min(availWSide / 10, availHForField / 13)));
117 var fieldWSide = tileSide * 10;
118 var fieldHSide = tileSide * 13;
119 var leftover = (vw - fieldWSide) / 2;
120 var need = probe.outerW + GAP + EDGE;
121 if (vw >= MIN_VIEWPORT_FOR_SIDES && leftover >= need
122 && tileSide >= MIN_TILE_FOR_SIDES)
123 {
124 var fieldX = Math.floor((vw - fieldWSide) / 2);
125 var fieldY = hudH + ARC_TOP_PAD
126 + Math.floor((availHForField - fieldHSide) / 2);
127 if (fieldY < hudH + ARC_TOP_PAD)
128 { fieldY = hudH + ARC_TOP_PAD; }
129 return finish('sides', tileSide, fieldX, fieldY, 0, probe,
130 sidePositions(n, fieldX, fieldY, fieldWSide, fieldHSide, probe, hudH));
131 }
132 }
133
134 var miniTop = canvasSize(n, 'top', 0);
135 var miniH = 0;
136 if (n > 0)
137 {
138 var share = n > 6 ? 0.26 : 0.20;
139 miniH = Math.min(n > 6 ? 180 : 150, Math.max(86, Math.round(vh * share)));
140 }
141 var availW = Math.max(80, vw - margin * 2);
142 var availH = Math.max(80, vh - hudH - miniH - margin);
143 var tile = Math.max(14, Math.floor(Math.min(availW / 10, availH / 13)));
144 var fieldW = tile * 10;
145 var fieldH = tile * 13;
146 var fieldX = Math.floor((vw - fieldW) / 2);
147 var topBand = hudH + miniH;
148 var fieldY = topBand + Math.floor((vh - topBand - fieldH - margin / 2) / 2);
149 if (fieldY < topBand)
150 { fieldY = topBand; }
151 return finish('top', tile, fieldX, fieldY, miniH, miniTop, []);
152}
153
154var api = {
155 GAP: GAP,
156 VGAP: VGAP,
157 EDGE: EDGE,
158 MIN_TILE_FOR_SIDES: MIN_TILE_FOR_SIDES,
159 MIN_VIEWPORT_FOR_SIDES: MIN_VIEWPORT_FOR_SIDES,
160 ARC_TOP_PAD: ARC_TOP_PAD,
161 LABEL_H: LABEL_H,
162 canvasSize: canvasSize,
163 sidePositions: sidePositions,
164 plan: plan
165};
166
167if (typeof module !== 'undefined' && module.exports)
168{ module.exports = api; }
169else if (typeof globalThis !== 'undefined')
170{ globalThis.MiniLayout = api; }
171
172return api;
173
174})();
175
176if (typeof module !== 'undefined' && module.exports && typeof MiniLayout !== 'undefined')
177{ module.exports = MiniLayout; }