| 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 | |
| 9 | var MiniLayout = (function () |
| 10 | { |
| 11 | |
| 12 | var GAP = 12; |
| 13 | var VGAP = 8; |
| 14 | var EDGE = 16; |
| 15 | var MIN_TILE_FOR_SIDES = 18; |
| 16 | var MIN_VIEWPORT_FOR_SIDES = 960; |
| 17 | var 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). */ |
| 20 | var ARC_TOP_PAD = 100; |
| 21 | |
| 22 | function 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 | |
| 45 | function 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 | */ |
| 86 | function 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 | |
| 154 | var 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 | |
| 167 | if (typeof module !== 'undefined' && module.exports) |
| 168 | { module.exports = api; } |
| 169 | else if (typeof globalThis !== 'undefined') |
| 170 | { globalThis.MiniLayout = api; } |
| 171 | |
| 172 | return api; |
| 173 | |
| 174 | })(); |
| 175 | |
| 176 | if (typeof module !== 'undefined' && module.exports && typeof MiniLayout !== 'undefined') |
| 177 | { module.exports = MiniLayout; } |
projects-timfalken-com meteors