BlueGit

projects-timfalken-com meteors

Merge feature/t1203-mini-scale: minis scale to fit above the field on narrow screens (t1203)

timfa Grok Bot · pushed by timfa

Authored 2026-11-15 · 2 days ago

Hash
70ee4edbfac47c40edf44ff4bcd9ae0d5c2f0a8d
Pipeline
Passed
9 files changed +684 −5
README.md +7 −0
@@ -226,6 +226,13 @@ maximum 32. Iedereen drukt op Gereed; de host start als er minstens twee spelers
226 226 zijn en iedereen gereed is.
227 227
228 228 Je eigen veld is het hoofdspel; miniaturen van de tegenstanders staan erboven.
229 Op een smal/staand scherm (t1203) worden die miniaturen (en hun labels)
230 kleiner gemaakt tot ze **allemaal** boven je veld passen (canvas van
231 80 px breed tot minimaal 32 px, labels 11 → 9 px; rijen gebalanceerd).
232 Passen ze zelfs op 32 px niet, dan schuiven de al verslagen tegenstanders
233 naar achteren (volgorde blijft stabiel), zodat juist die achter het veld
234 vallen. Dit geldt voor Spelen (bots) en Online spelen; brede schermen
235 houden de layout naast het veld.
229 236 Blokjes die van je veld afschieten kiezen een willekeurige andere (nog niet
230 237 uitgeschakelde) speler en vliegen daar in een korte tween naartoe (draaien en
231 238 krimpen). De kans dat ze missen komt uit de **Power van jouw planeet** (60 % op het
@@ -226,6 +226,13 @@ maximum 32. Iedereen drukt op Gereed; de host start als er minstens twee spelers
226zijn en iedereen gereed is.
226zijn en iedereen gereed is.
227
227
228Je eigen veld is het hoofdspel; miniaturen van de tegenstanders staan erboven.
228Je eigen veld is het hoofdspel; miniaturen van de tegenstanders staan erboven.
229Op een smal/staand scherm (t1203) worden die miniaturen (en hun labels)
230kleiner gemaakt tot ze **allemaal** boven je veld passen (canvas van
23180 px breed tot minimaal 32 px, labels 11 → 9 px; rijen gebalanceerd).
232Passen ze zelfs op 32 px niet, dan schuiven de al verslagen tegenstanders
233naar achteren (volgorde blijft stabiel), zodat juist die achter het veld
234vallen. Dit geldt voor Spelen (bots) en Online spelen; brede schermen
235houden de layout naast het veld.
229Blokjes die van je veld afschieten kiezen een willekeurige andere (nog niet
236Blokjes die van je veld afschieten kiezen een willekeurige andere (nog niet
230uitgeschakelde) speler en vliegen daar in een korte tween naartoe (draaien en
237uitgeschakelde) speler en vliegen daar in een korte tween naartoe (draaien en
231krimpen). De kans dat ze missen komt uit de **Power van jouw planeet** (60 % op het
238krimpen). De kans dat ze missen komt uit de **Power van jouw planeet** (60 % op het
build/game.js +202 −2
@@ -8893,6 +8893,152 @@ function sidePositions (n, fieldX, fieldY, fieldW, fieldH, mini, hudH, vw, colsP
8893 8893 return positions;
8894 8894 }
8895 8895
8896 /* ---- t1203: top-row minis scale down so they all fit above the field ---- */
8897
8898 /** Horizontal / vertical gap between top-row minis (px). */
8899 var TOP_GAP = 8;
8900 var TOP_VGAP = 4;
8901 /** Padding above the first top row (matches #minis padding-top). */
8902 var TOP_PAD = 6;
8903 /** Largest and smallest mini canvas width in the top row (px). 32 px is
8904 * 3.2 px per column: the smallest size that still reads as a field. */
8905 var TOP_MAX_W = 80;
8906 var TOP_MIN_W = 32;
8907 /** Label font: 11 px at full size, never below 9 px. */
8908 var TOP_FONT_MAX = 11;
8909 var TOP_FONT_MIN = 9;
8910
8911 /** Size of one top-row mini for a canvas width `w` (px). */
8912 function topMiniForWidth (w)
8913 {
8914 w = Math.max(TOP_MIN_W, Math.min(TOP_MAX_W, Math.round(w)));
8915 var h = Math.round(w * 13 / 10);
8916 var font = Math.max(TOP_FONT_MIN, Math.min(TOP_FONT_MAX, Math.round(TOP_FONT_MAX * w / TOP_MAX_W)));
8917 var labelH = Math.round(font * 2.9);
8918 var outerW = w + Math.max(4, Math.round(10 * w / TOP_MAX_W));
8919 return {
8920 w: w,
8921 h: h,
8922 outerW: outerW,
8923 outerH: h + labelH + 2,
8924 font: font,
8925 labelH: labelH,
8926 scale: w / TOP_MAX_W
8927 };
8928 }
8929
8930 function topGrid (n, availW, mini)
8931 {
8932 var cols = Math.max(1, Math.floor((availW + TOP_GAP) / (mini.outerW + TOP_GAP)));
8933 cols = Math.min(cols, Math.max(1, n));
8934 var rows = Math.max(1, Math.ceil(n / cols));
8935 // Balance the rows (6 → 3 + 3 rather than 5 + 1).
8936 cols = Math.max(1, Math.ceil(n / rows));
8937 return { cols: cols, rows: rows, height: rows * mini.outerH + (rows - 1) * TOP_VGAP };
8938 }
8939
8940 /**
8941 * The largest top-row mini so that all `n` fit in `availW` × `bandH`
8942 * (t1203). If even TOP_MIN_W does not fit, return the minimum size with
8943 * fits = false and `capacity` = how many still fit above the field.
8944 */
8945 function topMiniFit (n, availW, bandH)
8946 {
8947 n = Math.max(0, n || 0);
8948 for (var w = TOP_MAX_W; w >= TOP_MIN_W; w--)
8949 {
8950 var m = topMiniForWidth(w);
8951 var g = topGrid(n, availW, m);
8952 if (g.height <= bandH)
8953 {
8954 m.cols = g.cols;
8955 m.rows = g.rows;
8956 m.fits = true;
8957 m.capacity = Math.max(n, g.cols * g.rows);
8958 return m;
8959 }
8960 }
8961 var min = topMiniForWidth(TOP_MIN_W);
8962 var maxCols = Math.max(1, Math.floor((availW + TOP_GAP) / (min.outerW + TOP_GAP)));
8963 var rowsFit = Math.max(1, Math.floor((bandH + TOP_VGAP) / (min.outerH + TOP_VGAP)));
8964 min.cols = maxCols;
8965 min.rows = Math.ceil(n / maxCols);
8966 min.fits = false;
8967 min.capacity = maxCols * rowsFit;
8968 return min;
8969 }
8970
8971 /**
8972 * Slot per opponent (t1203). When everything fits, slot = index (order
8973 * unchanged). Only when they do not fit: alive opponents first, then the
8974 * eliminated ones, each group in its original order (stable), so the
8975 * ones that end up behind the field are the defeated ones.
8976 * @param {boolean[]} eliminated per original index
8977 * @return {number[]} slot for each original index
8978 */
8979 function topSlots (eliminated, fits)
8980 {
8981 var n = eliminated.length;
8982 var slots = new Array(n);
8983 if (fits)
8984 {
8985 for (var i = 0; i < n; i++)
8986 { slots[i] = i; }
8987 return slots;
8988 }
8989 var next = 0;
8990 for (var a = 0; a < n; a++)
8991 {
8992 if (!eliminated[a])
8993 { slots[a] = next++; }
8994 }
8995 for (var e = 0; e < n; e++)
8996 {
8997 if (eliminated[e])
8998 { slots[e] = next++; }
8999 }
9000 return slots;
9001 }
9002
9003 /** Viewport position of top-row slot `slot` (rows centred). */
9004 function topSlotPosition (slot, n, plan)
9005 {
9006 var mini = plan.mini;
9007 var cols = mini.cols || 1;
9008 var row = Math.floor(slot / cols);
9009 var inRow = Math.min(cols, n - row * cols);
9010 var rowW = inRow * mini.outerW + (inRow - 1) * TOP_GAP;
9011 var x0 = Math.round((plan.vw - rowW) / 2);
9012 return {
9013 slot: slot,
9014 row: row,
9015 x: x0 + (slot % cols) * (mini.outerW + TOP_GAP),
9016 y: plan.hudH + TOP_PAD + row * (mini.outerH + TOP_VGAP),
9017 w: mini.outerW,
9018 h: mini.outerH,
9019 canvasW: mini.w,
9020 canvasH: mini.h,
9021 font: mini.font,
9022 aboveField: (plan.hudH + TOP_PAD + row * (mini.outerH + TOP_VGAP) + mini.outerH) <= plan.fieldY + 0.5
9023 };
9024 }
9025
9026 /** Positions per original index for the top row (t1203). */
9027 function topPositions (eliminated, plan)
9028 {
9029 var n = eliminated.length;
9030 var slots = topSlots(eliminated, plan.mini && plan.mini.fits);
9031 var out = [];
9032 for (var i = 0; i < n; i++)
9033 {
9034 var pos = topSlotPosition(slots[i], n, plan);
9035 pos.index = i;
9036 pos.eliminated = !!eliminated[i];
9037 out.push(pos);
9038 }
9039 return out;
9040 }
9041
8896 9042 function isPortraitNarrow (vw, vh)
8897 9043 {
8898 9044 if (vw < PORTRAIT_NARROW)
@@ -8998,7 +9144,24 @@ function plan (vw, vh, n, hudH, margin)
8998 9144 var fieldY = topBand + Math.floor((vh - topBand - fieldH - margin / 2) / 2);
8999 9145 if (fieldY < topBand)
9000 9146 { fieldY = topBand; }
9001 return finish('top', tile, fieldX, fieldY, miniH, miniTop, [], 0);
9147 if (n > 0)
9148 {
9149 // t1203: scale the minis so all of them fit in the band above the
9150 // field (band = from below the HUD to the top of the field).
9151 var bandH = Math.max(0, fieldY - hudH - TOP_PAD - 2);
9152 miniTop = topMiniFit(n, Math.max(40, vw - 2 * TOP_GAP), bandH);
9153 }
9154 var res = finish('top', tile, fieldX, fieldY, miniH, miniTop, [], 0);
9155 res.vw = vw;
9156 res.hudH = hudH;
9157 if (n > 0)
9158 {
9159 var none = [];
9160 for (var k = 0; k < n; k++)
9161 { none.push(false); }
9162 res.positions = topPositions(none, res);
9163 }
9164 return res;
9002 9165 }
9003 9166
9004 9167 var api = {
@@ -9010,6 +9173,17 @@ var api = {
9010 9173 PORTRAIT_NARROW: PORTRAIT_NARROW,
9011 9174 LABEL_H: LABEL_H,
9012 9175 canvasSize: canvasSize,
9176 TOP_GAP: TOP_GAP,
9177 TOP_VGAP: TOP_VGAP,
9178 TOP_PAD: TOP_PAD,
9179 TOP_MAX_W: TOP_MAX_W,
9180 TOP_MIN_W: TOP_MIN_W,
9181 TOP_FONT_MIN: TOP_FONT_MIN,
9182 topMiniForWidth: topMiniForWidth,
9183 topMiniFit: topMiniFit,
9184 topSlots: topSlots,
9185 topSlotPosition: topSlotPosition,
9186 topPositions: topPositions,
9013 9187 colsThatFit: colsThatFit,
9014 9188 sidePositions: sidePositions,
9015 9189 plan: plan
@@ -13769,6 +13943,19 @@ function applyMinisContainer (plan)
13769 13943 { return; }
13770 13944 var n = plan ? plan.n : 0;
13771 13945 minis.classList.toggle('crowded', n > 5);
13946 if (plan && n > 0 && plan.mode === 'top' && plan.mini && plan.mini.cols)
13947 {
13948 // t1203: top row is placed absolutely too, scaled to fit above the field.
13949 minis.classList.remove('sides');
13950 minis.classList.add('placed');
13951 minis.style.top = '0';
13952 minis.style.bottom = '0';
13953 minis.style.left = '0';
13954 minis.style.right = '0';
13955 minis.style.maxHeight = 'none';
13956 return;
13957 }
13958 minis.classList.remove('placed');
13772 13959 if (!plan || n === 0 || plan.mode !== 'sides')
13773 13960 {
13774 13961 minis.classList.remove('sides');
@@ -13784,6 +13971,7 @@ function applyMinisContainer (plan)
13784 13971 kids[i].style.top = '';
13785 13972 kids[i].style.width = '';
13786 13973 kids[i].style.position = '';
13974 kids[i].style.fontSize = '';
13787 13975 }
13788 13976 return;
13789 13977 }
@@ -13802,10 +13990,20 @@ function applyMinisLayout ()
13802 13990 if (!minis)
13803 13991 { return; }
13804 13992 applyMinisContainer(plan);
13805 if (!plan || plan.mode !== 'sides')
13993 if (!plan || !plan.n || (plan.mode !== 'sides' && plan.mode !== 'top'))
13806 13994 { return; }
13807 13995 var positions = plan.positions || [];
13808 13996 var kids = minis.querySelectorAll('.mini');
13997 if (plan.mode === 'top' && kids.length && typeof MiniLayout !== 'undefined' && MiniLayout.topPositions)
13998 {
13999 // t1203: if they do not all fit even at the minimum size, defeated
14000 // opponents move to the back (stable), so the living stay visible.
14001 var elim = [];
14002 for (var k = 0; k < kids.length; k++)
14003 { elim.push(kids[k].classList.contains('eliminated')); }
14004 positions = MiniLayout.topPositions(elim, plan);
14005 plan.positions = positions;
14006 }
13809 14007 for (var i = 0; i < positions.length && i < kids.length; i++)
13810 14008 {
13811 14009 var p = positions[i];
@@ -13814,6 +14012,8 @@ function applyMinisLayout ()
13814 14012 el.style.left = p.x + 'px';
13815 14013 el.style.top = p.y + 'px';
13816 14014 el.style.width = p.w + 'px';
14015 el.style.fontSize = p.font ? p.font + 'px' : '';
14016 el.setAttribute('data-slot', p.slot != null ? String(p.slot) : String(i));
13817 14017 var canvas = el.querySelector('canvas');
13818 14018 if (canvas)
13819 14019 {
@@ -8893,6 +8893,152 @@ function sidePositions (n, fieldX, fieldY, fieldW, fieldH, mini, hudH, vw, colsP
8893 return positions;
8893 return positions;
8894}
8894}
8895
8895
8896/* ---- t1203: top-row minis scale down so they all fit above the field ---- */
8897
8898/** Horizontal / vertical gap between top-row minis (px). */
8899var TOP_GAP = 8;
8900var TOP_VGAP = 4;
8901/** Padding above the first top row (matches #minis padding-top). */
8902var TOP_PAD = 6;
8903/** Largest and smallest mini canvas width in the top row (px). 32 px is
8904 * 3.2 px per column: the smallest size that still reads as a field. */
8905var TOP_MAX_W = 80;
8906var TOP_MIN_W = 32;
8907/** Label font: 11 px at full size, never below 9 px. */
8908var TOP_FONT_MAX = 11;
8909var TOP_FONT_MIN = 9;
8910
8911/** Size of one top-row mini for a canvas width `w` (px). */
8912function topMiniForWidth (w)
8913{
8914 w = Math.max(TOP_MIN_W, Math.min(TOP_MAX_W, Math.round(w)));
8915 var h = Math.round(w * 13 / 10);
8916 var font = Math.max(TOP_FONT_MIN, Math.min(TOP_FONT_MAX, Math.round(TOP_FONT_MAX * w / TOP_MAX_W)));
8917 var labelH = Math.round(font * 2.9);
8918 var outerW = w + Math.max(4, Math.round(10 * w / TOP_MAX_W));
8919 return {
8920 w: w,
8921 h: h,
8922 outerW: outerW,
8923 outerH: h + labelH + 2,
8924 font: font,
8925 labelH: labelH,
8926 scale: w / TOP_MAX_W
8927 };
8928}
8929
8930function topGrid (n, availW, mini)
8931{
8932 var cols = Math.max(1, Math.floor((availW + TOP_GAP) / (mini.outerW + TOP_GAP)));
8933 cols = Math.min(cols, Math.max(1, n));
8934 var rows = Math.max(1, Math.ceil(n / cols));
8935 // Balance the rows (6 → 3 + 3 rather than 5 + 1).
8936 cols = Math.max(1, Math.ceil(n / rows));
8937 return { cols: cols, rows: rows, height: rows * mini.outerH + (rows - 1) * TOP_VGAP };
8938}
8939
8940/**
8941 * The largest top-row mini so that all `n` fit in `availW` × `bandH`
8942 * (t1203). If even TOP_MIN_W does not fit, return the minimum size with
8943 * fits = false and `capacity` = how many still fit above the field.
8944 */
8945function topMiniFit (n, availW, bandH)
8946{
8947 n = Math.max(0, n || 0);
8948 for (var w = TOP_MAX_W; w >= TOP_MIN_W; w--)
8949 {
8950 var m = topMiniForWidth(w);
8951 var g = topGrid(n, availW, m);
8952 if (g.height <= bandH)
8953 {
8954 m.cols = g.cols;
8955 m.rows = g.rows;
8956 m.fits = true;
8957 m.capacity = Math.max(n, g.cols * g.rows);
8958 return m;
8959 }
8960 }
8961 var min = topMiniForWidth(TOP_MIN_W);
8962 var maxCols = Math.max(1, Math.floor((availW + TOP_GAP) / (min.outerW + TOP_GAP)));
8963 var rowsFit = Math.max(1, Math.floor((bandH + TOP_VGAP) / (min.outerH + TOP_VGAP)));
8964 min.cols = maxCols;
8965 min.rows = Math.ceil(n / maxCols);
8966 min.fits = false;
8967 min.capacity = maxCols * rowsFit;
8968 return min;
8969}
8970
8971/**
8972 * Slot per opponent (t1203). When everything fits, slot = index (order
8973 * unchanged). Only when they do not fit: alive opponents first, then the
8974 * eliminated ones, each group in its original order (stable), so the
8975 * ones that end up behind the field are the defeated ones.
8976 * @param {boolean[]} eliminated per original index
8977 * @return {number[]} slot for each original index
8978 */
8979function topSlots (eliminated, fits)
8980{
8981 var n = eliminated.length;
8982 var slots = new Array(n);
8983 if (fits)
8984 {
8985 for (var i = 0; i < n; i++)
8986 { slots[i] = i; }
8987 return slots;
8988 }
8989 var next = 0;
8990 for (var a = 0; a < n; a++)
8991 {
8992 if (!eliminated[a])
8993 { slots[a] = next++; }
8994 }
8995 for (var e = 0; e < n; e++)
8996 {
8997 if (eliminated[e])
8998 { slots[e] = next++; }
8999 }
9000 return slots;
9001}
9002
9003/** Viewport position of top-row slot `slot` (rows centred). */
9004function topSlotPosition (slot, n, plan)
9005{
9006 var mini = plan.mini;
9007 var cols = mini.cols || 1;
9008 var row = Math.floor(slot / cols);
9009 var inRow = Math.min(cols, n - row * cols);
9010 var rowW = inRow * mini.outerW + (inRow - 1) * TOP_GAP;
9011 var x0 = Math.round((plan.vw - rowW) / 2);
9012 return {
9013 slot: slot,
9014 row: row,
9015 x: x0 + (slot % cols) * (mini.outerW + TOP_GAP),
9016 y: plan.hudH + TOP_PAD + row * (mini.outerH + TOP_VGAP),
9017 w: mini.outerW,
9018 h: mini.outerH,
9019 canvasW: mini.w,
9020 canvasH: mini.h,
9021 font: mini.font,
9022 aboveField: (plan.hudH + TOP_PAD + row * (mini.outerH + TOP_VGAP) + mini.outerH) <= plan.fieldY + 0.5
9023 };
9024}
9025
9026/** Positions per original index for the top row (t1203). */
9027function topPositions (eliminated, plan)
9028{
9029 var n = eliminated.length;
9030 var slots = topSlots(eliminated, plan.mini && plan.mini.fits);
9031 var out = [];
9032 for (var i = 0; i < n; i++)
9033 {
9034 var pos = topSlotPosition(slots[i], n, plan);
9035 pos.index = i;
9036 pos.eliminated = !!eliminated[i];
9037 out.push(pos);
9038 }
9039 return out;
9040}
9041
8896function isPortraitNarrow (vw, vh)
9042function isPortraitNarrow (vw, vh)
8897{
9043{
8898 if (vw < PORTRAIT_NARROW)
9044 if (vw < PORTRAIT_NARROW)
@@ -8998,7 +9144,24 @@ function plan (vw, vh, n, hudH, margin)
8998 var fieldY = topBand + Math.floor((vh - topBand - fieldH - margin / 2) / 2);
9144 var fieldY = topBand + Math.floor((vh - topBand - fieldH - margin / 2) / 2);
8999 if (fieldY < topBand)
9145 if (fieldY < topBand)
9000 { fieldY = topBand; }
9146 { fieldY = topBand; }
9001 return finish('top', tile, fieldX, fieldY, miniH, miniTop, [], 0);
9147 if (n > 0)
9148 {
9149 // t1203: scale the minis so all of them fit in the band above the
9150 // field (band = from below the HUD to the top of the field).
9151 var bandH = Math.max(0, fieldY - hudH - TOP_PAD - 2);
9152 miniTop = topMiniFit(n, Math.max(40, vw - 2 * TOP_GAP), bandH);
9153 }
9154 var res = finish('top', tile, fieldX, fieldY, miniH, miniTop, [], 0);
9155 res.vw = vw;
9156 res.hudH = hudH;
9157 if (n > 0)
9158 {
9159 var none = [];
9160 for (var k = 0; k < n; k++)
9161 { none.push(false); }
9162 res.positions = topPositions(none, res);
9163 }
9164 return res;
9002}
9165}
9003
9166
9004var api = {
9167var api = {
@@ -9010,6 +9173,17 @@ var api = {
9010 PORTRAIT_NARROW: PORTRAIT_NARROW,
9173 PORTRAIT_NARROW: PORTRAIT_NARROW,
9011 LABEL_H: LABEL_H,
9174 LABEL_H: LABEL_H,
9012 canvasSize: canvasSize,
9175 canvasSize: canvasSize,
9176 TOP_GAP: TOP_GAP,
9177 TOP_VGAP: TOP_VGAP,
9178 TOP_PAD: TOP_PAD,
9179 TOP_MAX_W: TOP_MAX_W,
9180 TOP_MIN_W: TOP_MIN_W,
9181 TOP_FONT_MIN: TOP_FONT_MIN,
9182 topMiniForWidth: topMiniForWidth,
9183 topMiniFit: topMiniFit,
9184 topSlots: topSlots,
9185 topSlotPosition: topSlotPosition,
9186 topPositions: topPositions,
9013 colsThatFit: colsThatFit,
9187 colsThatFit: colsThatFit,
9014 sidePositions: sidePositions,
9188 sidePositions: sidePositions,
9015 plan: plan
9189 plan: plan
@@ -13769,6 +13943,19 @@ function applyMinisContainer (plan)
13769 { return; }
13943 { return; }
13770 var n = plan ? plan.n : 0;
13944 var n = plan ? plan.n : 0;
13771 minis.classList.toggle('crowded', n > 5);
13945 minis.classList.toggle('crowded', n > 5);
13946 if (plan && n > 0 && plan.mode === 'top' && plan.mini && plan.mini.cols)
13947 {
13948 // t1203: top row is placed absolutely too, scaled to fit above the field.
13949 minis.classList.remove('sides');
13950 minis.classList.add('placed');
13951 minis.style.top = '0';
13952 minis.style.bottom = '0';
13953 minis.style.left = '0';
13954 minis.style.right = '0';
13955 minis.style.maxHeight = 'none';
13956 return;
13957 }
13958 minis.classList.remove('placed');
13772 if (!plan || n === 0 || plan.mode !== 'sides')
13959 if (!plan || n === 0 || plan.mode !== 'sides')
13773 {
13960 {
13774 minis.classList.remove('sides');
13961 minis.classList.remove('sides');
@@ -13784,6 +13971,7 @@ function applyMinisContainer (plan)
13784 kids[i].style.top = '';
13971 kids[i].style.top = '';
13785 kids[i].style.width = '';
13972 kids[i].style.width = '';
13786 kids[i].style.position = '';
13973 kids[i].style.position = '';
13974 kids[i].style.fontSize = '';
13787 }
13975 }
13788 return;
13976 return;
13789 }
13977 }
@@ -13802,10 +13990,20 @@ function applyMinisLayout ()
13802 if (!minis)
13990 if (!minis)
13803 { return; }
13991 { return; }
13804 applyMinisContainer(plan);
13992 applyMinisContainer(plan);
13805 if (!plan || plan.mode !== 'sides')
13993 if (!plan || !plan.n || (plan.mode !== 'sides' && plan.mode !== 'top'))
13806 { return; }
13994 { return; }
13807 var positions = plan.positions || [];
13995 var positions = plan.positions || [];
13808 var kids = minis.querySelectorAll('.mini');
13996 var kids = minis.querySelectorAll('.mini');
13997 if (plan.mode === 'top' && kids.length && typeof MiniLayout !== 'undefined' && MiniLayout.topPositions)
13998 {
13999 // t1203: if they do not all fit even at the minimum size, defeated
14000 // opponents move to the back (stable), so the living stay visible.
14001 var elim = [];
14002 for (var k = 0; k < kids.length; k++)
14003 { elim.push(kids[k].classList.contains('eliminated')); }
14004 positions = MiniLayout.topPositions(elim, plan);
14005 plan.positions = positions;
14006 }
13809 for (var i = 0; i < positions.length && i < kids.length; i++)
14007 for (var i = 0; i < positions.length && i < kids.length; i++)
13810 {
14008 {
13811 var p = positions[i];
14009 var p = positions[i];
@@ -13814,6 +14012,8 @@ function applyMinisLayout ()
13814 el.style.left = p.x + 'px';
14012 el.style.left = p.x + 'px';
13815 el.style.top = p.y + 'px';
14013 el.style.top = p.y + 'px';
13816 el.style.width = p.w + 'px';
14014 el.style.width = p.w + 'px';
14015 el.style.fontSize = p.font ? p.font + 'px' : '';
14016 el.setAttribute('data-slot', p.slot != null ? String(p.slot) : String(i));
13817 var canvas = el.querySelector('canvas');
14017 var canvas = el.querySelector('canvas');
13818 if (canvas)
14018 if (canvas)
13819 {
14019 {
build/style.css +24 −0
@@ -1131,3 +1131,27 @@ html[lang="ja"], html[lang="zh-Hans"], html[lang="ko"] {
1131 1131 font-size: 14px;
1132 1132 }
1133 1133 .planet-mode:empty, .game-menu-mode:empty { display: none; }
1134
1135 /* t1203: top-row minis placed (and scaled) by MiniLayout.topPositions. */
1136 #minis.placed {
1137 inset: 0;
1138 display: block;
1139 padding: 0;
1140 overflow: visible;
1141 max-height: none;
1142 gap: 0;
1143 }
1144 #minis.placed .mini {
1145 position: absolute;
1146 margin: 0;
1147 min-width: 0;
1148 line-height: 1.3;
1149 }
1150 #minis.placed .mini-name { max-width: 100%; }
1151 #minis.placed .mini-meta {
1152 max-width: 100%;
1153 overflow: hidden;
1154 text-overflow: ellipsis;
1155 white-space: nowrap;
1156 }
1157 #minis.placed .mini-canvas { margin: 0 auto; }
@@ -1131,3 +1131,27 @@ html[lang="ja"], html[lang="zh-Hans"], html[lang="ko"] {
1131 font-size: 14px;
1131 font-size: 14px;
1132}
1132}
1133.planet-mode:empty, .game-menu-mode:empty { display: none; }
1133.planet-mode:empty, .game-menu-mode:empty { display: none; }
1134
1135/* t1203: top-row minis placed (and scaled) by MiniLayout.topPositions. */
1136#minis.placed {
1137 inset: 0;
1138 display: block;
1139 padding: 0;
1140 overflow: visible;
1141 max-height: none;
1142 gap: 0;
1143}
1144#minis.placed .mini {
1145 position: absolute;
1146 margin: 0;
1147 min-width: 0;
1148 line-height: 1.3;
1149}
1150#minis.placed .mini-name { max-width: 100%; }
1151#minis.placed .mini-meta {
1152 max-width: 100%;
1153 overflow: hidden;
1154 text-overflow: ellipsis;
1155 white-space: nowrap;
1156}
1157#minis.placed .mini-canvas { margin: 0 auto; }
docs/ASSUMPTIONS.md +38 −0
@@ -1321,3 +1321,41 @@ t1197 (“totaal van de laatste lancering”).
1321 1321 modus is.
1322 1322 - De knop onderaan het planeetscherm blijft “Spelen” (start), ook bij
1323 1323 Overleven; het label erboven noemt de modus.
1324
1325 ## t1203 — Miniaturen schalen op smalle schermen
1326
1327 **Probleem.** In de bovenrij (smal/staand scherm) hadden de miniaturen
1328 vaste maten per aantal (80/56/40 px breed) en liepen ze via flex-wrap
1329 naar een tweede rij. Bij bijv. 6 bots op ~460 px kwam de 6e op een
1330 tweede rij die (deels) achter het eigen veld viel.
1331
1332 **Oplossing (`src/miniLayout.js`, gedeeld door Spelen/bots en Online).**
1333 - De beschikbare band is de hele ruimte tussen de HUD en de bovenkant van
1334 het eigen veld (niet alleen de vaste `miniH`), over de schermbreedte.
1335 - `topMiniFit(n, breedte, bandhoogte)` zoekt de **grootste** mini
1336 (canvasbreedte 80 → 32 px, hoogte 13/10 daarvan) waarbij alle *n* in
1337 de band passen, eventueel in meerdere rijen; de rijen worden
1338 gebalanceerd (6 → 3 + 3, niet 5 + 1) en gecentreerd. Het label schaalt
1339 mee: 11 px bij volle maat, **minimaal 9 px**; namen worden zo nodig
1340 afgekapt met “…”.
1341 - **Gekozen minimum: 32 px canvasbreedte (×42 px hoog), labels 9 px.**
1342 Dat is 3,2 px per kolom: kleiner leest het veld niet meer als veld en
1343 is 9 px tekst niet meer leesbaar. Gemeten: 6 bots → 62 px (412×915),
1344 57 px (360×800), 59 px (460×900, één rij); 12 → 52/44/54 px;
1345 16 → 37/33/43 px. Tot ~16–20 tegenstanders past alles op een telefoon.
1346 - De bovenrij wordt nu, net als de zij-layout, absoluut geplaatst
1347 (`#minis.placed`), zodat er niets meer onvoorspelbaar wrapt.
1348
1349 **Sorteren alleen bij echt te veel.** Zolang alles past blijft de
1350 volgorde exact zoals hij was (ook met verslagen tegenstanders). Past het
1351 zelfs bij 32 px niet (bijv. 31 bots op 360×800: 24 plekken), dan krijgen
1352 eerst alle levende tegenstanders een plek en daarna de verslagen, elk in
1353 de oorspronkelijke volgorde (stabiel). Alles wat niet meer past komt in
1354 de rijen eronder, dus achter het veld — en dat zijn dan alleen verslagen
1355 tegenstanders. (Zijn er meer levenden dan plekken, dan vallen de laatste
1356 levenden er alsnog achter; dat komt pas voor bij 25+ levende
1357 tegenstanders op een telefoon.) De volgorde wordt bij elke update
1358 opnieuw bepaald, dus een tegenstander die uitvalt schuift pas dan naar
1359 achteren.
1360
1361 Brede schermen (zij-layout) zijn ongewijzigd.
@@ -1321,3 +1321,41 @@ t1197 (“totaal van de laatste lancering”).
1321 modus is.
1321 modus is.
1322- De knop onderaan het planeetscherm blijft “Spelen” (start), ook bij
1322- De knop onderaan het planeetscherm blijft “Spelen” (start), ook bij
1323 Overleven; het label erboven noemt de modus.
1323 Overleven; het label erboven noemt de modus.
1324
1325## t1203 — Miniaturen schalen op smalle schermen
1326
1327**Probleem.** In de bovenrij (smal/staand scherm) hadden de miniaturen
1328vaste maten per aantal (80/56/40 px breed) en liepen ze via flex-wrap
1329naar een tweede rij. Bij bijv. 6 bots op ~460 px kwam de 6e op een
1330tweede rij die (deels) achter het eigen veld viel.
1331
1332**Oplossing (`src/miniLayout.js`, gedeeld door Spelen/bots en Online).**
1333- De beschikbare band is de hele ruimte tussen de HUD en de bovenkant van
1334 het eigen veld (niet alleen de vaste `miniH`), over de schermbreedte.
1335- `topMiniFit(n, breedte, bandhoogte)` zoekt de **grootste** mini
1336 (canvasbreedte 80 → 32 px, hoogte 13/10 daarvan) waarbij alle *n* in
1337 de band passen, eventueel in meerdere rijen; de rijen worden
1338 gebalanceerd (6 → 3 + 3, niet 5 + 1) en gecentreerd. Het label schaalt
1339 mee: 11 px bij volle maat, **minimaal 9 px**; namen worden zo nodig
1340 afgekapt met “…”.
1341- **Gekozen minimum: 32 px canvasbreedte (×42 px hoog), labels 9 px.**
1342 Dat is 3,2 px per kolom: kleiner leest het veld niet meer als veld en
1343 is 9 px tekst niet meer leesbaar. Gemeten: 6 bots → 62 px (412×915),
1344 57 px (360×800), 59 px (460×900, één rij); 12 → 52/44/54 px;
1345 16 → 37/33/43 px. Tot ~16–20 tegenstanders past alles op een telefoon.
1346- De bovenrij wordt nu, net als de zij-layout, absoluut geplaatst
1347 (`#minis.placed`), zodat er niets meer onvoorspelbaar wrapt.
1348
1349**Sorteren alleen bij echt te veel.** Zolang alles past blijft de
1350volgorde exact zoals hij was (ook met verslagen tegenstanders). Past het
1351zelfs bij 32 px niet (bijv. 31 bots op 360×800: 24 plekken), dan krijgen
1352eerst alle levende tegenstanders een plek en daarna de verslagen, elk in
1353de oorspronkelijke volgorde (stabiel). Alles wat niet meer past komt in
1354de rijen eronder, dus achter het veld — en dat zijn dan alleen verslagen
1355tegenstanders. (Zijn er meer levenden dan plekken, dan vallen de laatste
1356levenden er alsnog achter; dat komt pas voor bij 25+ levende
1357tegenstanders op een telefoon.) De volgorde wordt bij elke update
1358opnieuw bepaald, dus een tegenstander die uitvalt schuift pas dan naar
1359achteren.
1360
1361Brede schermen (zij-layout) zijn ongewijzigd.
src/main.js +27 −1
@@ -457,6 +457,19 @@ function applyMinisContainer (plan)
457 457 { return; }
458 458 var n = plan ? plan.n : 0;
459 459 minis.classList.toggle('crowded', n > 5);
460 if (plan && n > 0 && plan.mode === 'top' && plan.mini && plan.mini.cols)
461 {
462 // t1203: top row is placed absolutely too, scaled to fit above the field.
463 minis.classList.remove('sides');
464 minis.classList.add('placed');
465 minis.style.top = '0';
466 minis.style.bottom = '0';
467 minis.style.left = '0';
468 minis.style.right = '0';
469 minis.style.maxHeight = 'none';
470 return;
471 }
472 minis.classList.remove('placed');
460 473 if (!plan || n === 0 || plan.mode !== 'sides')
461 474 {
462 475 minis.classList.remove('sides');
@@ -472,6 +485,7 @@ function applyMinisContainer (plan)
472 485 kids[i].style.top = '';
473 486 kids[i].style.width = '';
474 487 kids[i].style.position = '';
488 kids[i].style.fontSize = '';
475 489 }
476 490 return;
477 491 }
@@ -490,10 +504,20 @@ function applyMinisLayout ()
490 504 if (!minis)
491 505 { return; }
492 506 applyMinisContainer(plan);
493 if (!plan || plan.mode !== 'sides')
507 if (!plan || !plan.n || (plan.mode !== 'sides' && plan.mode !== 'top'))
494 508 { return; }
495 509 var positions = plan.positions || [];
496 510 var kids = minis.querySelectorAll('.mini');
511 if (plan.mode === 'top' && kids.length && typeof MiniLayout !== 'undefined' && MiniLayout.topPositions)
512 {
513 // t1203: if they do not all fit even at the minimum size, defeated
514 // opponents move to the back (stable), so the living stay visible.
515 var elim = [];
516 for (var k = 0; k < kids.length; k++)
517 { elim.push(kids[k].classList.contains('eliminated')); }
518 positions = MiniLayout.topPositions(elim, plan);
519 plan.positions = positions;
520 }
497 521 for (var i = 0; i < positions.length && i < kids.length; i++)
498 522 {
499 523 var p = positions[i];
@@ -502,6 +526,8 @@ function applyMinisLayout ()
502 526 el.style.left = p.x + 'px';
503 527 el.style.top = p.y + 'px';
504 528 el.style.width = p.w + 'px';
529 el.style.fontSize = p.font ? p.font + 'px' : '';
530 el.setAttribute('data-slot', p.slot != null ? String(p.slot) : String(i));
505 531 var canvas = el.querySelector('canvas');
506 532 if (canvas)
507 533 {
@@ -457,6 +457,19 @@ function applyMinisContainer (plan)
457 { return; }
457 { return; }
458 var n = plan ? plan.n : 0;
458 var n = plan ? plan.n : 0;
459 minis.classList.toggle('crowded', n > 5);
459 minis.classList.toggle('crowded', n > 5);
460 if (plan && n > 0 && plan.mode === 'top' && plan.mini && plan.mini.cols)
461 {
462 // t1203: top row is placed absolutely too, scaled to fit above the field.
463 minis.classList.remove('sides');
464 minis.classList.add('placed');
465 minis.style.top = '0';
466 minis.style.bottom = '0';
467 minis.style.left = '0';
468 minis.style.right = '0';
469 minis.style.maxHeight = 'none';
470 return;
471 }
472 minis.classList.remove('placed');
460 if (!plan || n === 0 || plan.mode !== 'sides')
473 if (!plan || n === 0 || plan.mode !== 'sides')
461 {
474 {
462 minis.classList.remove('sides');
475 minis.classList.remove('sides');
@@ -472,6 +485,7 @@ function applyMinisContainer (plan)
472 kids[i].style.top = '';
485 kids[i].style.top = '';
473 kids[i].style.width = '';
486 kids[i].style.width = '';
474 kids[i].style.position = '';
487 kids[i].style.position = '';
488 kids[i].style.fontSize = '';
475 }
489 }
476 return;
490 return;
477 }
491 }
@@ -490,10 +504,20 @@ function applyMinisLayout ()
490 if (!minis)
504 if (!minis)
491 { return; }
505 { return; }
492 applyMinisContainer(plan);
506 applyMinisContainer(plan);
493 if (!plan || plan.mode !== 'sides')
507 if (!plan || !plan.n || (plan.mode !== 'sides' && plan.mode !== 'top'))
494 { return; }
508 { return; }
495 var positions = plan.positions || [];
509 var positions = plan.positions || [];
496 var kids = minis.querySelectorAll('.mini');
510 var kids = minis.querySelectorAll('.mini');
511 if (plan.mode === 'top' && kids.length && typeof MiniLayout !== 'undefined' && MiniLayout.topPositions)
512 {
513 // t1203: if they do not all fit even at the minimum size, defeated
514 // opponents move to the back (stable), so the living stay visible.
515 var elim = [];
516 for (var k = 0; k < kids.length; k++)
517 { elim.push(kids[k].classList.contains('eliminated')); }
518 positions = MiniLayout.topPositions(elim, plan);
519 plan.positions = positions;
520 }
497 for (var i = 0; i < positions.length && i < kids.length; i++)
521 for (var i = 0; i < positions.length && i < kids.length; i++)
498 {
522 {
499 var p = positions[i];
523 var p = positions[i];
@@ -502,6 +526,8 @@ function applyMinisLayout ()
502 el.style.left = p.x + 'px';
526 el.style.left = p.x + 'px';
503 el.style.top = p.y + 'px';
527 el.style.top = p.y + 'px';
504 el.style.width = p.w + 'px';
528 el.style.width = p.w + 'px';
529 el.style.fontSize = p.font ? p.font + 'px' : '';
530 el.setAttribute('data-slot', p.slot != null ? String(p.slot) : String(i));
505 var canvas = el.querySelector('canvas');
531 var canvas = el.querySelector('canvas');
506 if (canvas)
532 if (canvas)
507 {
533 {
src/miniLayout.js +175 −1
@@ -137,6 +137,152 @@ function sidePositions (n, fieldX, fieldY, fieldW, fieldH, mini, hudH, vw, colsP
137 137 return positions;
138 138 }
139 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
140 286 function isPortraitNarrow (vw, vh)
141 287 {
142 288 if (vw < PORTRAIT_NARROW)
@@ -242,7 +388,24 @@ function plan (vw, vh, n, hudH, margin)
242 388 var fieldY = topBand + Math.floor((vh - topBand - fieldH - margin / 2) / 2);
243 389 if (fieldY < topBand)
244 390 { fieldY = topBand; }
245 return finish('top', tile, fieldX, fieldY, miniH, miniTop, [], 0);
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;
246 409 }
247 410
248 411 var api = {
@@ -254,6 +417,17 @@ var api = {
254 417 PORTRAIT_NARROW: PORTRAIT_NARROW,
255 418 LABEL_H: LABEL_H,
256 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,
257 431 colsThatFit: colsThatFit,
258 432 sidePositions: sidePositions,
259 433 plan: plan
@@ -137,6 +137,152 @@ function sidePositions (n, fieldX, fieldY, fieldW, fieldH, mini, hudH, vw, colsP
137 return positions;
137 return positions;
138}
138}
139
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). */
143var TOP_GAP = 8;
144var TOP_VGAP = 4;
145/** Padding above the first top row (matches #minis padding-top). */
146var 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. */
149var TOP_MAX_W = 80;
150var TOP_MIN_W = 32;
151/** Label font: 11 px at full size, never below 9 px. */
152var TOP_FONT_MAX = 11;
153var TOP_FONT_MIN = 9;
154
155/** Size of one top-row mini for a canvas width `w` (px). */
156function 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
174function 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 */
189function 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 */
223function 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). */
248function 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). */
271function 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
140function isPortraitNarrow (vw, vh)
286function isPortraitNarrow (vw, vh)
141{
287{
142 if (vw < PORTRAIT_NARROW)
288 if (vw < PORTRAIT_NARROW)
@@ -242,7 +388,24 @@ function plan (vw, vh, n, hudH, margin)
242 var fieldY = topBand + Math.floor((vh - topBand - fieldH - margin / 2) / 2);
388 var fieldY = topBand + Math.floor((vh - topBand - fieldH - margin / 2) / 2);
243 if (fieldY < topBand)
389 if (fieldY < topBand)
244 { fieldY = topBand; }
390 { fieldY = topBand; }
245 return finish('top', tile, fieldX, fieldY, miniH, miniTop, [], 0);
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;
246}
409}
247
410
248var api = {
411var api = {
@@ -254,6 +417,17 @@ var api = {
254 PORTRAIT_NARROW: PORTRAIT_NARROW,
417 PORTRAIT_NARROW: PORTRAIT_NARROW,
255 LABEL_H: LABEL_H,
418 LABEL_H: LABEL_H,
256 canvasSize: canvasSize,
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,
257 colsThatFit: colsThatFit,
431 colsThatFit: colsThatFit,
258 sidePositions: sidePositions,
432 sidePositions: sidePositions,
259 plan: plan
433 plan: plan
test/mini-layout.test.js +1 −1
@@ -35,7 +35,7 @@ describe('MiniLayout (t1125 / t1127 / t1131 / t1133)', () =>
35 35 const narrow = plan(720, 800, 2);
36 36 assert.equal(narrow.mode, 'top', '720-tall-ish keeps the top row');
37 37 assert.ok(narrow.miniH > 0, 'top mode reserves height above the field');
38 assert.equal(narrow.positions.length, 0);
38 assert.equal(narrow.positions.length, 2, 'top mode also places its minis (t1203)');
39 39
40 40 const mobile = plan(393, 851, 1);
41 41 assert.equal(mobile.mode, 'top', 'phone stays on the top layout');
@@ -35,7 +35,7 @@ describe('MiniLayout (t1125 / t1127 / t1131 / t1133)', () =>
35 const narrow = plan(720, 800, 2);
35 const narrow = plan(720, 800, 2);
36 assert.equal(narrow.mode, 'top', '720-tall-ish keeps the top row');
36 assert.equal(narrow.mode, 'top', '720-tall-ish keeps the top row');
37 assert.ok(narrow.miniH > 0, 'top mode reserves height above the field');
37 assert.ok(narrow.miniH > 0, 'top mode reserves height above the field');
38 assert.equal(narrow.positions.length, 0);
38 assert.equal(narrow.positions.length, 2, 'top mode also places its minis (t1203)');
39
39
40 const mobile = plan(393, 851, 1);
40 const mobile = plan(393, 851, 1);
41 assert.equal(mobile.mode, 'top', 'phone stays on the top layout');
41 assert.equal(mobile.mode, 'top', 'phone stays on the top layout');
test/mini-top-scale.test.js added +123 −0
@@ -0,0 +1,123 @@
1 'use strict';
2
3 // t1203: on narrow / portrait screens the opponent minis shrink so they all
4 // fit above the player's field; only if even the minimum size does not fit,
5 // defeated opponents are sorted to the back (stable).
6
7 const { describe, it } = require('node:test');
8 const assert = require('node:assert/strict');
9 const L = require('../src/miniLayout.js');
10
11 const hudFor = (vh) => Math.max(56, Math.round(vh * 0.09));
12 const plan = (vw, vh, n) => L.plan(vw, vh, n, hudFor(vh), Math.max(6, Math.round(Math.min(vw, vh) * 0.015)));
13
14 function noOverlap (ps)
15 {
16 for (let i = 0; i < ps.length; i++)
17 for (let j = i + 1; j < ps.length; j++)
18 {
19 const a = ps[i], b = ps[j];
20 const sep = a.x + a.w <= b.x || b.x + b.w <= a.x || a.y + a.h <= b.y || b.y + b.h <= a.y;
21 if (!sep) return false;
22 }
23 return true;
24 }
25
26 describe('Top-row mini scaling (t1203)', () =>
27 {
28 it('constants: 80 px max, 32 px min canvas width, 9 px min label font', () =>
29 {
30 assert.equal(L.TOP_MAX_W, 80);
31 assert.equal(L.TOP_MIN_W, 32);
32 assert.equal(L.TOP_FONT_MIN, 9);
33 const m = L.topMiniForWidth(10);
34 assert.equal(m.w, 32);
35 assert.equal(m.h, Math.round(32 * 1.3));
36 assert.ok(m.font >= 9);
37 });
38
39 for (const [vw, vh] of [[412, 915], [360, 800], [460, 900], [390, 844]])
40 {
41 for (const n of [6, 7, 8, 10, 12, 16])
42 {
43 it(`${vw}x${vh}, ${n} opponents: all fit above the field, inside the screen, no overlap`, () =>
44 {
45 const p = plan(vw, vh, n);
46 assert.equal(p.mode, 'top');
47 assert.equal(p.mini.fits, true);
48 assert.equal(p.positions.length, n);
49 for (const q of p.positions)
50 {
51 assert.ok(q.aboveField, `slot ${q.slot} bottom ${q.y + q.h} <= field top ${p.fieldY}`);
52 assert.ok(q.x >= 0 && q.x + q.w <= vw, `slot ${q.slot} inside the screen`);
53 assert.ok(q.y >= p.hudH, 'below the HUD');
54 }
55 assert.ok(noOverlap(p.positions));
56 assert.ok(p.mini.w >= L.TOP_MIN_W && p.mini.w <= L.TOP_MAX_W);
57 });
58 }
59 }
60
61 it('few opponents keep the full size; more opponents shrink monotonically', () =>
62 {
63 assert.equal(plan(412, 915, 3).mini.w, 80);
64 let prev = Infinity;
65 for (const n of [3, 6, 12, 16, 20])
66 {
67 const w = plan(412, 915, n).mini.w;
68 assert.ok(w <= prev, n + ': ' + w);
69 prev = w;
70 }
71 });
72
73 it("Tim's case: 6 bots at ~460 px portrait no longer spill behind the field", () =>
74 {
75 const p = plan(460, 900, 6);
76 assert.ok(p.positions.every((q) => q.aboveField));
77 });
78
79 it('order is unchanged while everything fits, even with defeated opponents', () =>
80 {
81 const p = plan(412, 915, 6);
82 const elim = [true, false, true, false, false, false];
83 const pos = L.topPositions(elim, p);
84 assert.deepEqual(pos.map((q) => q.slot), [0, 1, 2, 3, 4, 5]);
85 });
86
87 it('when they do not fit even at the minimum: living first, defeated last, stable', () =>
88 {
89 assert.deepEqual(L.topSlots([true, false, true, false, false], false), [3, 0, 4, 1, 2]);
90 assert.deepEqual(L.topSlots([false, false, false], false), [0, 1, 2]);
91 assert.deepEqual(L.topSlots([true, true], false), [0, 1]);
92 });
93
94 it('overflow at 360x800 with 31 opponents: min size, defeated ones are the ones behind the field', () =>
95 {
96 const n = 31;
97 const p = plan(360, 800, n);
98 assert.equal(p.mini.fits, false);
99 assert.equal(p.mini.w, L.TOP_MIN_W);
100 const cap = p.mini.capacity;
101 assert.ok(cap > 0 && cap < n);
102 const elim = Array.from({ length: n }, (_, i) => i % 3 === 0); // 11 defeated
103 const alive = elim.filter((e) => !e).length;
104 assert.ok(alive <= cap, 'all living fit');
105 const pos = L.topPositions(elim, p);
106 for (const q of pos)
107 {
108 if (!q.eliminated) assert.ok(q.aboveField, 'living opponent ' + q.index + ' visible');
109 }
110 const hidden = pos.filter((q) => !q.aboveField);
111 assert.ok(hidden.length > 0 && hidden.every((q) => q.eliminated), 'only defeated ones fall behind');
112 // stable within groups
113 const aliveSlots = pos.filter((q) => !q.eliminated).map((q) => q.slot);
114 assert.deepEqual(aliveSlots, [...aliveSlots].sort((a, b) => a - b));
115 const elimSlots = pos.filter((q) => q.eliminated).map((q) => q.slot);
116 assert.deepEqual(elimSlots, [...elimSlots].sort((a, b) => a - b));
117 });
118
119 it('wide screens still use the side layout (unchanged)', () =>
120 {
121 assert.equal(plan(1280, 900, 6).mode, 'sides');
122 });
123 });
@@ -0,0 +1,123 @@
1'use strict';
2
3// t1203: on narrow / portrait screens the opponent minis shrink so they all
4// fit above the player's field; only if even the minimum size does not fit,
5// defeated opponents are sorted to the back (stable).
6
7const { describe, it } = require('node:test');
8const assert = require('node:assert/strict');
9const L = require('../src/miniLayout.js');
10
11const hudFor = (vh) => Math.max(56, Math.round(vh * 0.09));
12const plan = (vw, vh, n) => L.plan(vw, vh, n, hudFor(vh), Math.max(6, Math.round(Math.min(vw, vh) * 0.015)));
13
14function noOverlap (ps)
15{
16 for (let i = 0; i < ps.length; i++)
17 for (let j = i + 1; j < ps.length; j++)
18 {
19 const a = ps[i], b = ps[j];
20 const sep = a.x + a.w <= b.x || b.x + b.w <= a.x || a.y + a.h <= b.y || b.y + b.h <= a.y;
21 if (!sep) return false;
22 }
23 return true;
24}
25
26describe('Top-row mini scaling (t1203)', () =>
27{
28 it('constants: 80 px max, 32 px min canvas width, 9 px min label font', () =>
29 {
30 assert.equal(L.TOP_MAX_W, 80);
31 assert.equal(L.TOP_MIN_W, 32);
32 assert.equal(L.TOP_FONT_MIN, 9);
33 const m = L.topMiniForWidth(10);
34 assert.equal(m.w, 32);
35 assert.equal(m.h, Math.round(32 * 1.3));
36 assert.ok(m.font >= 9);
37 });
38
39 for (const [vw, vh] of [[412, 915], [360, 800], [460, 900], [390, 844]])
40 {
41 for (const n of [6, 7, 8, 10, 12, 16])
42 {
43 it(`${vw}x${vh}, ${n} opponents: all fit above the field, inside the screen, no overlap`, () =>
44 {
45 const p = plan(vw, vh, n);
46 assert.equal(p.mode, 'top');
47 assert.equal(p.mini.fits, true);
48 assert.equal(p.positions.length, n);
49 for (const q of p.positions)
50 {
51 assert.ok(q.aboveField, `slot ${q.slot} bottom ${q.y + q.h} <= field top ${p.fieldY}`);
52 assert.ok(q.x >= 0 && q.x + q.w <= vw, `slot ${q.slot} inside the screen`);
53 assert.ok(q.y >= p.hudH, 'below the HUD');
54 }
55 assert.ok(noOverlap(p.positions));
56 assert.ok(p.mini.w >= L.TOP_MIN_W && p.mini.w <= L.TOP_MAX_W);
57 });
58 }
59 }
60
61 it('few opponents keep the full size; more opponents shrink monotonically', () =>
62 {
63 assert.equal(plan(412, 915, 3).mini.w, 80);
64 let prev = Infinity;
65 for (const n of [3, 6, 12, 16, 20])
66 {
67 const w = plan(412, 915, n).mini.w;
68 assert.ok(w <= prev, n + ': ' + w);
69 prev = w;
70 }
71 });
72
73 it("Tim's case: 6 bots at ~460 px portrait no longer spill behind the field", () =>
74 {
75 const p = plan(460, 900, 6);
76 assert.ok(p.positions.every((q) => q.aboveField));
77 });
78
79 it('order is unchanged while everything fits, even with defeated opponents', () =>
80 {
81 const p = plan(412, 915, 6);
82 const elim = [true, false, true, false, false, false];
83 const pos = L.topPositions(elim, p);
84 assert.deepEqual(pos.map((q) => q.slot), [0, 1, 2, 3, 4, 5]);
85 });
86
87 it('when they do not fit even at the minimum: living first, defeated last, stable', () =>
88 {
89 assert.deepEqual(L.topSlots([true, false, true, false, false], false), [3, 0, 4, 1, 2]);
90 assert.deepEqual(L.topSlots([false, false, false], false), [0, 1, 2]);
91 assert.deepEqual(L.topSlots([true, true], false), [0, 1]);
92 });
93
94 it('overflow at 360x800 with 31 opponents: min size, defeated ones are the ones behind the field', () =>
95 {
96 const n = 31;
97 const p = plan(360, 800, n);
98 assert.equal(p.mini.fits, false);
99 assert.equal(p.mini.w, L.TOP_MIN_W);
100 const cap = p.mini.capacity;
101 assert.ok(cap > 0 && cap < n);
102 const elim = Array.from({ length: n }, (_, i) => i % 3 === 0); // 11 defeated
103 const alive = elim.filter((e) => !e).length;
104 assert.ok(alive <= cap, 'all living fit');
105 const pos = L.topPositions(elim, p);
106 for (const q of pos)
107 {
108 if (!q.eliminated) assert.ok(q.aboveField, 'living opponent ' + q.index + ' visible');
109 }
110 const hidden = pos.filter((q) => !q.aboveField);
111 assert.ok(hidden.length > 0 && hidden.every((q) => q.eliminated), 'only defeated ones fall behind');
112 // stable within groups
113 const aliveSlots = pos.filter((q) => !q.eliminated).map((q) => q.slot);
114 assert.deepEqual(aliveSlots, [...aliveSlots].sort((a, b) => a - b));
115 const elimSlots = pos.filter((q) => q.eliminated).map((q) => q.slot);
116 assert.deepEqual(elimSlots, [...elimSlots].sort((a, b) => a - b));
117 });
118
119 it('wide screens still use the side layout (unchanged)', () =>
120 {
121 assert.equal(plan(1280, 900, 6).mode, 'sides');
122 });
123});
test/t1203-mini-scale-playwright.py added +87 −0
@@ -0,0 +1,87 @@
1 """t1203: opponent minis scale to fit above the field on narrow portrait screens.
2 Usage: python3 test/t1203-mini-scale-playwright.py ROOT [tag]"""
3 import sys, json
4 from playwright.sync_api import sync_playwright
5 URL = sys.argv[1].rstrip("/") + "/"
6 TAG = sys.argv[2] if len(sys.argv) > 2 else "live"
7 fails = []
8 def check(ok, msg):
9 print(("OK " if ok else "FAIL ") + msg)
10 if not ok: fails.append(msg)
11
12 ROUND_FOR = {6: 12, 8: 23, 12: 57, 16: 107, 31: 437}
13
14 MEASURE = """() => {
15 const minis = [...document.querySelectorAll('#minis .mini')];
16 const fieldTop = app.fieldY, vw = innerWidth;
17 const out = minis.map(el => { const r = el.getBoundingClientRect(); const c = el.querySelector('canvas').getBoundingClientRect();
18 return { id: el.dataset.player, slot: +el.dataset.slot, elim: el.classList.contains('eliminated'),
19 x: r.left, y: r.top, w: r.width, bottom: r.bottom, right: r.right, cw: c.width, ch: c.height, font: parseFloat(getComputedStyle(el).fontSize) }; });
20 return { fieldTop, vw, hud: app.hudH, mini: app.miniLayout.mini, minis: out };
21 }"""
22
23 def start(page, n, elim_idx):
24 page.evaluate(f"""() => {{
25 teardownPlay && teardownPlay();
26 hideEl('menu');
27 app.offline = true;
28 startPlay({{ planet: Planet.defaultPlanet(), offline: true, round: {ROUND_FOR[n]} }});
29 }}""")
30 page.wait_for_function(f"() => app.mode === 'playing' && app.battle && app.battle.bots.length === {n}")
31 page.evaluate("() => { app.core.noSpawn = true; for (const b of app.battle.bots) { b.core.noSpawn = true; } }")
32 if elim_idx:
33 page.evaluate(f"() => {{ for (const i of {json.dumps(elim_idx)}) app.battle.bots[i].core.state = 'gameover'; }}")
34 page.wait_for_timeout(600)
35 return page.evaluate(MEASURE)
36
37 with sync_playwright() as p:
38 br = p.chromium.launch()
39 for vw, vh in ((412, 915), (360, 800), (460, 900)):
40 ctx = br.new_context(viewport={"width": vw, "height": vh}, is_mobile=True, has_touch=True, device_scale_factor=2)
41 page = ctx.new_page(); errs = []
42 page.on("pageerror", lambda e: errs.append(str(e)))
43 page.goto(URL + "index.html", wait_until="networkidle")
44 for n, elim in ((6, []), (6, [1, 4]), (8, [0, 2, 5]), (12, [3]), (16, [0, 1, 2, 3])):
45 m = start(page, n, elim)
46 tag = f"{vw}x{vh}-{n}bots" + (f"-{len(elim)}out" if elim else "")
47 ms = m["minis"]
48 above = all(q["bottom"] <= m["fieldTop"] + 0.5 for q in ms)
49 inside = all(q["x"] >= -0.5 and q["right"] <= m["vw"] + 0.5 and q["y"] >= m["hud"] - 0.5 for q in ms)
50 check(len(ms) == n and above and inside, f"{tag}: all {len(ms)} minis above the field (field top {m['fieldTop']}, lowest {max(q['bottom'] for q in ms):.0f}) and on screen; canvas {m['mini']['w']}x{m['mini']['h']}, font {ms[0]['font']}px")
51 check(m["mini"]["fits"] and [q["slot"] for q in ms] == list(range(n)), f"{tag}: order unchanged while they fit")
52 check(all(abs(q["cw"] - m["mini"]["w"]) < 1 for q in ms) and ms[0]["font"] >= 9, f"{tag}: canvas and label scaled ({ms[0]['cw']:.0f}px, {ms[0]['font']}px)")
53 if vw != 460 or n in (6,):
54 page.screenshot(path=f"/workspace/meteors-shots/t1203-{TAG}-{tag}.png")
55 # overflow: 31 bots, 11 defeated
56 elim = [i for i in range(31) if i % 3 == 0]
57 m = start(page, 31, elim)
58 ms = m["minis"]
59 hidden = [q for q in ms if q["bottom"] > m["fieldTop"] + 0.5]
60 alive_ok = all(q["bottom"] <= m["fieldTop"] + 0.5 for q in ms if not q["elim"])
61 check(not m["mini"]["fits"] and m["mini"]["w"] == 32, f"{vw}x{vh}-31bots: minimum size used (canvas {m['mini']['w']}x{m['mini']['h']}), capacity {m['mini']['capacity']}")
62 check(alive_ok and hidden and all(q["elim"] for q in hidden), f"{vw}x{vh}-31bots: living all visible, only defeated behind the field ({len(hidden)} hidden, all defeated)")
63 alive_slots = [q["slot"] for q in ms if not q["elim"]]
64 check(alive_slots == sorted(alive_slots), f"{vw}x{vh}-31bots: stable order of the living")
65 page.screenshot(path=f"/workspace/meteors-shots/t1203-{TAG}-{vw}x{vh}-31bots-11out.png")
66 # Online uses the same layout: fake an 8-opponent lobby (2 out) and render its minis.
67 page.evaluate("() => { teardownPlay && teardownPlay(); }")
68 m = page.evaluate("""() => {
69 const players = [{ id: 'me', name: 'Ik', is_me: true }];
70 for (let i = 1; i <= 8; i++) players.push({ id: 'p' + i, name: 'Speler ' + i, score: i, eliminated: i === 2 || i === 5, snapshot: { blocks: [] }, planet: Planet.defaultPlanet() });
71 Online.lobby = { players };
72 app.online = true; app.offline = false; app.battle = null;
73 hideEl('menu'); document.getElementById('minis').hidden = false;
74 app._layoutN = -1; layout();
75 Online.renderMinis(document.getElementById('minis'));
76 return true; }""")
77 page.wait_for_timeout(200)
78 m = page.evaluate(MEASURE)
79 ms = m["minis"]
80 check(len(ms) == 8 and all(q["bottom"] <= m["fieldTop"] + 0.5 and q["x"] >= -0.5 and q["right"] <= m["vw"] + 0.5 for q in ms) and abs(ms[0]["cw"] - m["mini"]["w"]) < 1, f"{vw}x{vh}-online-8: online minis use the same scaled top layout (canvas {m['mini']['w']}px, lowest {max(q['bottom'] for q in ms):.0f} <= field {m['fieldTop']})")
81 page.screenshot(path=f"/workspace/meteors-shots/t1203-{TAG}-{vw}x{vh}-online-8.png")
82 page.evaluate("() => { app.online = false; Online.lobby = null; }")
83 check(not errs, f"{vw}x{vh}: no page errors {errs[:2]}")
84 ctx.close()
85 br.close()
86 print("ALL OK" if not fails else f"{len(fails)} FAILED")
87 sys.exit(1 if fails else 0)
@@ -0,0 +1,87 @@
1"""t1203: opponent minis scale to fit above the field on narrow portrait screens.
2Usage: python3 test/t1203-mini-scale-playwright.py ROOT [tag]"""
3import sys, json
4from playwright.sync_api import sync_playwright
5URL = sys.argv[1].rstrip("/") + "/"
6TAG = sys.argv[2] if len(sys.argv) > 2 else "live"
7fails = []
8def check(ok, msg):
9 print(("OK " if ok else "FAIL ") + msg)
10 if not ok: fails.append(msg)
11
12ROUND_FOR = {6: 12, 8: 23, 12: 57, 16: 107, 31: 437}
13
14MEASURE = """() => {
15 const minis = [...document.querySelectorAll('#minis .mini')];
16 const fieldTop = app.fieldY, vw = innerWidth;
17 const out = minis.map(el => { const r = el.getBoundingClientRect(); const c = el.querySelector('canvas').getBoundingClientRect();
18 return { id: el.dataset.player, slot: +el.dataset.slot, elim: el.classList.contains('eliminated'),
19 x: r.left, y: r.top, w: r.width, bottom: r.bottom, right: r.right, cw: c.width, ch: c.height, font: parseFloat(getComputedStyle(el).fontSize) }; });
20 return { fieldTop, vw, hud: app.hudH, mini: app.miniLayout.mini, minis: out };
21}"""
22
23def start(page, n, elim_idx):
24 page.evaluate(f"""() => {{
25 teardownPlay && teardownPlay();
26 hideEl('menu');
27 app.offline = true;
28 startPlay({{ planet: Planet.defaultPlanet(), offline: true, round: {ROUND_FOR[n]} }});
29 }}""")
30 page.wait_for_function(f"() => app.mode === 'playing' && app.battle && app.battle.bots.length === {n}")
31 page.evaluate("() => { app.core.noSpawn = true; for (const b of app.battle.bots) { b.core.noSpawn = true; } }")
32 if elim_idx:
33 page.evaluate(f"() => {{ for (const i of {json.dumps(elim_idx)}) app.battle.bots[i].core.state = 'gameover'; }}")
34 page.wait_for_timeout(600)
35 return page.evaluate(MEASURE)
36
37with sync_playwright() as p:
38 br = p.chromium.launch()
39 for vw, vh in ((412, 915), (360, 800), (460, 900)):
40 ctx = br.new_context(viewport={"width": vw, "height": vh}, is_mobile=True, has_touch=True, device_scale_factor=2)
41 page = ctx.new_page(); errs = []
42 page.on("pageerror", lambda e: errs.append(str(e)))
43 page.goto(URL + "index.html", wait_until="networkidle")
44 for n, elim in ((6, []), (6, [1, 4]), (8, [0, 2, 5]), (12, [3]), (16, [0, 1, 2, 3])):
45 m = start(page, n, elim)
46 tag = f"{vw}x{vh}-{n}bots" + (f"-{len(elim)}out" if elim else "")
47 ms = m["minis"]
48 above = all(q["bottom"] <= m["fieldTop"] + 0.5 for q in ms)
49 inside = all(q["x"] >= -0.5 and q["right"] <= m["vw"] + 0.5 and q["y"] >= m["hud"] - 0.5 for q in ms)
50 check(len(ms) == n and above and inside, f"{tag}: all {len(ms)} minis above the field (field top {m['fieldTop']}, lowest {max(q['bottom'] for q in ms):.0f}) and on screen; canvas {m['mini']['w']}x{m['mini']['h']}, font {ms[0]['font']}px")
51 check(m["mini"]["fits"] and [q["slot"] for q in ms] == list(range(n)), f"{tag}: order unchanged while they fit")
52 check(all(abs(q["cw"] - m["mini"]["w"]) < 1 for q in ms) and ms[0]["font"] >= 9, f"{tag}: canvas and label scaled ({ms[0]['cw']:.0f}px, {ms[0]['font']}px)")
53 if vw != 460 or n in (6,):
54 page.screenshot(path=f"/workspace/meteors-shots/t1203-{TAG}-{tag}.png")
55 # overflow: 31 bots, 11 defeated
56 elim = [i for i in range(31) if i % 3 == 0]
57 m = start(page, 31, elim)
58 ms = m["minis"]
59 hidden = [q for q in ms if q["bottom"] > m["fieldTop"] + 0.5]
60 alive_ok = all(q["bottom"] <= m["fieldTop"] + 0.5 for q in ms if not q["elim"])
61 check(not m["mini"]["fits"] and m["mini"]["w"] == 32, f"{vw}x{vh}-31bots: minimum size used (canvas {m['mini']['w']}x{m['mini']['h']}), capacity {m['mini']['capacity']}")
62 check(alive_ok and hidden and all(q["elim"] for q in hidden), f"{vw}x{vh}-31bots: living all visible, only defeated behind the field ({len(hidden)} hidden, all defeated)")
63 alive_slots = [q["slot"] for q in ms if not q["elim"]]
64 check(alive_slots == sorted(alive_slots), f"{vw}x{vh}-31bots: stable order of the living")
65 page.screenshot(path=f"/workspace/meteors-shots/t1203-{TAG}-{vw}x{vh}-31bots-11out.png")
66 # Online uses the same layout: fake an 8-opponent lobby (2 out) and render its minis.
67 page.evaluate("() => { teardownPlay && teardownPlay(); }")
68 m = page.evaluate("""() => {
69 const players = [{ id: 'me', name: 'Ik', is_me: true }];
70 for (let i = 1; i <= 8; i++) players.push({ id: 'p' + i, name: 'Speler ' + i, score: i, eliminated: i === 2 || i === 5, snapshot: { blocks: [] }, planet: Planet.defaultPlanet() });
71 Online.lobby = { players };
72 app.online = true; app.offline = false; app.battle = null;
73 hideEl('menu'); document.getElementById('minis').hidden = false;
74 app._layoutN = -1; layout();
75 Online.renderMinis(document.getElementById('minis'));
76 return true; }""")
77 page.wait_for_timeout(200)
78 m = page.evaluate(MEASURE)
79 ms = m["minis"]
80 check(len(ms) == 8 and all(q["bottom"] <= m["fieldTop"] + 0.5 and q["x"] >= -0.5 and q["right"] <= m["vw"] + 0.5 for q in ms) and abs(ms[0]["cw"] - m["mini"]["w"]) < 1, f"{vw}x{vh}-online-8: online minis use the same scaled top layout (canvas {m['mini']['w']}px, lowest {max(q['bottom'] for q in ms):.0f} <= field {m['fieldTop']})")
81 page.screenshot(path=f"/workspace/meteors-shots/t1203-{TAG}-{vw}x{vh}-online-8.png")
82 page.evaluate("() => { app.online = false; Online.lobby = null; }")
83 check(not errs, f"{vw}x{vh}: no page errors {errs[:2]}")
84 ctx.close()
85 br.close()
86print("ALL OK" if not fails else f"{len(fails)} FAILED")
87sys.exit(1 if fails else 0)