| 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 | |
| 13 | var MiniLayout = (function () |
| 14 | { |
| 15 | |
| 16 | var GAP = 12; |
| 17 | var VGAP = 8; |
| 18 | var EDGE = 16; |
| 19 | var MIN_TILE_FOR_SIDES = 18; |
| 20 | var 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). */ |
| 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; |
| 27 | |
| 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) |
| 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 | */ |
| 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) |
| 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). */ |
| 143 | var TOP_GAP = 8; |
| 144 | var TOP_VGAP = 4; |
| 145 | /** Padding above the first top row (matches #minis padding-top). */ |
| 146 | var 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. */ |
| 149 | var TOP_MAX_W = 80; |
| 150 | var TOP_MIN_W = 32; |
| 151 | /** Label font: 11 px at full size, never below 9 px. */ |
| 152 | var TOP_FONT_MAX = 11; |
| 153 | var TOP_FONT_MIN = 9; |
| 154 | |
| 155 | /** Size of one top-row mini for a canvas width `w` (px). */ |
| 156 | function 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 | |
| 174 | function 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 | */ |
| 189 | function 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 | */ |
| 223 | function 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). */ |
| 248 | function 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). */ |
| 271 | function 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 | |
| 286 | function 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 | */ |
| 299 | function 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 | |
| 411 | var 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 | |
| 436 | if (typeof module !== 'undefined' && module.exports) |
| 437 | { module.exports = api; } |
| 438 | else if (typeof globalThis !== 'undefined') |
| 439 | { globalThis.MiniLayout = api; } |
| 440 | |
| 441 | return api; |
| 442 | |
| 443 | })(); |
| 444 | |
| 445 | if (typeof module !== 'undefined' && module.exports && typeof MiniLayout !== 'undefined') |
| 446 | { module.exports = MiniLayout; } |
projects-timfalken-com meteors