BlueGit

projects-timfalken-com meteors

feat: place minis from the outer edges, filling inward (t1127, t1133)

Opponents are anchored to the screen edges: 1st left-outer, 2nd
right-outer, 3rd left one step inward, and so on. A side fills its
row horizontally first and only wraps to a new row upward when no
more columns fit. The 960 px cutoff is gone; sides win whenever a
mini fits beside the field, except on truly narrow or portrait
screens (t1131).

timfa Grok Bot · pushed by timfa

Authored 2026-11-13 · 4 days ago

Hash
d211d53d45ab7a86f826429d668f64e3f2af8a06
Parent
37bbefd6
1 file changed +128 −33
src/miniLayout.js +128 −33
@@ -1,9 +1,13 @@
1 1 'use strict';
2 2
3 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.
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.
7 11 */
8 12
9 13 var MiniLayout = (function ()
@@ -13,27 +17,38 @@ var GAP = 12;
13 17 var VGAP = 8;
14 18 var EDGE = 16;
15 19 var MIN_TILE_FOR_SIDES = 18;
16 var MIN_VIEWPORT_FOR_SIDES = 960;
17 20 var LABEL_H = 32;
18 21 /* Extra space above the field in the wide (sides) layout so
19 22 enemy↔player arcs can route around the top edge (t1129). */
20 23 var ARC_TOP_PAD = 100;
24 /* Below this width, or in a narrow portrait, keep the top row (t1131). */
25 var PORTRAIT_NARROW = 700;
26 var PORTRAIT_MAX = 850;
21 27
22 function canvasSize (n, mode, availH)
28 function preferredMini ()
29 {
30 return { w: 80, h: 104, outerW: 90, outerH: 104 + LABEL_H };
31 }
32
33 function canvasSize (n, mode, availH, rows)
23 34 {
24 35 n = n || 0;
25 if (mode === 'sides' && availH && n > 0)
36 if (mode === 'sides')
26 37 {
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 };
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();
37 52 }
38 53 if (n >= 10)
39 54 { return { w: 40, h: 52, outerW: 56, outerH: 52 + LABEL_H }; }
@@ -42,12 +57,49 @@ function canvasSize (n, mode, availH)
42 57 return { w: 80, h: 104, outerW: 90, outerH: 104 + LABEL_H };
43 58 }
44 59
45 function sidePositions (n, fieldX, fieldY, fieldW, fieldH, mini, hudH)
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 */
64 function 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 */
82 function sidePositions (n, fieldX, fieldY, fieldW, fieldH, mini, hudH, vw, colsPerSide)
46 83 {
47 84 var positions = [];
48 85 if (n <= 0)
49 86 { return positions; }
50 var rows = Math.ceil(n / 2);
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 );
51 103 var stackH = rows * mini.outerH + Math.max(0, rows - 1) * VGAP;
52 104 var bottom = fieldY + fieldH;
53 105 var top = bottom - stackH;
@@ -56,18 +108,24 @@ function sidePositions (n, fieldX, fieldY, fieldW, fieldH, mini, hudH)
56 108 top = hudH + 4;
57 109 bottom = top + stackH;
58 110 }
111
59 112 for (var i = 0; i < n; i++)
60 113 {
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;
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);
66 122 var y = bottom - (row + 1) * mini.outerH - row * VGAP;
67 123 positions.push({
68 124 index: i,
69 side: col === 0 ? 'left' : 'right',
125 side: isLeft ? 'left' : 'right',
70 126 row: row,
127 fromOuter: fromOuter,
128 colsPerSide: cols,
71 129 x: x,
72 130 y: y,
73 131 w: mini.outerW,
@@ -79,6 +137,15 @@ function sidePositions (n, fieldX, fieldY, fieldW, fieldH, mini, hudH)
79 137 return positions;
80 138 }
81 139
140 function 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
82 149 /**
83 150 * Compute the field and mini plan for a viewport.
84 151 * `n` is the number of opponents (0 = solo, no minis).
@@ -91,7 +158,7 @@ function plan (vw, vh, n, hudH, margin)
91 158 hudH = hudH == null ? 56 : hudH;
92 159 margin = margin == null ? Math.max(6, Math.round(Math.min(vw, vh) * 0.015)) : margin;
93 160
94 function finish (mode, tile, fieldX, fieldY, miniH, mini, positions)
161 function finish (mode, tile, fieldX, fieldY, miniH, mini, positions, cols)
95 162 {
96 163 return {
97 164 mode: mode,
@@ -103,31 +170,58 @@ function plan (vw, vh, n, hudH, margin)
103 170 miniH: miniH,
104 171 mini: mini,
105 172 positions: positions || [],
173 colsPerSide: cols || 0,
106 174 n: n
107 175 };
108 176 }
109 177
110 if (n > 0)
178 if (n > 0 && !isPortraitNarrow(vw, vh))
111 179 {
112 180 var availHSide = Math.max(80, vh - hudH - margin);
113 var probe = canvasSize(n, 'sides', availHSide);
181 var probe = preferredMini();
114 182 var availWSide = Math.max(80, vw - margin * 2 - 2 * (probe.outerW + GAP));
115 183 var availHForField = Math.max(80, availHSide - ARC_TOP_PAD);
116 184 var tileSide = Math.max(14, Math.floor(Math.min(availWSide / 10, availHForField / 13)));
117 185 var fieldWSide = tileSide * 10;
118 var fieldHSide = tileSide * 13;
119 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 }
120 202 var need = probe.outerW + GAP + EDGE;
121 if (vw >= MIN_VIEWPORT_FOR_SIDES && leftover >= need
122 && tileSide >= MIN_TILE_FOR_SIDES)
203 if (leftover >= need && tileSide >= MIN_TILE_FOR_SIDES && cols >= 1)
123 204 {
124 205 var fieldX = Math.floor((vw - fieldWSide) / 2);
206 var fieldHSide = tileSide * 13;
125 207 var fieldY = hudH + ARC_TOP_PAD
126 208 + Math.floor((availHForField - fieldHSide) / 2);
127 209 if (fieldY < hudH + ARC_TOP_PAD)
128 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
129 222 return finish('sides', tileSide, fieldX, fieldY, 0, probe,
130 sidePositions(n, fieldX, fieldY, fieldWSide, fieldHSide, probe, hudH));
223 sidePositions(n, fieldX, fieldY, fieldWSide, fieldHSide, probe, hudH, vw, cols),
224 cols);
131 225 }
132 226 }
133 227
@@ -148,7 +242,7 @@ function plan (vw, vh, n, hudH, margin)
148 242 var fieldY = topBand + Math.floor((vh - topBand - fieldH - margin / 2) / 2);
149 243 if (fieldY < topBand)
150 244 { fieldY = topBand; }
151 return finish('top', tile, fieldX, fieldY, miniH, miniTop, []);
245 return finish('top', tile, fieldX, fieldY, miniH, miniTop, [], 0);
152 246 }
153 247
154 248 var api = {
@@ -156,10 +250,11 @@ var api = {
156 250 VGAP: VGAP,
157 251 EDGE: EDGE,
158 252 MIN_TILE_FOR_SIDES: MIN_TILE_FOR_SIDES,
159 MIN_VIEWPORT_FOR_SIDES: MIN_VIEWPORT_FOR_SIDES,
160 253 ARC_TOP_PAD: ARC_TOP_PAD,
254 PORTRAIT_NARROW: PORTRAIT_NARROW,
161 255 LABEL_H: LABEL_H,
162 256 canvasSize: canvasSize,
257 colsThatFit: colsThatFit,
163 258 sidePositions: sidePositions,
164 259 plan: plan
165 260 };
@@ -1,9 +1,13 @@
1'use strict';
1'use strict';
2
2
3/**
3/**
4 * Opponent miniature layout for online and Offline Strijd (t1125).
4 * Opponent miniature layout for online and Offline Strijd
5 * Wide screens: alternating left/right of the player's field, extra
5 * (t1125, t1127, t1129, t1131, t1133).
6 * rows stacked upward. Narrow screens: a row (wrapping) above the field.
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.
7 */
11 */
8
12
9var MiniLayout = (function ()
13var MiniLayout = (function ()
@@ -13,27 +17,38 @@ var GAP = 12;
13var VGAP = 8;
17var VGAP = 8;
14var EDGE = 16;
18var EDGE = 16;
15var MIN_TILE_FOR_SIDES = 18;
19var MIN_TILE_FOR_SIDES = 18;
16var MIN_VIEWPORT_FOR_SIDES = 960;
17var LABEL_H = 32;
20var LABEL_H = 32;
18/* Extra space above the field in the wide (sides) layout so
21/* Extra space above the field in the wide (sides) layout so
19 enemy↔player arcs can route around the top edge (t1129). */
22 enemy↔player arcs can route around the top edge (t1129). */
20var ARC_TOP_PAD = 100;
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;
21
27
22function canvasSize (n, mode, availH)
28function preferredMini ()
29{
30 return { w: 80, h: 104, outerW: 90, outerH: 104 + LABEL_H };
31}
32
33function canvasSize (n, mode, availH, rows)
23{
34{
24 n = n || 0;
35 n = n || 0;
25 if (mode === 'sides' && availH && n > 0)
36 if (mode === 'sides')
26 {
37 {
27 var rows = Math.ceil(n / 2);
38 rows = Math.max(1, rows || 1);
28 var maxOuter = Math.floor((availH - (rows - 1) * VGAP) / Math.max(1, rows));
39 if (availH && rows > 1)
29 var ch = Math.max(40, Math.min(104, maxOuter - LABEL_H));
40 {
30 var cw = Math.max(32, Math.round(ch * 10 / 13));
41 var maxOuter = Math.floor((availH - (rows - 1) * VGAP) / rows);
31 return {
42 var ch = Math.max(40, Math.min(104, maxOuter - LABEL_H));
32 w: cw,
43 var cw = Math.max(32, Math.round(ch * 10 / 13));
33 h: ch,
44 return {
34 outerW: Math.max(cw + 8, 64),
45 w: cw,
35 outerH: ch + LABEL_H
46 h: ch,
36 };
47 outerW: Math.max(cw + 8, 56),
48 outerH: ch + LABEL_H
49 };
50 }
51 return preferredMini();
37 }
52 }
38 if (n >= 10)
53 if (n >= 10)
39 { return { w: 40, h: 52, outerW: 56, outerH: 52 + LABEL_H }; }
54 { return { w: 40, h: 52, outerW: 56, outerH: 52 + LABEL_H }; }
@@ -42,12 +57,49 @@ function canvasSize (n, mode, availH)
42 return { w: 80, h: 104, outerW: 90, outerH: 104 + LABEL_H };
57 return { w: 80, h: 104, outerW: 90, outerH: 104 + LABEL_H };
43}
58}
44
59
45function sidePositions (n, fieldX, fieldY, fieldW, fieldH, mini, hudH)
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)
46{
83{
47 var positions = [];
84 var positions = [];
48 if (n <= 0)
85 if (n <= 0)
49 { return positions; }
86 { return positions; }
50 var rows = Math.ceil(n / 2);
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 );
51 var stackH = rows * mini.outerH + Math.max(0, rows - 1) * VGAP;
103 var stackH = rows * mini.outerH + Math.max(0, rows - 1) * VGAP;
52 var bottom = fieldY + fieldH;
104 var bottom = fieldY + fieldH;
53 var top = bottom - stackH;
105 var top = bottom - stackH;
@@ -56,18 +108,24 @@ function sidePositions (n, fieldX, fieldY, fieldW, fieldH, mini, hudH)
56 top = hudH + 4;
108 top = hudH + 4;
57 bottom = top + stackH;
109 bottom = top + stackH;
58 }
110 }
111
59 for (var i = 0; i < n; i++)
112 for (var i = 0; i < n; i++)
60 {
113 {
61 var col = i % 2;
114 var isLeft = (i % 2) === 0;
62 var row = Math.floor(i / 2);
115 var slot = Math.floor(i / 2);
63 var x = col === 0
116 var cols = isLeft ? colsL : colsR;
64 ? fieldX - GAP - mini.outerW
117 var row = Math.floor(slot / cols);
65 : fieldX + fieldW + GAP;
118 var fromOuter = slot % cols;
119 var x = isLeft
120 ? EDGE + fromOuter * (mini.outerW + GAP)
121 : vw - EDGE - mini.outerW - fromOuter * (mini.outerW + GAP);
66 var y = bottom - (row + 1) * mini.outerH - row * VGAP;
122 var y = bottom - (row + 1) * mini.outerH - row * VGAP;
67 positions.push({
123 positions.push({
68 index: i,
124 index: i,
69 side: col === 0 ? 'left' : 'right',
125 side: isLeft ? 'left' : 'right',
70 row: row,
126 row: row,
127 fromOuter: fromOuter,
128 colsPerSide: cols,
71 x: x,
129 x: x,
72 y: y,
130 y: y,
73 w: mini.outerW,
131 w: mini.outerW,
@@ -79,6 +137,15 @@ function sidePositions (n, fieldX, fieldY, fieldW, fieldH, mini, hudH)
79 return positions;
137 return positions;
80}
138}
81
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
82/**
149/**
83 * Compute the field and mini plan for a viewport.
150 * Compute the field and mini plan for a viewport.
84 * `n` is the number of opponents (0 = solo, no minis).
151 * `n` is the number of opponents (0 = solo, no minis).
@@ -91,7 +158,7 @@ function plan (vw, vh, n, hudH, margin)
91 hudH = hudH == null ? 56 : hudH;
158 hudH = hudH == null ? 56 : hudH;
92 margin = margin == null ? Math.max(6, Math.round(Math.min(vw, vh) * 0.015)) : margin;
159 margin = margin == null ? Math.max(6, Math.round(Math.min(vw, vh) * 0.015)) : margin;
93
160
94 function finish (mode, tile, fieldX, fieldY, miniH, mini, positions)
161 function finish (mode, tile, fieldX, fieldY, miniH, mini, positions, cols)
95 {
162 {
96 return {
163 return {
97 mode: mode,
164 mode: mode,
@@ -103,31 +170,58 @@ function plan (vw, vh, n, hudH, margin)
103 miniH: miniH,
170 miniH: miniH,
104 mini: mini,
171 mini: mini,
105 positions: positions || [],
172 positions: positions || [],
173 colsPerSide: cols || 0,
106 n: n
174 n: n
107 };
175 };
108 }
176 }
109
177
110 if (n > 0)
178 if (n > 0 && !isPortraitNarrow(vw, vh))
111 {
179 {
112 var availHSide = Math.max(80, vh - hudH - margin);
180 var availHSide = Math.max(80, vh - hudH - margin);
113 var probe = canvasSize(n, 'sides', availHSide);
181 var probe = preferredMini();
114 var availWSide = Math.max(80, vw - margin * 2 - 2 * (probe.outerW + GAP));
182 var availWSide = Math.max(80, vw - margin * 2 - 2 * (probe.outerW + GAP));
115 var availHForField = Math.max(80, availHSide - ARC_TOP_PAD);
183 var availHForField = Math.max(80, availHSide - ARC_TOP_PAD);
116 var tileSide = Math.max(14, Math.floor(Math.min(availWSide / 10, availHForField / 13)));
184 var tileSide = Math.max(14, Math.floor(Math.min(availWSide / 10, availHForField / 13)));
117 var fieldWSide = tileSide * 10;
185 var fieldWSide = tileSide * 10;
118 var fieldHSide = tileSide * 13;
119 var leftover = (vw - fieldWSide) / 2;
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 }
120 var need = probe.outerW + GAP + EDGE;
202 var need = probe.outerW + GAP + EDGE;
121 if (vw >= MIN_VIEWPORT_FOR_SIDES && leftover >= need
203 if (leftover >= need && tileSide >= MIN_TILE_FOR_SIDES && cols >= 1)
122 && tileSide >= MIN_TILE_FOR_SIDES)
123 {
204 {
124 var fieldX = Math.floor((vw - fieldWSide) / 2);
205 var fieldX = Math.floor((vw - fieldWSide) / 2);
206 var fieldHSide = tileSide * 13;
125 var fieldY = hudH + ARC_TOP_PAD
207 var fieldY = hudH + ARC_TOP_PAD
126 + Math.floor((availHForField - fieldHSide) / 2);
208 + Math.floor((availHForField - fieldHSide) / 2);
127 if (fieldY < hudH + ARC_TOP_PAD)
209 if (fieldY < hudH + ARC_TOP_PAD)
128 { 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
129 return finish('sides', tileSide, fieldX, fieldY, 0, probe,
222 return finish('sides', tileSide, fieldX, fieldY, 0, probe,
130 sidePositions(n, fieldX, fieldY, fieldWSide, fieldHSide, probe, hudH));
223 sidePositions(n, fieldX, fieldY, fieldWSide, fieldHSide, probe, hudH, vw, cols),
224 cols);
131 }
225 }
132 }
226 }
133
227
@@ -148,7 +242,7 @@ function plan (vw, vh, n, hudH, margin)
148 var fieldY = topBand + Math.floor((vh - topBand - fieldH - margin / 2) / 2);
242 var fieldY = topBand + Math.floor((vh - topBand - fieldH - margin / 2) / 2);
149 if (fieldY < topBand)
243 if (fieldY < topBand)
150 { fieldY = topBand; }
244 { fieldY = topBand; }
151 return finish('top', tile, fieldX, fieldY, miniH, miniTop, []);
245 return finish('top', tile, fieldX, fieldY, miniH, miniTop, [], 0);
152}
246}
153
247
154var api = {
248var api = {
@@ -156,10 +250,11 @@ var api = {
156 VGAP: VGAP,
250 VGAP: VGAP,
157 EDGE: EDGE,
251 EDGE: EDGE,
158 MIN_TILE_FOR_SIDES: MIN_TILE_FOR_SIDES,
252 MIN_TILE_FOR_SIDES: MIN_TILE_FOR_SIDES,
159 MIN_VIEWPORT_FOR_SIDES: MIN_VIEWPORT_FOR_SIDES,
160 ARC_TOP_PAD: ARC_TOP_PAD,
253 ARC_TOP_PAD: ARC_TOP_PAD,
254 PORTRAIT_NARROW: PORTRAIT_NARROW,
161 LABEL_H: LABEL_H,
255 LABEL_H: LABEL_H,
162 canvasSize: canvasSize,
256 canvasSize: canvasSize,
257 colsThatFit: colsThatFit,
163 sidePositions: sidePositions,
258 sidePositions: sidePositions,
164 plan: plan
259 plan: plan
165};
260};