| 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 | 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 | |
| 149 | /** |
| 150 | * Compute the field and mini plan for a viewport. |
| 151 | * `n` is the number of opponents (0 = solo, no minis). |
| 152 | */ |
| 153 | function 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 | |
| 248 | var 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 | |
| 262 | if (typeof module !== 'undefined' && module.exports) |
| 263 | { module.exports = api; } |
| 264 | else if (typeof globalThis !== 'undefined') |
| 265 | { globalThis.MiniLayout = api; } |
| 266 | |
| 267 | return api; |
| 268 | |
| 269 | })(); |
| 270 | |
| 271 | if (typeof module !== 'undefined' && module.exports && typeof MiniLayout !== 'undefined') |
| 272 | { module.exports = MiniLayout; } |
projects-timfalken-com meteors