BlueGit

projects-timfalken-com meteors

Merge branch 'feature/t1127-horizontal-outer-minis'

timfa Grok Bot · pushed by timfa

Authored 2026-11-13 · 4 days ago

Hash
e7dcd132ce2dae2e66dd822ba794c8ff8e253067
Pipeline
Passed
6 files changed +480 −168
build/game.js +130 −37
@@ -3778,9 +3778,13 @@ else if (typeof globalThis !== 'undefined')
3778 3778 'use strict';
3779 3779
3780 3780 /**
3781 * Opponent miniature layout for online and Offline Strijd (t1125).
3782 * Wide screens: alternating left/right of the player's field, extra
3783 * rows stacked upward. Narrow screens: a row (wrapping) above the field.
3781 * Opponent miniature layout for online and Offline Strijd
3782 * (t1125, t1127, t1129, t1131, t1133).
3783 * Wide screens: minis sit beside the field, anchored to the outer
3784 * screen edges, filling inward (1 = left outer, 2 = right outer,
3785 * 3 = left next inward, …). Extra minis wrap to a new row upward
3786 * only when a side's row is full. Narrow / portrait: a row above
3787 * the field.
3784 3788 */
3785 3789
3786 3790 var MiniLayout = (function ()
@@ -3790,27 +3794,38 @@ var GAP = 12;
3790 3794 var VGAP = 8;
3791 3795 var EDGE = 16;
3792 3796 var MIN_TILE_FOR_SIDES = 18;
3793 var MIN_VIEWPORT_FOR_SIDES = 960;
3794 3797 var LABEL_H = 32;
3795 3798 /* Extra space above the field in the wide (sides) layout so
3796 3799 enemy↔player arcs can route around the top edge (t1129). */
3797 3800 var ARC_TOP_PAD = 100;
3801 /* Below this width, or in a narrow portrait, keep the top row (t1131). */
3802 var PORTRAIT_NARROW = 700;
3803 var PORTRAIT_MAX = 850;
3798 3804
3799 function canvasSize (n, mode, availH)
3805 function preferredMini ()
3806 {
3807 return { w: 80, h: 104, outerW: 90, outerH: 104 + LABEL_H };
3808 }
3809
3810 function canvasSize (n, mode, availH, rows)
3800 3811 {
3801 3812 n = n || 0;
3802 if (mode === 'sides' && availH && n > 0)
3813 if (mode === 'sides')
3803 3814 {
3804 var rows = Math.ceil(n / 2);
3805 var maxOuter = Math.floor((availH - (rows - 1) * VGAP) / Math.max(1, rows));
3806 var ch = Math.max(40, Math.min(104, maxOuter - LABEL_H));
3807 var cw = Math.max(32, Math.round(ch * 10 / 13));
3808 return {
3809 w: cw,
3810 h: ch,
3811 outerW: Math.max(cw + 8, 64),
3812 outerH: ch + LABEL_H
3813 };
3815 rows = Math.max(1, rows || 1);
3816 if (availH && rows > 1)
3817 {
3818 var maxOuter = Math.floor((availH - (rows - 1) * VGAP) / rows);
3819 var ch = Math.max(40, Math.min(104, maxOuter - LABEL_H));
3820 var cw = Math.max(32, Math.round(ch * 10 / 13));
3821 return {
3822 w: cw,
3823 h: ch,
3824 outerW: Math.max(cw + 8, 56),
3825 outerH: ch + LABEL_H
3826 };
3827 }
3828 return preferredMini();
3814 3829 }
3815 3830 if (n >= 10)
3816 3831 { return { w: 40, h: 52, outerW: 56, outerH: 52 + LABEL_H }; }
@@ -3819,12 +3834,49 @@ function canvasSize (n, mode, availH)
3819 3834 return { w: 80, h: 104, outerW: 90, outerH: 104 + LABEL_H };
3820 3835 }
3821 3836
3822 function sidePositions (n, fieldX, fieldY, fieldW, fieldH, mini, hudH)
3837 /**
3838 * How many minis fit in one row on a side, between the screen edge
3839 * and the field: EDGE + n*outerW + n*GAP <= sideWidth.
3840 */
3841 function colsThatFit (sideWidth, mini)
3842 {
3843 if (!mini || !mini.outerW)
3844 { return 0; }
3845 var stride = mini.outerW + GAP;
3846 if (stride <= 0)
3847 { return 0; }
3848 return Math.max(0, Math.floor((sideWidth - EDGE) / stride));
3849 }
3850
3851 /**
3852 * Place n opponents. Anchored to the OUTER screen edges, filling
3853 * inward toward the field (t1133). Row 0 is bottom-aligned with the
3854 * field; further rows stack upward only after a side's row is full
3855 * (t1127).
3856 *
3857 * Index 0 → left outer, 1 → right outer, 2 → left next inward, …
3858 */
3859 function sidePositions (n, fieldX, fieldY, fieldW, fieldH, mini, hudH, vw, colsPerSide)
3823 3860 {
3824 3861 var positions = [];
3825 3862 if (n <= 0)
3826 3863 { return positions; }
3827 var rows = Math.ceil(n / 2);
3864 vw = vw || (fieldX * 2 + fieldW);
3865 var leftSpace = fieldX;
3866 var rightSpace = vw - (fieldX + fieldW);
3867 var colsL = colsPerSide != null ? colsPerSide : Math.max(1, colsThatFit(leftSpace, mini));
3868 var colsR = colsPerSide != null ? colsPerSide : Math.max(1, colsThatFit(rightSpace, mini));
3869 if (colsL < 1)
3870 { colsL = 1; }
3871 if (colsR < 1)
3872 { colsR = 1; }
3873
3874 var leftCount = Math.ceil(n / 2);
3875 var rightCount = Math.floor(n / 2);
3876 var rows = Math.max(
3877 Math.ceil(leftCount / colsL),
3878 rightCount ? Math.ceil(rightCount / colsR) : 1
3879 );
3828 3880 var stackH = rows * mini.outerH + Math.max(0, rows - 1) * VGAP;
3829 3881 var bottom = fieldY + fieldH;
3830 3882 var top = bottom - stackH;
@@ -3833,18 +3885,24 @@ function sidePositions (n, fieldX, fieldY, fieldW, fieldH, mini, hudH)
3833 3885 top = hudH + 4;
3834 3886 bottom = top + stackH;
3835 3887 }
3888
3836 3889 for (var i = 0; i < n; i++)
3837 3890 {
3838 var col = i % 2;
3839 var row = Math.floor(i / 2);
3840 var x = col === 0
3841 ? fieldX - GAP - mini.outerW
3842 : fieldX + fieldW + GAP;
3891 var isLeft = (i % 2) === 0;
3892 var slot = Math.floor(i / 2);
3893 var cols = isLeft ? colsL : colsR;
3894 var row = Math.floor(slot / cols);
3895 var fromOuter = slot % cols;
3896 var x = isLeft
3897 ? EDGE + fromOuter * (mini.outerW + GAP)
3898 : vw - EDGE - mini.outerW - fromOuter * (mini.outerW + GAP);
3843 3899 var y = bottom - (row + 1) * mini.outerH - row * VGAP;
3844 3900 positions.push({
3845 3901 index: i,
3846 side: col === 0 ? 'left' : 'right',
3902 side: isLeft ? 'left' : 'right',
3847 3903 row: row,
3904 fromOuter: fromOuter,
3905 colsPerSide: cols,
3848 3906 x: x,
3849 3907 y: y,
3850 3908 w: mini.outerW,
@@ -3856,6 +3914,15 @@ function sidePositions (n, fieldX, fieldY, fieldW, fieldH, mini, hudH)
3856 3914 return positions;
3857 3915 }
3858 3916
3917 function isPortraitNarrow (vw, vh)
3918 {
3919 if (vw < PORTRAIT_NARROW)
3920 { return true; }
3921 if (vw < vh && vw < PORTRAIT_MAX)
3922 { return true; }
3923 return false;
3924 }
3925
3859 3926 /**
3860 3927 * Compute the field and mini plan for a viewport.
3861 3928 * `n` is the number of opponents (0 = solo, no minis).
@@ -3868,7 +3935,7 @@ function plan (vw, vh, n, hudH, margin)
3868 3935 hudH = hudH == null ? 56 : hudH;
3869 3936 margin = margin == null ? Math.max(6, Math.round(Math.min(vw, vh) * 0.015)) : margin;
3870 3937
3871 function finish (mode, tile, fieldX, fieldY, miniH, mini, positions)
3938 function finish (mode, tile, fieldX, fieldY, miniH, mini, positions, cols)
3872 3939 {
3873 3940 return {
3874 3941 mode: mode,
@@ -3880,31 +3947,58 @@ function plan (vw, vh, n, hudH, margin)
3880 3947 miniH: miniH,
3881 3948 mini: mini,
3882 3949 positions: positions || [],
3950 colsPerSide: cols || 0,
3883 3951 n: n
3884 3952 };
3885 3953 }
3886 3954
3887 if (n > 0)
3955 if (n > 0 && !isPortraitNarrow(vw, vh))
3888 3956 {
3889 3957 var availHSide = Math.max(80, vh - hudH - margin);
3890 var probe = canvasSize(n, 'sides', availHSide);
3958 var probe = preferredMini();
3891 3959 var availWSide = Math.max(80, vw - margin * 2 - 2 * (probe.outerW + GAP));
3892 3960 var availHForField = Math.max(80, availHSide - ARC_TOP_PAD);
3893 3961 var tileSide = Math.max(14, Math.floor(Math.min(availWSide / 10, availHForField / 13)));
3894 3962 var fieldWSide = tileSide * 10;
3895 var fieldHSide = tileSide * 13;
3896 3963 var leftover = (vw - fieldWSide) / 2;
3964 var cols = colsThatFit(leftover, probe);
3965 // If a large mini does not fit, shrink it so a small one still can (t1131).
3966 if (cols < 1)
3967 {
3968 var shrinkStride = leftover - EDGE;
3969 if (shrinkStride >= 56 + GAP)
3970 {
3971 var ow = Math.max(56, shrinkStride - GAP);
3972 var oh = Math.round(ow * (104 + LABEL_H) / 90);
3973 var ch = Math.max(40, oh - LABEL_H);
3974 var cw = Math.max(32, Math.round(ch * 10 / 13));
3975 probe = { w: cw, h: ch, outerW: ow, outerH: ch + LABEL_H };
3976 cols = colsThatFit(leftover, probe);
3977 }
3978 }
3897 3979 var need = probe.outerW + GAP + EDGE;
3898 if (vw >= MIN_VIEWPORT_FOR_SIDES && leftover >= need
3899 && tileSide >= MIN_TILE_FOR_SIDES)
3980 if (leftover >= need && tileSide >= MIN_TILE_FOR_SIDES && cols >= 1)
3900 3981 {
3901 3982 var fieldX = Math.floor((vw - fieldWSide) / 2);
3983 var fieldHSide = tileSide * 13;
3902 3984 var fieldY = hudH + ARC_TOP_PAD
3903 3985 + Math.floor((availHForField - fieldHSide) / 2);
3904 3986 if (fieldY < hudH + ARC_TOP_PAD)
3905 3987 { fieldY = hudH + ARC_TOP_PAD; }
3988
3989 var leftCount = Math.ceil(n / 2);
3990 var rows = Math.max(1, Math.ceil(leftCount / cols));
3991 var stackAvail = fieldY + fieldHSide - (hudH + 4);
3992 if (rows > 1)
3993 {
3994 probe = canvasSize(n, 'sides', stackAvail, rows);
3995 cols = Math.max(1, colsThatFit(leftover, probe));
3996 rows = Math.max(1, Math.ceil(leftCount / cols));
3997 }
3998
3906 3999 return finish('sides', tileSide, fieldX, fieldY, 0, probe,
3907 sidePositions(n, fieldX, fieldY, fieldWSide, fieldHSide, probe, hudH));
4000 sidePositions(n, fieldX, fieldY, fieldWSide, fieldHSide, probe, hudH, vw, cols),
4001 cols);
3908 4002 }
3909 4003 }
3910 4004
@@ -3925,7 +4019,7 @@ function plan (vw, vh, n, hudH, margin)
3925 4019 var fieldY = topBand + Math.floor((vh - topBand - fieldH - margin / 2) / 2);
3926 4020 if (fieldY < topBand)
3927 4021 { fieldY = topBand; }
3928 return finish('top', tile, fieldX, fieldY, miniH, miniTop, []);
4022 return finish('top', tile, fieldX, fieldY, miniH, miniTop, [], 0);
3929 4023 }
3930 4024
3931 4025 var api = {
@@ -3933,10 +4027,11 @@ var api = {
3933 4027 VGAP: VGAP,
3934 4028 EDGE: EDGE,
3935 4029 MIN_TILE_FOR_SIDES: MIN_TILE_FOR_SIDES,
3936 MIN_VIEWPORT_FOR_SIDES: MIN_VIEWPORT_FOR_SIDES,
3937 4030 ARC_TOP_PAD: ARC_TOP_PAD,
4031 PORTRAIT_NARROW: PORTRAIT_NARROW,
3938 4032 LABEL_H: LABEL_H,
3939 4033 canvasSize: canvasSize,
4034 colsThatFit: colsThatFit,
3940 4035 sidePositions: sidePositions,
3941 4036 plan: plan
3942 4037 };
@@ -7080,10 +7175,8 @@ function miniViewportCenter (botId)
7080 7175 var plan = app.miniLayout;
7081 7176 if (plan && plan.mode === 'sides')
7082 7177 {
7083 var mid = plan.fieldX + plan.fieldW / 2;
7084 if (rect.left + rect.width / 2 < mid)
7085 { return { x: rect.right, y: rect.top + rect.height / 2 }; }
7086 return { x: rect.left, y: rect.top + rect.height / 2 };
7178 // Leave from the top of the mini, then the arc goes up and over (t1131).
7179 return { x: rect.left + rect.width / 2, y: rect.top + 4 };
7087 7180 }
7088 7181 return { x: rect.left + rect.width / 2, y: rect.bottom };
7089 7182 }
@@ -3778,9 +3778,13 @@ else if (typeof globalThis !== 'undefined')
3778'use strict';
3778'use strict';
3779
3779
3780/**
3780/**
3781 * Opponent miniature layout for online and Offline Strijd (t1125).
3781 * Opponent miniature layout for online and Offline Strijd
3782 * Wide screens: alternating left/right of the player's field, extra
3782 * (t1125, t1127, t1129, t1131, t1133).
3783 * rows stacked upward. Narrow screens: a row (wrapping) above the field.
3783 * Wide screens: minis sit beside the field, anchored to the outer
3784 * screen edges, filling inward (1 = left outer, 2 = right outer,
3785 * 3 = left next inward, …). Extra minis wrap to a new row upward
3786 * only when a side's row is full. Narrow / portrait: a row above
3787 * the field.
3784 */
3788 */
3785
3789
3786var MiniLayout = (function ()
3790var MiniLayout = (function ()
@@ -3790,27 +3794,38 @@ var GAP = 12;
3790var VGAP = 8;
3794var VGAP = 8;
3791var EDGE = 16;
3795var EDGE = 16;
3792var MIN_TILE_FOR_SIDES = 18;
3796var MIN_TILE_FOR_SIDES = 18;
3793var MIN_VIEWPORT_FOR_SIDES = 960;
3794var LABEL_H = 32;
3797var LABEL_H = 32;
3795/* Extra space above the field in the wide (sides) layout so
3798/* Extra space above the field in the wide (sides) layout so
3796 enemy↔player arcs can route around the top edge (t1129). */
3799 enemy↔player arcs can route around the top edge (t1129). */
3797var ARC_TOP_PAD = 100;
3800var ARC_TOP_PAD = 100;
3801/* Below this width, or in a narrow portrait, keep the top row (t1131). */
3802var PORTRAIT_NARROW = 700;
3803var PORTRAIT_MAX = 850;
3798
3804
3799function canvasSize (n, mode, availH)
3805function preferredMini ()
3806{
3807 return { w: 80, h: 104, outerW: 90, outerH: 104 + LABEL_H };
3808}
3809
3810function canvasSize (n, mode, availH, rows)
3800{
3811{
3801 n = n || 0;
3812 n = n || 0;
3802 if (mode === 'sides' && availH && n > 0)
3813 if (mode === 'sides')
3803 {
3814 {
3804 var rows = Math.ceil(n / 2);
3815 rows = Math.max(1, rows || 1);
3805 var maxOuter = Math.floor((availH - (rows - 1) * VGAP) / Math.max(1, rows));
3816 if (availH && rows > 1)
3806 var ch = Math.max(40, Math.min(104, maxOuter - LABEL_H));
3817 {
3807 var cw = Math.max(32, Math.round(ch * 10 / 13));
3818 var maxOuter = Math.floor((availH - (rows - 1) * VGAP) / rows);
3808 return {
3819 var ch = Math.max(40, Math.min(104, maxOuter - LABEL_H));
3809 w: cw,
3820 var cw = Math.max(32, Math.round(ch * 10 / 13));
3810 h: ch,
3821 return {
3811 outerW: Math.max(cw + 8, 64),
3822 w: cw,
3812 outerH: ch + LABEL_H
3823 h: ch,
3813 };
3824 outerW: Math.max(cw + 8, 56),
3825 outerH: ch + LABEL_H
3826 };
3827 }
3828 return preferredMini();
3814 }
3829 }
3815 if (n >= 10)
3830 if (n >= 10)
3816 { return { w: 40, h: 52, outerW: 56, outerH: 52 + LABEL_H }; }
3831 { return { w: 40, h: 52, outerW: 56, outerH: 52 + LABEL_H }; }
@@ -3819,12 +3834,49 @@ function canvasSize (n, mode, availH)
3819 return { w: 80, h: 104, outerW: 90, outerH: 104 + LABEL_H };
3834 return { w: 80, h: 104, outerW: 90, outerH: 104 + LABEL_H };
3820}
3835}
3821
3836
3822function sidePositions (n, fieldX, fieldY, fieldW, fieldH, mini, hudH)
3837/**
3838 * How many minis fit in one row on a side, between the screen edge
3839 * and the field: EDGE + n*outerW + n*GAP <= sideWidth.
3840 */
3841function colsThatFit (sideWidth, mini)
3842{
3843 if (!mini || !mini.outerW)
3844 { return 0; }
3845 var stride = mini.outerW + GAP;
3846 if (stride <= 0)
3847 { return 0; }
3848 return Math.max(0, Math.floor((sideWidth - EDGE) / stride));
3849}
3850
3851/**
3852 * Place n opponents. Anchored to the OUTER screen edges, filling
3853 * inward toward the field (t1133). Row 0 is bottom-aligned with the
3854 * field; further rows stack upward only after a side's row is full
3855 * (t1127).
3856 *
3857 * Index 0 → left outer, 1 → right outer, 2 → left next inward, …
3858 */
3859function sidePositions (n, fieldX, fieldY, fieldW, fieldH, mini, hudH, vw, colsPerSide)
3823{
3860{
3824 var positions = [];
3861 var positions = [];
3825 if (n <= 0)
3862 if (n <= 0)
3826 { return positions; }
3863 { return positions; }
3827 var rows = Math.ceil(n / 2);
3864 vw = vw || (fieldX * 2 + fieldW);
3865 var leftSpace = fieldX;
3866 var rightSpace = vw - (fieldX + fieldW);
3867 var colsL = colsPerSide != null ? colsPerSide : Math.max(1, colsThatFit(leftSpace, mini));
3868 var colsR = colsPerSide != null ? colsPerSide : Math.max(1, colsThatFit(rightSpace, mini));
3869 if (colsL < 1)
3870 { colsL = 1; }
3871 if (colsR < 1)
3872 { colsR = 1; }
3873
3874 var leftCount = Math.ceil(n / 2);
3875 var rightCount = Math.floor(n / 2);
3876 var rows = Math.max(
3877 Math.ceil(leftCount / colsL),
3878 rightCount ? Math.ceil(rightCount / colsR) : 1
3879 );
3828 var stackH = rows * mini.outerH + Math.max(0, rows - 1) * VGAP;
3880 var stackH = rows * mini.outerH + Math.max(0, rows - 1) * VGAP;
3829 var bottom = fieldY + fieldH;
3881 var bottom = fieldY + fieldH;
3830 var top = bottom - stackH;
3882 var top = bottom - stackH;
@@ -3833,18 +3885,24 @@ function sidePositions (n, fieldX, fieldY, fieldW, fieldH, mini, hudH)
3833 top = hudH + 4;
3885 top = hudH + 4;
3834 bottom = top + stackH;
3886 bottom = top + stackH;
3835 }
3887 }
3888
3836 for (var i = 0; i < n; i++)
3889 for (var i = 0; i < n; i++)
3837 {
3890 {
3838 var col = i % 2;
3891 var isLeft = (i % 2) === 0;
3839 var row = Math.floor(i / 2);
3892 var slot = Math.floor(i / 2);
3840 var x = col === 0
3893 var cols = isLeft ? colsL : colsR;
3841 ? fieldX - GAP - mini.outerW
3894 var row = Math.floor(slot / cols);
3842 : fieldX + fieldW + GAP;
3895 var fromOuter = slot % cols;
3896 var x = isLeft
3897 ? EDGE + fromOuter * (mini.outerW + GAP)
3898 : vw - EDGE - mini.outerW - fromOuter * (mini.outerW + GAP);
3843 var y = bottom - (row + 1) * mini.outerH - row * VGAP;
3899 var y = bottom - (row + 1) * mini.outerH - row * VGAP;
3844 positions.push({
3900 positions.push({
3845 index: i,
3901 index: i,
3846 side: col === 0 ? 'left' : 'right',
3902 side: isLeft ? 'left' : 'right',
3847 row: row,
3903 row: row,
3904 fromOuter: fromOuter,
3905 colsPerSide: cols,
3848 x: x,
3906 x: x,
3849 y: y,
3907 y: y,
3850 w: mini.outerW,
3908 w: mini.outerW,
@@ -3856,6 +3914,15 @@ function sidePositions (n, fieldX, fieldY, fieldW, fieldH, mini, hudH)
3856 return positions;
3914 return positions;
3857}
3915}
3858
3916
3917function isPortraitNarrow (vw, vh)
3918{
3919 if (vw < PORTRAIT_NARROW)
3920 { return true; }
3921 if (vw < vh && vw < PORTRAIT_MAX)
3922 { return true; }
3923 return false;
3924}
3925
3859/**
3926/**
3860 * Compute the field and mini plan for a viewport.
3927 * Compute the field and mini plan for a viewport.
3861 * `n` is the number of opponents (0 = solo, no minis).
3928 * `n` is the number of opponents (0 = solo, no minis).
@@ -3868,7 +3935,7 @@ function plan (vw, vh, n, hudH, margin)
3868 hudH = hudH == null ? 56 : hudH;
3935 hudH = hudH == null ? 56 : hudH;
3869 margin = margin == null ? Math.max(6, Math.round(Math.min(vw, vh) * 0.015)) : margin;
3936 margin = margin == null ? Math.max(6, Math.round(Math.min(vw, vh) * 0.015)) : margin;
3870
3937
3871 function finish (mode, tile, fieldX, fieldY, miniH, mini, positions)
3938 function finish (mode, tile, fieldX, fieldY, miniH, mini, positions, cols)
3872 {
3939 {
3873 return {
3940 return {
3874 mode: mode,
3941 mode: mode,
@@ -3880,31 +3947,58 @@ function plan (vw, vh, n, hudH, margin)
3880 miniH: miniH,
3947 miniH: miniH,
3881 mini: mini,
3948 mini: mini,
3882 positions: positions || [],
3949 positions: positions || [],
3950 colsPerSide: cols || 0,
3883 n: n
3951 n: n
3884 };
3952 };
3885 }
3953 }
3886
3954
3887 if (n > 0)
3955 if (n > 0 && !isPortraitNarrow(vw, vh))
3888 {
3956 {
3889 var availHSide = Math.max(80, vh - hudH - margin);
3957 var availHSide = Math.max(80, vh - hudH - margin);
3890 var probe = canvasSize(n, 'sides', availHSide);
3958 var probe = preferredMini();
3891 var availWSide = Math.max(80, vw - margin * 2 - 2 * (probe.outerW + GAP));
3959 var availWSide = Math.max(80, vw - margin * 2 - 2 * (probe.outerW + GAP));
3892 var availHForField = Math.max(80, availHSide - ARC_TOP_PAD);
3960 var availHForField = Math.max(80, availHSide - ARC_TOP_PAD);
3893 var tileSide = Math.max(14, Math.floor(Math.min(availWSide / 10, availHForField / 13)));
3961 var tileSide = Math.max(14, Math.floor(Math.min(availWSide / 10, availHForField / 13)));
3894 var fieldWSide = tileSide * 10;
3962 var fieldWSide = tileSide * 10;
3895 var fieldHSide = tileSide * 13;
3896 var leftover = (vw - fieldWSide) / 2;
3963 var leftover = (vw - fieldWSide) / 2;
3964 var cols = colsThatFit(leftover, probe);
3965 // If a large mini does not fit, shrink it so a small one still can (t1131).
3966 if (cols < 1)
3967 {
3968 var shrinkStride = leftover - EDGE;
3969 if (shrinkStride >= 56 + GAP)
3970 {
3971 var ow = Math.max(56, shrinkStride - GAP);
3972 var oh = Math.round(ow * (104 + LABEL_H) / 90);
3973 var ch = Math.max(40, oh - LABEL_H);
3974 var cw = Math.max(32, Math.round(ch * 10 / 13));
3975 probe = { w: cw, h: ch, outerW: ow, outerH: ch + LABEL_H };
3976 cols = colsThatFit(leftover, probe);
3977 }
3978 }
3897 var need = probe.outerW + GAP + EDGE;
3979 var need = probe.outerW + GAP + EDGE;
3898 if (vw >= MIN_VIEWPORT_FOR_SIDES && leftover >= need
3980 if (leftover >= need && tileSide >= MIN_TILE_FOR_SIDES && cols >= 1)
3899 && tileSide >= MIN_TILE_FOR_SIDES)
3900 {
3981 {
3901 var fieldX = Math.floor((vw - fieldWSide) / 2);
3982 var fieldX = Math.floor((vw - fieldWSide) / 2);
3983 var fieldHSide = tileSide * 13;
3902 var fieldY = hudH + ARC_TOP_PAD
3984 var fieldY = hudH + ARC_TOP_PAD
3903 + Math.floor((availHForField - fieldHSide) / 2);
3985 + Math.floor((availHForField - fieldHSide) / 2);
3904 if (fieldY < hudH + ARC_TOP_PAD)
3986 if (fieldY < hudH + ARC_TOP_PAD)
3905 { fieldY = hudH + ARC_TOP_PAD; }
3987 { fieldY = hudH + ARC_TOP_PAD; }
3988
3989 var leftCount = Math.ceil(n / 2);
3990 var rows = Math.max(1, Math.ceil(leftCount / cols));
3991 var stackAvail = fieldY + fieldHSide - (hudH + 4);
3992 if (rows > 1)
3993 {
3994 probe = canvasSize(n, 'sides', stackAvail, rows);
3995 cols = Math.max(1, colsThatFit(leftover, probe));
3996 rows = Math.max(1, Math.ceil(leftCount / cols));
3997 }
3998
3906 return finish('sides', tileSide, fieldX, fieldY, 0, probe,
3999 return finish('sides', tileSide, fieldX, fieldY, 0, probe,
3907 sidePositions(n, fieldX, fieldY, fieldWSide, fieldHSide, probe, hudH));
4000 sidePositions(n, fieldX, fieldY, fieldWSide, fieldHSide, probe, hudH, vw, cols),
4001 cols);
3908 }
4002 }
3909 }
4003 }
3910
4004
@@ -3925,7 +4019,7 @@ function plan (vw, vh, n, hudH, margin)
3925 var fieldY = topBand + Math.floor((vh - topBand - fieldH - margin / 2) / 2);
4019 var fieldY = topBand + Math.floor((vh - topBand - fieldH - margin / 2) / 2);
3926 if (fieldY < topBand)
4020 if (fieldY < topBand)
3927 { fieldY = topBand; }
4021 { fieldY = topBand; }
3928 return finish('top', tile, fieldX, fieldY, miniH, miniTop, []);
4022 return finish('top', tile, fieldX, fieldY, miniH, miniTop, [], 0);
3929}
4023}
3930
4024
3931var api = {
4025var api = {
@@ -3933,10 +4027,11 @@ var api = {
3933 VGAP: VGAP,
4027 VGAP: VGAP,
3934 EDGE: EDGE,
4028 EDGE: EDGE,
3935 MIN_TILE_FOR_SIDES: MIN_TILE_FOR_SIDES,
4029 MIN_TILE_FOR_SIDES: MIN_TILE_FOR_SIDES,
3936 MIN_VIEWPORT_FOR_SIDES: MIN_VIEWPORT_FOR_SIDES,
3937 ARC_TOP_PAD: ARC_TOP_PAD,
4030 ARC_TOP_PAD: ARC_TOP_PAD,
4031 PORTRAIT_NARROW: PORTRAIT_NARROW,
3938 LABEL_H: LABEL_H,
4032 LABEL_H: LABEL_H,
3939 canvasSize: canvasSize,
4033 canvasSize: canvasSize,
4034 colsThatFit: colsThatFit,
3940 sidePositions: sidePositions,
4035 sidePositions: sidePositions,
3941 plan: plan
4036 plan: plan
3942};
4037};
@@ -7080,10 +7175,8 @@ function miniViewportCenter (botId)
7080 var plan = app.miniLayout;
7175 var plan = app.miniLayout;
7081 if (plan && plan.mode === 'sides')
7176 if (plan && plan.mode === 'sides')
7082 {
7177 {
7083 var mid = plan.fieldX + plan.fieldW / 2;
7178 // Leave from the top of the mini, then the arc goes up and over (t1131).
7084 if (rect.left + rect.width / 2 < mid)
7179 return { x: rect.left + rect.width / 2, y: rect.top + 4 };
7085 { return { x: rect.right, y: rect.top + rect.height / 2 }; }
7086 return { x: rect.left, y: rect.top + rect.height / 2 };
7087 }
7180 }
7088 return { x: rect.left + rect.width / 2, y: rect.bottom };
7181 return { x: rect.left + rect.width / 2, y: rect.bottom };
7089}
7182}
docs/ASSUMPTIONS.md +35 −10
@@ -552,16 +552,23 @@ Aanname:
552 552
553 553 ## t1125 — mini's links/rechts en boogjes tussen velden
554 554
555 - **Breed scherm:** als het venster minstens 960 px breed is, er aan
556 weerszijden van het geschaalde veld genoeg marge is voor één mini
557 (buitenmaat + 12 px tussenruimte + 16 px rand) én de tegels
558 minstens 18 px blijven, staan de tegenstanders om-en-om
559 links en rechts van het veld van de speler (1e links, 2e rechts,
560 3e links, …). De onderste rij sluit aan op de onderkant van het
561 veld. Extra tegenstanders vormen rijen daarboven (kolommen die
562 omhoog groeien). Mini's worden kleiner als dat nodig is om onder
563 de HUD te blijven. Het veld gebruikt de volle hoogte onder de HUD
564 (`miniH = 0`).
555 - **Breed scherm:** als er aan weerszijden van het geschaalde veld
556 genoeg marge is voor minstens één mini (eventueel een kleinere)
557 én de tegels minstens 18 px blijven, staan de tegenstanders
558 **naast** het veld. Alleen écht smalle of staande vensters
559 (korter dan 700 px breed, of staand onder 850 px) houden de rij
560 boven het veld (t1131). Geen harde 960 px-drempel: een kort
561 liggend venster zoals 1024×532 met 3 bots is dus sides.
562 - **Plaatsing (t1127, t1133):** mini's worden aan de **buitenrand**
563 van het scherm verankerd en vullen naar binnen, richting het veld.
564 Volgorde: 1e links buiten, 2e rechts buiten, 3e links één stap
565 naar binnen, 4e rechts één stap naar binnen, enzovoort. De
566 onderste rij sluit aan op de onderkant van het veld. Eerst wordt
567 een rij horizontaal volgelegd; pas als er aan die kant geen
568 kolom meer bij past, komt er een extra rij naar boven (weer
569 beginnend aan de buitenrand). Mini's worden kleiner als gestapelde
570 rijen anders in de HUD zouden lopen. Het veld gebruikt de volle
571 hoogte onder de HUD plus de boog-padding (`miniH = 0`).
565 572 - **Smal scherm / telefoon:** de bestaande layout blijft: mini's in
566 573 een wrappende rij boven het veld.
567 574 - **Boogjes** zijn puur visueel. De vluchttijd blijft 1,2 s, gelijk
@@ -640,3 +647,21 @@ Aanname:
640 647 schutter. Zo komt het boogje overeen met wat er landt.
641 648 - Missers houden de kleur van de schutter: daar wordt niets
642 649 ontvangen, het blokje vliegt weg en vervaagt zoals voorheen.
650
651 ## t1127 / t1131 / t1133 — mini's van de rand naar binnen, horizontaal eerst
652
653 - Tim wilde eerst horizontaal plaatsen en pas verticaal stapelen als
654 de marge vol is (t1127), en de mini's „uitgelijnd van ons veld
655 weg” (t1131 / t1133): verankerd aan de **buitenrand** van het
656 scherm, elke volgende op die kant één stap verder naar het veld
657 toe. Dat is het omgekeerde van „eerst tegen het veld, dan naar
658 buiten”.
659 - Bij 8 tegenstanders past één rij op 1400×900 en 1920×1080; op een
660 smaller breed scherm (bijv. 1280×900) wrapt de vierde per kant
661 naar een rij daarboven, opnieuw aan de buitenrand.
662 - De drempel voor sides is versoepeld (t1131): zodra er een mini
663 naast het veld past — ook een kleinere — kiezen we sides, ook in
664 een kort liggend venster (1024×532, 3 bots). Boogjes vertrekken
665 vanaf de **bovenkant** van de mini, gaan omhoog en in een ruime
666 boog over de bovenrand naar de landingskolom, niet over de mini's
667 of over het binnenveld.
@@ -552,16 +552,23 @@ Aanname:
552
552
553## t1125 — mini's links/rechts en boogjes tussen velden
553## t1125 — mini's links/rechts en boogjes tussen velden
554
554
555- **Breed scherm:** als het venster minstens 960 px breed is, er aan
555- **Breed scherm:** als er aan weerszijden van het geschaalde veld
556 weerszijden van het geschaalde veld genoeg marge is voor één mini
556 genoeg marge is voor minstens één mini (eventueel een kleinere)
557 (buitenmaat + 12 px tussenruimte + 16 px rand) én de tegels
557 én de tegels minstens 18 px blijven, staan de tegenstanders
558 minstens 18 px blijven, staan de tegenstanders om-en-om
558 **naast** het veld. Alleen écht smalle of staande vensters
559 links en rechts van het veld van de speler (1e links, 2e rechts,
559 (korter dan 700 px breed, of staand onder 850 px) houden de rij
560 3e links, …). De onderste rij sluit aan op de onderkant van het
560 boven het veld (t1131). Geen harde 960 px-drempel: een kort
561 veld. Extra tegenstanders vormen rijen daarboven (kolommen die
561 liggend venster zoals 1024×532 met 3 bots is dus sides.
562 omhoog groeien). Mini's worden kleiner als dat nodig is om onder
562- **Plaatsing (t1127, t1133):** mini's worden aan de **buitenrand**
563 de HUD te blijven. Het veld gebruikt de volle hoogte onder de HUD
563 van het scherm verankerd en vullen naar binnen, richting het veld.
564 (`miniH = 0`).
564 Volgorde: 1e links buiten, 2e rechts buiten, 3e links één stap
565 naar binnen, 4e rechts één stap naar binnen, enzovoort. De
566 onderste rij sluit aan op de onderkant van het veld. Eerst wordt
567 een rij horizontaal volgelegd; pas als er aan die kant geen
568 kolom meer bij past, komt er een extra rij naar boven (weer
569 beginnend aan de buitenrand). Mini's worden kleiner als gestapelde
570 rijen anders in de HUD zouden lopen. Het veld gebruikt de volle
571 hoogte onder de HUD plus de boog-padding (`miniH = 0`).
565- **Smal scherm / telefoon:** de bestaande layout blijft: mini's in
572- **Smal scherm / telefoon:** de bestaande layout blijft: mini's in
566 een wrappende rij boven het veld.
573 een wrappende rij boven het veld.
567- **Boogjes** zijn puur visueel. De vluchttijd blijft 1,2 s, gelijk
574- **Boogjes** zijn puur visueel. De vluchttijd blijft 1,2 s, gelijk
@@ -640,3 +647,21 @@ Aanname:
640 schutter. Zo komt het boogje overeen met wat er landt.
647 schutter. Zo komt het boogje overeen met wat er landt.
641- Missers houden de kleur van de schutter: daar wordt niets
648- Missers houden de kleur van de schutter: daar wordt niets
642 ontvangen, het blokje vliegt weg en vervaagt zoals voorheen.
649 ontvangen, het blokje vliegt weg en vervaagt zoals voorheen.
650
651## t1127 / t1131 / t1133 — mini's van de rand naar binnen, horizontaal eerst
652
653- Tim wilde eerst horizontaal plaatsen en pas verticaal stapelen als
654 de marge vol is (t1127), en de mini's „uitgelijnd van ons veld
655 weg” (t1131 / t1133): verankerd aan de **buitenrand** van het
656 scherm, elke volgende op die kant één stap verder naar het veld
657 toe. Dat is het omgekeerde van „eerst tegen het veld, dan naar
658 buiten”.
659- Bij 8 tegenstanders past één rij op 1400×900 en 1920×1080; op een
660 smaller breed scherm (bijv. 1280×900) wrapt de vierde per kant
661 naar een rij daarboven, opnieuw aan de buitenrand.
662- De drempel voor sides is versoepeld (t1131): zodra er een mini
663 naast het veld past — ook een kleinere — kiezen we sides, ook in
664 een kort liggend venster (1024×532, 3 bots). Boogjes vertrekken
665 vanaf de **bovenkant** van de mini, gaan omhoog en in een ruime
666 boog over de bovenrand naar de landingskolom, niet over de mini's
667 of over het binnenveld.
src/main.js +2 −4
@@ -1477,10 +1477,8 @@ function miniViewportCenter (botId)
1477 1477 var plan = app.miniLayout;
1478 1478 if (plan && plan.mode === 'sides')
1479 1479 {
1480 var mid = plan.fieldX + plan.fieldW / 2;
1481 if (rect.left + rect.width / 2 < mid)
1482 { return { x: rect.right, y: rect.top + rect.height / 2 }; }
1483 return { x: rect.left, y: rect.top + rect.height / 2 };
1480 // Leave from the top of the mini, then the arc goes up and over (t1131).
1481 return { x: rect.left + rect.width / 2, y: rect.top + 4 };
1484 1482 }
1485 1483 return { x: rect.left + rect.width / 2, y: rect.bottom };
1486 1484 }
@@ -1477,10 +1477,8 @@ function miniViewportCenter (botId)
1477 var plan = app.miniLayout;
1477 var plan = app.miniLayout;
1478 if (plan && plan.mode === 'sides')
1478 if (plan && plan.mode === 'sides')
1479 {
1479 {
1480 var mid = plan.fieldX + plan.fieldW / 2;
1480 // Leave from the top of the mini, then the arc goes up and over (t1131).
1481 if (rect.left + rect.width / 2 < mid)
1481 return { x: rect.left + rect.width / 2, y: rect.top + 4 };
1482 { return { x: rect.right, y: rect.top + rect.height / 2 }; }
1483 return { x: rect.left, y: rect.top + rect.height / 2 };
1484 }
1482 }
1485 return { x: rect.left + rect.width / 2, y: rect.bottom };
1483 return { x: rect.left + rect.width / 2, y: rect.bottom };
1486}
1484}
src/miniLayout.js +128 −33
@@ -1,9 +1,13 @@
1 1 'use strict';
2 2
3 3 /**
4 * Opponent miniature layout for online and Offline Strijd (t1125).
5 * Wide screens: alternating left/right of the player's field, extra
6 * rows stacked upward. Narrow screens: a row (wrapping) above the field.
4 * Opponent miniature layout for online and Offline Strijd
5 * (t1125, t1127, t1129, t1131, t1133).
6 * Wide screens: minis sit beside the field, anchored to the outer
7 * screen edges, filling inward (1 = left outer, 2 = right outer,
8 * 3 = left next inward, …). Extra minis wrap to a new row upward
9 * only when a side's row is full. Narrow / portrait: a row above
10 * the field.
7 11 */
8 12
9 13 var MiniLayout = (function ()
@@ -13,27 +17,38 @@ var GAP = 12;
13 17 var VGAP = 8;
14 18 var EDGE = 16;
15 19 var MIN_TILE_FOR_SIDES = 18;
16 var MIN_VIEWPORT_FOR_SIDES = 960;
17 20 var LABEL_H = 32;
18 21 /* Extra space above the field in the wide (sides) layout so
19 22 enemy↔player arcs can route around the top edge (t1129). */
20 23 var ARC_TOP_PAD = 100;
24 /* Below this width, or in a narrow portrait, keep the top row (t1131). */
25 var PORTRAIT_NARROW = 700;
26 var PORTRAIT_MAX = 850;
21 27
22 function canvasSize (n, mode, availH)
28 function preferredMini ()
29 {
30 return { w: 80, h: 104, outerW: 90, outerH: 104 + LABEL_H };
31 }
32
33 function canvasSize (n, mode, availH, rows)
23 34 {
24 35 n = n || 0;
25 if (mode === 'sides' && availH && n > 0)
36 if (mode === 'sides')
26 37 {
27 var rows = Math.ceil(n / 2);
28 var maxOuter = Math.floor((availH - (rows - 1) * VGAP) / Math.max(1, rows));
29 var ch = Math.max(40, Math.min(104, maxOuter - LABEL_H));
30 var cw = Math.max(32, Math.round(ch * 10 / 13));
31 return {
32 w: cw,
33 h: ch,
34 outerW: Math.max(cw + 8, 64),
35 outerH: ch + LABEL_H
36 };
38 rows = Math.max(1, rows || 1);
39 if (availH && rows > 1)
40 {
41 var maxOuter = Math.floor((availH - (rows - 1) * VGAP) / rows);
42 var ch = Math.max(40, Math.min(104, maxOuter - LABEL_H));
43 var cw = Math.max(32, Math.round(ch * 10 / 13));
44 return {
45 w: cw,
46 h: ch,
47 outerW: Math.max(cw + 8, 56),
48 outerH: ch + LABEL_H
49 };
50 }
51 return preferredMini();
37 52 }
38 53 if (n >= 10)
39 54 { return { w: 40, h: 52, outerW: 56, outerH: 52 + LABEL_H }; }
@@ -42,12 +57,49 @@ function canvasSize (n, mode, availH)
42 57 return { w: 80, h: 104, outerW: 90, outerH: 104 + LABEL_H };
43 58 }
44 59
45 function sidePositions (n, fieldX, fieldY, fieldW, fieldH, mini, hudH)
60 /**
61 * How many minis fit in one row on a side, between the screen edge
62 * and the field: EDGE + n*outerW + n*GAP <= sideWidth.
63 */
64 function colsThatFit (sideWidth, mini)
65 {
66 if (!mini || !mini.outerW)
67 { return 0; }
68 var stride = mini.outerW + GAP;
69 if (stride <= 0)
70 { return 0; }
71 return Math.max(0, Math.floor((sideWidth - EDGE) / stride));
72 }
73
74 /**
75 * Place n opponents. Anchored to the OUTER screen edges, filling
76 * inward toward the field (t1133). Row 0 is bottom-aligned with the
77 * field; further rows stack upward only after a side's row is full
78 * (t1127).
79 *
80 * Index 0 → left outer, 1 → right outer, 2 → left next inward, …
81 */
82 function sidePositions (n, fieldX, fieldY, fieldW, fieldH, mini, hudH, vw, colsPerSide)
46 83 {
47 84 var positions = [];
48 85 if (n <= 0)
49 86 { return positions; }
50 var rows = Math.ceil(n / 2);
87 vw = vw || (fieldX * 2 + fieldW);
88 var leftSpace = fieldX;
89 var rightSpace = vw - (fieldX + fieldW);
90 var colsL = colsPerSide != null ? colsPerSide : Math.max(1, colsThatFit(leftSpace, mini));
91 var colsR = colsPerSide != null ? colsPerSide : Math.max(1, colsThatFit(rightSpace, mini));
92 if (colsL < 1)
93 { colsL = 1; }
94 if (colsR < 1)
95 { colsR = 1; }
96
97 var leftCount = Math.ceil(n / 2);
98 var rightCount = Math.floor(n / 2);
99 var rows = Math.max(
100 Math.ceil(leftCount / colsL),
101 rightCount ? Math.ceil(rightCount / colsR) : 1
102 );
51 103 var stackH = rows * mini.outerH + Math.max(0, rows - 1) * VGAP;
52 104 var bottom = fieldY + fieldH;
53 105 var top = bottom - stackH;
@@ -56,18 +108,24 @@ function sidePositions (n, fieldX, fieldY, fieldW, fieldH, mini, hudH)
56 108 top = hudH + 4;
57 109 bottom = top + stackH;
58 110 }
111
59 112 for (var i = 0; i < n; i++)
60 113 {
61 var col = i % 2;
62 var row = Math.floor(i / 2);
63 var x = col === 0
64 ? fieldX - GAP - mini.outerW
65 : fieldX + fieldW + GAP;
114 var isLeft = (i % 2) === 0;
115 var slot = Math.floor(i / 2);
116 var cols = isLeft ? colsL : colsR;
117 var row = Math.floor(slot / cols);
118 var fromOuter = slot % cols;
119 var x = isLeft
120 ? EDGE + fromOuter * (mini.outerW + GAP)
121 : vw - EDGE - mini.outerW - fromOuter * (mini.outerW + GAP);
66 122 var y = bottom - (row + 1) * mini.outerH - row * VGAP;
67 123 positions.push({
68 124 index: i,
69 side: col === 0 ? 'left' : 'right',
125 side: isLeft ? 'left' : 'right',
70 126 row: row,
127 fromOuter: fromOuter,
128 colsPerSide: cols,
71 129 x: x,
72 130 y: y,
73 131 w: mini.outerW,
@@ -79,6 +137,15 @@ function sidePositions (n, fieldX, fieldY, fieldW, fieldH, mini, hudH)
79 137 return positions;
80 138 }
81 139
140 function isPortraitNarrow (vw, vh)
141 {
142 if (vw < PORTRAIT_NARROW)
143 { return true; }
144 if (vw < vh && vw < PORTRAIT_MAX)
145 { return true; }
146 return false;
147 }
148
82 149 /**
83 150 * Compute the field and mini plan for a viewport.
84 151 * `n` is the number of opponents (0 = solo, no minis).
@@ -91,7 +158,7 @@ function plan (vw, vh, n, hudH, margin)
91 158 hudH = hudH == null ? 56 : hudH;
92 159 margin = margin == null ? Math.max(6, Math.round(Math.min(vw, vh) * 0.015)) : margin;
93 160
94 function finish (mode, tile, fieldX, fieldY, miniH, mini, positions)
161 function finish (mode, tile, fieldX, fieldY, miniH, mini, positions, cols)
95 162 {
96 163 return {
97 164 mode: mode,
@@ -103,31 +170,58 @@ function plan (vw, vh, n, hudH, margin)
103 170 miniH: miniH,
104 171 mini: mini,
105 172 positions: positions || [],
173 colsPerSide: cols || 0,
106 174 n: n
107 175 };
108 176 }
109 177
110 if (n > 0)
178 if (n > 0 && !isPortraitNarrow(vw, vh))
111 179 {
112 180 var availHSide = Math.max(80, vh - hudH - margin);
113 var probe = canvasSize(n, 'sides', availHSide);
181 var probe = preferredMini();
114 182 var availWSide = Math.max(80, vw - margin * 2 - 2 * (probe.outerW + GAP));
115 183 var availHForField = Math.max(80, availHSide - ARC_TOP_PAD);
116 184 var tileSide = Math.max(14, Math.floor(Math.min(availWSide / 10, availHForField / 13)));
117 185 var fieldWSide = tileSide * 10;
118 var fieldHSide = tileSide * 13;
119 186 var leftover = (vw - fieldWSide) / 2;
187 var cols = colsThatFit(leftover, probe);
188 // If a large mini does not fit, shrink it so a small one still can (t1131).
189 if (cols < 1)
190 {
191 var shrinkStride = leftover - EDGE;
192 if (shrinkStride >= 56 + GAP)
193 {
194 var ow = Math.max(56, shrinkStride - GAP);
195 var oh = Math.round(ow * (104 + LABEL_H) / 90);
196 var ch = Math.max(40, oh - LABEL_H);
197 var cw = Math.max(32, Math.round(ch * 10 / 13));
198 probe = { w: cw, h: ch, outerW: ow, outerH: ch + LABEL_H };
199 cols = colsThatFit(leftover, probe);
200 }
201 }
120 202 var need = probe.outerW + GAP + EDGE;
121 if (vw >= MIN_VIEWPORT_FOR_SIDES && leftover >= need
122 && tileSide >= MIN_TILE_FOR_SIDES)
203 if (leftover >= need && tileSide >= MIN_TILE_FOR_SIDES && cols >= 1)
123 204 {
124 205 var fieldX = Math.floor((vw - fieldWSide) / 2);
206 var fieldHSide = tileSide * 13;
125 207 var fieldY = hudH + ARC_TOP_PAD
126 208 + Math.floor((availHForField - fieldHSide) / 2);
127 209 if (fieldY < hudH + ARC_TOP_PAD)
128 210 { fieldY = hudH + ARC_TOP_PAD; }
211
212 var leftCount = Math.ceil(n / 2);
213 var rows = Math.max(1, Math.ceil(leftCount / cols));
214 var stackAvail = fieldY + fieldHSide - (hudH + 4);
215 if (rows > 1)
216 {
217 probe = canvasSize(n, 'sides', stackAvail, rows);
218 cols = Math.max(1, colsThatFit(leftover, probe));
219 rows = Math.max(1, Math.ceil(leftCount / cols));
220 }
221
129 222 return finish('sides', tileSide, fieldX, fieldY, 0, probe,
130 sidePositions(n, fieldX, fieldY, fieldWSide, fieldHSide, probe, hudH));
223 sidePositions(n, fieldX, fieldY, fieldWSide, fieldHSide, probe, hudH, vw, cols),
224 cols);
131 225 }
132 226 }
133 227
@@ -148,7 +242,7 @@ function plan (vw, vh, n, hudH, margin)
148 242 var fieldY = topBand + Math.floor((vh - topBand - fieldH - margin / 2) / 2);
149 243 if (fieldY < topBand)
150 244 { fieldY = topBand; }
151 return finish('top', tile, fieldX, fieldY, miniH, miniTop, []);
245 return finish('top', tile, fieldX, fieldY, miniH, miniTop, [], 0);
152 246 }
153 247
154 248 var api = {
@@ -156,10 +250,11 @@ var api = {
156 250 VGAP: VGAP,
157 251 EDGE: EDGE,
158 252 MIN_TILE_FOR_SIDES: MIN_TILE_FOR_SIDES,
159 MIN_VIEWPORT_FOR_SIDES: MIN_VIEWPORT_FOR_SIDES,
160 253 ARC_TOP_PAD: ARC_TOP_PAD,
254 PORTRAIT_NARROW: PORTRAIT_NARROW,
161 255 LABEL_H: LABEL_H,
162 256 canvasSize: canvasSize,
257 colsThatFit: colsThatFit,
163 258 sidePositions: sidePositions,
164 259 plan: plan
165 260 };
@@ -1,9 +1,13 @@
1'use strict';
1'use strict';
2
2
3/**
3/**
4 * Opponent miniature layout for online and Offline Strijd (t1125).
4 * Opponent miniature layout for online and Offline Strijd
5 * Wide screens: alternating left/right of the player's field, extra
5 * (t1125, t1127, t1129, t1131, t1133).
6 * rows stacked upward. Narrow screens: a row (wrapping) above the field.
6 * Wide screens: minis sit beside the field, anchored to the outer
7 * screen edges, filling inward (1 = left outer, 2 = right outer,
8 * 3 = left next inward, …). Extra minis wrap to a new row upward
9 * only when a side's row is full. Narrow / portrait: a row above
10 * the field.
7 */
11 */
8
12
9var MiniLayout = (function ()
13var MiniLayout = (function ()
@@ -13,27 +17,38 @@ var GAP = 12;
13var VGAP = 8;
17var VGAP = 8;
14var EDGE = 16;
18var EDGE = 16;
15var MIN_TILE_FOR_SIDES = 18;
19var MIN_TILE_FOR_SIDES = 18;
16var MIN_VIEWPORT_FOR_SIDES = 960;
17var LABEL_H = 32;
20var LABEL_H = 32;
18/* Extra space above the field in the wide (sides) layout so
21/* Extra space above the field in the wide (sides) layout so
19 enemy↔player arcs can route around the top edge (t1129). */
22 enemy↔player arcs can route around the top edge (t1129). */
20var ARC_TOP_PAD = 100;
23var ARC_TOP_PAD = 100;
24/* Below this width, or in a narrow portrait, keep the top row (t1131). */
25var PORTRAIT_NARROW = 700;
26var PORTRAIT_MAX = 850;
21
27
22function canvasSize (n, mode, availH)
28function preferredMini ()
29{
30 return { w: 80, h: 104, outerW: 90, outerH: 104 + LABEL_H };
31}
32
33function canvasSize (n, mode, availH, rows)
23{
34{
24 n = n || 0;
35 n = n || 0;
25 if (mode === 'sides' && availH && n > 0)
36 if (mode === 'sides')
26 {
37 {
27 var rows = Math.ceil(n / 2);
38 rows = Math.max(1, rows || 1);
28 var maxOuter = Math.floor((availH - (rows - 1) * VGAP) / Math.max(1, rows));
39 if (availH && rows > 1)
29 var ch = Math.max(40, Math.min(104, maxOuter - LABEL_H));
40 {
30 var cw = Math.max(32, Math.round(ch * 10 / 13));
41 var maxOuter = Math.floor((availH - (rows - 1) * VGAP) / rows);
31 return {
42 var ch = Math.max(40, Math.min(104, maxOuter - LABEL_H));
32 w: cw,
43 var cw = Math.max(32, Math.round(ch * 10 / 13));
33 h: ch,
44 return {
34 outerW: Math.max(cw + 8, 64),
45 w: cw,
35 outerH: ch + LABEL_H
46 h: ch,
36 };
47 outerW: Math.max(cw + 8, 56),
48 outerH: ch + LABEL_H
49 };
50 }
51 return preferredMini();
37 }
52 }
38 if (n >= 10)
53 if (n >= 10)
39 { return { w: 40, h: 52, outerW: 56, outerH: 52 + LABEL_H }; }
54 { return { w: 40, h: 52, outerW: 56, outerH: 52 + LABEL_H }; }
@@ -42,12 +57,49 @@ function canvasSize (n, mode, availH)
42 return { w: 80, h: 104, outerW: 90, outerH: 104 + LABEL_H };
57 return { w: 80, h: 104, outerW: 90, outerH: 104 + LABEL_H };
43}
58}
44
59
45function sidePositions (n, fieldX, fieldY, fieldW, fieldH, mini, hudH)
60/**
61 * How many minis fit in one row on a side, between the screen edge
62 * and the field: EDGE + n*outerW + n*GAP <= sideWidth.
63 */
64function colsThatFit (sideWidth, mini)
65{
66 if (!mini || !mini.outerW)
67 { return 0; }
68 var stride = mini.outerW + GAP;
69 if (stride <= 0)
70 { return 0; }
71 return Math.max(0, Math.floor((sideWidth - EDGE) / stride));
72}
73
74/**
75 * Place n opponents. Anchored to the OUTER screen edges, filling
76 * inward toward the field (t1133). Row 0 is bottom-aligned with the
77 * field; further rows stack upward only after a side's row is full
78 * (t1127).
79 *
80 * Index 0 → left outer, 1 → right outer, 2 → left next inward, …
81 */
82function sidePositions (n, fieldX, fieldY, fieldW, fieldH, mini, hudH, vw, colsPerSide)
46{
83{
47 var positions = [];
84 var positions = [];
48 if (n <= 0)
85 if (n <= 0)
49 { return positions; }
86 { return positions; }
50 var rows = Math.ceil(n / 2);
87 vw = vw || (fieldX * 2 + fieldW);
88 var leftSpace = fieldX;
89 var rightSpace = vw - (fieldX + fieldW);
90 var colsL = colsPerSide != null ? colsPerSide : Math.max(1, colsThatFit(leftSpace, mini));
91 var colsR = colsPerSide != null ? colsPerSide : Math.max(1, colsThatFit(rightSpace, mini));
92 if (colsL < 1)
93 { colsL = 1; }
94 if (colsR < 1)
95 { colsR = 1; }
96
97 var leftCount = Math.ceil(n / 2);
98 var rightCount = Math.floor(n / 2);
99 var rows = Math.max(
100 Math.ceil(leftCount / colsL),
101 rightCount ? Math.ceil(rightCount / colsR) : 1
102 );
51 var stackH = rows * mini.outerH + Math.max(0, rows - 1) * VGAP;
103 var stackH = rows * mini.outerH + Math.max(0, rows - 1) * VGAP;
52 var bottom = fieldY + fieldH;
104 var bottom = fieldY + fieldH;
53 var top = bottom - stackH;
105 var top = bottom - stackH;
@@ -56,18 +108,24 @@ function sidePositions (n, fieldX, fieldY, fieldW, fieldH, mini, hudH)
56 top = hudH + 4;
108 top = hudH + 4;
57 bottom = top + stackH;
109 bottom = top + stackH;
58 }
110 }
111
59 for (var i = 0; i < n; i++)
112 for (var i = 0; i < n; i++)
60 {
113 {
61 var col = i % 2;
114 var isLeft = (i % 2) === 0;
62 var row = Math.floor(i / 2);
115 var slot = Math.floor(i / 2);
63 var x = col === 0
116 var cols = isLeft ? colsL : colsR;
64 ? fieldX - GAP - mini.outerW
117 var row = Math.floor(slot / cols);
65 : fieldX + fieldW + GAP;
118 var fromOuter = slot % cols;
119 var x = isLeft
120 ? EDGE + fromOuter * (mini.outerW + GAP)
121 : vw - EDGE - mini.outerW - fromOuter * (mini.outerW + GAP);
66 var y = bottom - (row + 1) * mini.outerH - row * VGAP;
122 var y = bottom - (row + 1) * mini.outerH - row * VGAP;
67 positions.push({
123 positions.push({
68 index: i,
124 index: i,
69 side: col === 0 ? 'left' : 'right',
125 side: isLeft ? 'left' : 'right',
70 row: row,
126 row: row,
127 fromOuter: fromOuter,
128 colsPerSide: cols,
71 x: x,
129 x: x,
72 y: y,
130 y: y,
73 w: mini.outerW,
131 w: mini.outerW,
@@ -79,6 +137,15 @@ function sidePositions (n, fieldX, fieldY, fieldW, fieldH, mini, hudH)
79 return positions;
137 return positions;
80}
138}
81
139
140function isPortraitNarrow (vw, vh)
141{
142 if (vw < PORTRAIT_NARROW)
143 { return true; }
144 if (vw < vh && vw < PORTRAIT_MAX)
145 { return true; }
146 return false;
147}
148
82/**
149/**
83 * Compute the field and mini plan for a viewport.
150 * Compute the field and mini plan for a viewport.
84 * `n` is the number of opponents (0 = solo, no minis).
151 * `n` is the number of opponents (0 = solo, no minis).
@@ -91,7 +158,7 @@ function plan (vw, vh, n, hudH, margin)
91 hudH = hudH == null ? 56 : hudH;
158 hudH = hudH == null ? 56 : hudH;
92 margin = margin == null ? Math.max(6, Math.round(Math.min(vw, vh) * 0.015)) : margin;
159 margin = margin == null ? Math.max(6, Math.round(Math.min(vw, vh) * 0.015)) : margin;
93
160
94 function finish (mode, tile, fieldX, fieldY, miniH, mini, positions)
161 function finish (mode, tile, fieldX, fieldY, miniH, mini, positions, cols)
95 {
162 {
96 return {
163 return {
97 mode: mode,
164 mode: mode,
@@ -103,31 +170,58 @@ function plan (vw, vh, n, hudH, margin)
103 miniH: miniH,
170 miniH: miniH,
104 mini: mini,
171 mini: mini,
105 positions: positions || [],
172 positions: positions || [],
173 colsPerSide: cols || 0,
106 n: n
174 n: n
107 };
175 };
108 }
176 }
109
177
110 if (n > 0)
178 if (n > 0 && !isPortraitNarrow(vw, vh))
111 {
179 {
112 var availHSide = Math.max(80, vh - hudH - margin);
180 var availHSide = Math.max(80, vh - hudH - margin);
113 var probe = canvasSize(n, 'sides', availHSide);
181 var probe = preferredMini();
114 var availWSide = Math.max(80, vw - margin * 2 - 2 * (probe.outerW + GAP));
182 var availWSide = Math.max(80, vw - margin * 2 - 2 * (probe.outerW + GAP));
115 var availHForField = Math.max(80, availHSide - ARC_TOP_PAD);
183 var availHForField = Math.max(80, availHSide - ARC_TOP_PAD);
116 var tileSide = Math.max(14, Math.floor(Math.min(availWSide / 10, availHForField / 13)));
184 var tileSide = Math.max(14, Math.floor(Math.min(availWSide / 10, availHForField / 13)));
117 var fieldWSide = tileSide * 10;
185 var fieldWSide = tileSide * 10;
118 var fieldHSide = tileSide * 13;
119 var leftover = (vw - fieldWSide) / 2;
186 var leftover = (vw - fieldWSide) / 2;
187 var cols = colsThatFit(leftover, probe);
188 // If a large mini does not fit, shrink it so a small one still can (t1131).
189 if (cols < 1)
190 {
191 var shrinkStride = leftover - EDGE;
192 if (shrinkStride >= 56 + GAP)
193 {
194 var ow = Math.max(56, shrinkStride - GAP);
195 var oh = Math.round(ow * (104 + LABEL_H) / 90);
196 var ch = Math.max(40, oh - LABEL_H);
197 var cw = Math.max(32, Math.round(ch * 10 / 13));
198 probe = { w: cw, h: ch, outerW: ow, outerH: ch + LABEL_H };
199 cols = colsThatFit(leftover, probe);
200 }
201 }
120 var need = probe.outerW + GAP + EDGE;
202 var need = probe.outerW + GAP + EDGE;
121 if (vw >= MIN_VIEWPORT_FOR_SIDES && leftover >= need
203 if (leftover >= need && tileSide >= MIN_TILE_FOR_SIDES && cols >= 1)
122 && tileSide >= MIN_TILE_FOR_SIDES)
123 {
204 {
124 var fieldX = Math.floor((vw - fieldWSide) / 2);
205 var fieldX = Math.floor((vw - fieldWSide) / 2);
206 var fieldHSide = tileSide * 13;
125 var fieldY = hudH + ARC_TOP_PAD
207 var fieldY = hudH + ARC_TOP_PAD
126 + Math.floor((availHForField - fieldHSide) / 2);
208 + Math.floor((availHForField - fieldHSide) / 2);
127 if (fieldY < hudH + ARC_TOP_PAD)
209 if (fieldY < hudH + ARC_TOP_PAD)
128 { fieldY = hudH + ARC_TOP_PAD; }
210 { fieldY = hudH + ARC_TOP_PAD; }
211
212 var leftCount = Math.ceil(n / 2);
213 var rows = Math.max(1, Math.ceil(leftCount / cols));
214 var stackAvail = fieldY + fieldHSide - (hudH + 4);
215 if (rows > 1)
216 {
217 probe = canvasSize(n, 'sides', stackAvail, rows);
218 cols = Math.max(1, colsThatFit(leftover, probe));
219 rows = Math.max(1, Math.ceil(leftCount / cols));
220 }
221
129 return finish('sides', tileSide, fieldX, fieldY, 0, probe,
222 return finish('sides', tileSide, fieldX, fieldY, 0, probe,
130 sidePositions(n, fieldX, fieldY, fieldWSide, fieldHSide, probe, hudH));
223 sidePositions(n, fieldX, fieldY, fieldWSide, fieldHSide, probe, hudH, vw, cols),
224 cols);
131 }
225 }
132 }
226 }
133
227
@@ -148,7 +242,7 @@ function plan (vw, vh, n, hudH, margin)
148 var fieldY = topBand + Math.floor((vh - topBand - fieldH - margin / 2) / 2);
242 var fieldY = topBand + Math.floor((vh - topBand - fieldH - margin / 2) / 2);
149 if (fieldY < topBand)
243 if (fieldY < topBand)
150 { fieldY = topBand; }
244 { fieldY = topBand; }
151 return finish('top', tile, fieldX, fieldY, miniH, miniTop, []);
245 return finish('top', tile, fieldX, fieldY, miniH, miniTop, [], 0);
152}
246}
153
247
154var api = {
248var api = {
@@ -156,10 +250,11 @@ var api = {
156 VGAP: VGAP,
250 VGAP: VGAP,
157 EDGE: EDGE,
251 EDGE: EDGE,
158 MIN_TILE_FOR_SIDES: MIN_TILE_FOR_SIDES,
252 MIN_TILE_FOR_SIDES: MIN_TILE_FOR_SIDES,
159 MIN_VIEWPORT_FOR_SIDES: MIN_VIEWPORT_FOR_SIDES,
160 ARC_TOP_PAD: ARC_TOP_PAD,
253 ARC_TOP_PAD: ARC_TOP_PAD,
254 PORTRAIT_NARROW: PORTRAIT_NARROW,
161 LABEL_H: LABEL_H,
255 LABEL_H: LABEL_H,
162 canvasSize: canvasSize,
256 canvasSize: canvasSize,
257 colsThatFit: colsThatFit,
163 sidePositions: sidePositions,
258 sidePositions: sidePositions,
164 plan: plan
259 plan: plan
165};
260};
test/mini-layout.test.js +94 −39
@@ -5,67 +5,124 @@ const assert = require('node:assert/strict');
5 5 const MiniLayout = require('../src/miniLayout.js');
6 6 const Online = require('../src/online.js');
7 7
8 describe('MiniLayout (t1125)', () =>
8 function hudOf (vh)
9 9 {
10 it('uses sides on a wide desktop and top on a narrow one', () =>
10 return Math.max(56, Math.round(vh * 0.09));
11 }
12 function marginOf (vw, vh)
13 {
14 return Math.max(6, Math.round(Math.min(vw, vh) * 0.015));
15 }
16 function plan (vw, vh, n)
17 {
18 return MiniLayout.plan(vw, vh, n, hudOf(vh), marginOf(vw, vh));
19 }
20
21 describe('MiniLayout (t1125 / t1127 / t1131 / t1133)', () =>
22 {
23 it('uses sides on a wide desktop and top on a narrow or portrait one', () =>
11 24 {
12 const wide = MiniLayout.plan(1280, 900, 2, 70, 8);
25 const wide = plan(1280, 900, 2);
13 26 assert.equal(wide.mode, 'sides', '1280×900 with 2 opponents is sides');
14 27 assert.ok(wide.tile >= MiniLayout.MIN_TILE_FOR_SIDES, 'tiles stay large enough');
15 28 assert.equal(wide.miniH, 0, 'sides mode does not reserve a top band');
16 29 assert.equal(wide.positions.length, 2);
17 30
18 const justUnder = MiniLayout.plan(MiniLayout.MIN_VIEWPORT_FOR_SIDES - 1, 900, 2, 70, 8);
19 assert.equal(justUnder.mode, 'top', 'just under 960 px stays on top');
20 const narrow = MiniLayout.plan(720, 800, 2, 70, 8);
21 assert.equal(narrow.mode, 'top', '720-wide keeps the top row');
31 const shortWide = plan(1024, 532, 3);
32 assert.equal(shortWide.mode, 'sides', '1024×532 (Tim\'s window) is sides, not a top row');
33 assert.equal(shortWide.positions.length, 3);
34
35 const narrow = plan(720, 800, 2);
36 assert.equal(narrow.mode, 'top', '720-tall-ish keeps the top row');
22 37 assert.ok(narrow.miniH > 0, 'top mode reserves height above the field');
23 38 assert.equal(narrow.positions.length, 0);
24 39
25 const mobile = MiniLayout.plan(393, 851, 1, 60, 6);
40 const mobile = plan(393, 851, 1);
26 41 assert.equal(mobile.mode, 'top', 'phone stays on the top layout');
27 42 });
28 43
29 it('alternates first left, second right, third left, and stacks upward', () =>
44 it('anchors minis to the outer edges and fills inward, bottom-aligned (t1133)', () =>
30 45 {
31 const plan = MiniLayout.plan(1400, 900, 6, 70, 8);
32 assert.equal(plan.mode, 'sides');
33 assert.equal(plan.positions.length, 6);
34 const sides = plan.positions.map(p => p.side);
35 assert.deepEqual(sides, ['left', 'right', 'left', 'right', 'left', 'right']);
36 const rows = plan.positions.map(p => p.row);
37 assert.deepEqual(rows, [0, 0, 1, 1, 2, 2]);
38
39 // Lowest row aligns with (or near) the field bottom; higher rows go up.
40 const lefts = plan.positions.filter(p => p.side === 'left');
41 assert.ok(lefts[0].y + lefts[0].h <= plan.fieldY + plan.fieldH + 2,
42 'first row sits at the field bottom');
43 assert.ok(lefts[1].y < lefts[0].y, 'second row is above the first');
44 assert.ok(lefts[2].y < lefts[1].y, 'third row is above the second');
45 // Same x for a column
46 assert.equal(lefts[0].x, lefts[1].x);
47 assert.ok(lefts[0].x + lefts[0].w <= plan.fieldX - MiniLayout.GAP + 0.5);
48 const rights = plan.positions.filter(p => p.side === 'right');
49 assert.ok(rights[0].x >= plan.fieldX + plan.fieldW + MiniLayout.GAP - 0.5);
46 const p = plan(1024, 532, 3);
47 assert.equal(p.mode, 'sides');
48 assert.equal(p.positions.length, 3);
49 assert.deepEqual(p.positions.map(x => x.side), ['left', 'right', 'left']);
50 assert.deepEqual(p.positions.map(x => x.row), [0, 0, 0], '3 bots fit in one row');
51 assert.deepEqual(p.positions.map(x => x.fromOuter), [0, 0, 1]);
52
53 const [a, b, c] = p.positions;
54 assert.ok(Math.abs(a.x - MiniLayout.EDGE) <= 1, 'bot 1 sits at the left screen edge, x=' + a.x);
55 assert.ok(Math.abs((b.x + b.w) - (1024 - MiniLayout.EDGE)) <= 1,
56 'bot 2 sits at the right screen edge');
57 assert.ok(c.x > a.x, 'bot 3 is inward of bot 1, toward the field');
58 assert.ok(c.x + c.w + MiniLayout.GAP <= p.fieldX + 0.5,
59 'bot 3 does not overlap the field');
60 const bottom = p.fieldY + p.fieldH;
61 for (const m of p.positions)
62 {
63 assert.ok(Math.abs((m.y + m.h) - bottom) <= 2,
64 'mini ' + m.index + ' is bottom-aligned with the field');
65 }
66 });
67
68 it('fits 8 bots in a single row at 1400 and 1920, and wraps on a narrower wide screen (t1127)', () =>
69 {
70 const wide = plan(1400, 900, 8);
71 assert.equal(wide.mode, 'sides');
72 assert.equal(wide.positions.length, 8);
73 assert.ok(wide.positions.every(x => x.row === 0), '1400×900: all 8 in one row');
74 assert.ok(wide.colsPerSide >= 4, 'at least 4 columns per side, got ' + wide.colsPerSide);
75 const lefts = wide.positions.filter(x => x.side === 'left');
76 const rights = wide.positions.filter(x => x.side === 'right');
77 assert.equal(lefts.length, 4);
78 assert.equal(rights.length, 4);
79 // Outer to inward: x increases on the left, decreases on the right.
80 for (let i = 1; i < lefts.length; i++)
81 { assert.ok(lefts[i].x > lefts[i - 1].x, 'left fills inward'); }
82 for (let i = 1; i < rights.length; i++)
83 { assert.ok(rights[i].x < rights[i - 1].x, 'right fills inward'); }
84 assert.ok(Math.abs(lefts[0].x - MiniLayout.EDGE) <= 1, 'first left is at the outer edge');
85 assert.ok(Math.abs((rights[0].x + rights[0].w) - (1400 - MiniLayout.EDGE)) <= 1,
86 'first right is at the outer edge');
87
88 const fullhd = plan(1920, 1080, 8);
89 assert.equal(fullhd.mode, 'sides');
90 assert.ok(fullhd.positions.every(x => x.row === 0), '1920×1080: all 8 in one row');
91 assert.ok(fullhd.colsPerSide >= 4);
92
93 const narrower = plan(1280, 900, 8);
94 assert.equal(narrower.mode, 'sides');
95 const rowsUsed = Math.max(...narrower.positions.map(x => x.row));
96 assert.ok(rowsUsed >= 1, '1280×900 wraps to a second row for 8 bots');
97 const row0 = narrower.positions.filter(x => x.row === 0);
98 const row1 = narrower.positions.filter(x => x.row === 1);
99 assert.ok(row0.length >= 2 && row1.length >= 2);
100 // New row starts again at the outer edges.
101 const r1L = row1.find(x => x.side === 'left');
102 const r0L = row0.find(x => x.side === 'left' && x.fromOuter === 0);
103 assert.ok(r1L && r0L);
104 assert.equal(r1L.x, r0L.x, 'wrapped left mini is again at the outer edge');
105 assert.ok(r1L.y < r0L.y, 'wrapped row sits above the first');
106 assert.ok(r1L.y >= hudOf(900) + 3, 'wrapped row stays under the HUD');
50 107 });
51 108
52 109 it('shrinks minis so stacked rows stay under the HUD', () =>
53 110 {
54 const plan = MiniLayout.plan(1400, 800, 12, 70, 8);
55 assert.equal(plan.mode, 'sides');
56 for (const p of plan.positions)
111 const p = plan(1100, 700, 16);
112 assert.equal(p.mode, 'sides');
113 for (const m of p.positions)
57 114 {
58 assert.ok(p.y >= 70 + 3, 'mini top stays below the HUD, y=' + p.y);
59 assert.ok(p.canvasH >= 40, 'minis do not shrink below a readable size');
115 assert.ok(m.y >= hudOf(700) + 3, 'mini top stays below the HUD, y=' + m.y);
116 assert.ok(m.canvasH >= 40, 'minis do not shrink below a readable size');
60 117 }
61 118 });
62 119
63 120 it('solo (n=0) never reserves minis', () =>
64 121 {
65 const plan = MiniLayout.plan(1280, 900, 0, 70, 8);
66 assert.equal(plan.mode, 'top');
67 assert.equal(plan.miniH, 0);
68 assert.equal(plan.positions.length, 0);
122 const p = plan(1280, 900, 0);
123 assert.equal(p.mode, 'top');
124 assert.equal(p.miniH, 0);
125 assert.equal(p.positions.length, 0);
69 126 });
70 127 });
71 128
@@ -95,13 +152,11 @@ describe('Online flight visuals (t1125)', () =>
95 152 const h = 80;
96 153 const mid = Online.arcPoint(start, end, 0.5, h);
97 154 assert.equal(mid.x, 50);
98 // 4*h*t*(1-t) at t=0.5 is h, so y = 200 - 80
99 155 assert.equal(mid.y, 120);
100 156 const a = Online.arcPoint(start, end, 0, h);
101 157 const b = Online.arcPoint(start, end, 1, h);
102 158 assert.deepEqual(a, start);
103 159 assert.deepEqual(b, end);
104 // Symmetric and always above (smaller y) the chord
105 160 const q1 = Online.arcPoint(start, end, 0.25, h);
106 161 const q3 = Online.arcPoint(start, end, 0.75, h);
107 162 assert.equal(q1.y, q3.y);
@@ -5,67 +5,124 @@ const assert = require('node:assert/strict');
5const MiniLayout = require('../src/miniLayout.js');
5const MiniLayout = require('../src/miniLayout.js');
6const Online = require('../src/online.js');
6const Online = require('../src/online.js');
7
7
8describe('MiniLayout (t1125)', () =>
8function hudOf (vh)
9{
9{
10 it('uses sides on a wide desktop and top on a narrow one', () =>
10 return Math.max(56, Math.round(vh * 0.09));
11}
12function marginOf (vw, vh)
13{
14 return Math.max(6, Math.round(Math.min(vw, vh) * 0.015));
15}
16function plan (vw, vh, n)
17{
18 return MiniLayout.plan(vw, vh, n, hudOf(vh), marginOf(vw, vh));
19}
20
21describe('MiniLayout (t1125 / t1127 / t1131 / t1133)', () =>
22{
23 it('uses sides on a wide desktop and top on a narrow or portrait one', () =>
11 {
24 {
12 const wide = MiniLayout.plan(1280, 900, 2, 70, 8);
25 const wide = plan(1280, 900, 2);
13 assert.equal(wide.mode, 'sides', '1280×900 with 2 opponents is sides');
26 assert.equal(wide.mode, 'sides', '1280×900 with 2 opponents is sides');
14 assert.ok(wide.tile >= MiniLayout.MIN_TILE_FOR_SIDES, 'tiles stay large enough');
27 assert.ok(wide.tile >= MiniLayout.MIN_TILE_FOR_SIDES, 'tiles stay large enough');
15 assert.equal(wide.miniH, 0, 'sides mode does not reserve a top band');
28 assert.equal(wide.miniH, 0, 'sides mode does not reserve a top band');
16 assert.equal(wide.positions.length, 2);
29 assert.equal(wide.positions.length, 2);
17
30
18 const justUnder = MiniLayout.plan(MiniLayout.MIN_VIEWPORT_FOR_SIDES - 1, 900, 2, 70, 8);
31 const shortWide = plan(1024, 532, 3);
19 assert.equal(justUnder.mode, 'top', 'just under 960 px stays on top');
32 assert.equal(shortWide.mode, 'sides', '1024×532 (Tim\'s window) is sides, not a top row');
20 const narrow = MiniLayout.plan(720, 800, 2, 70, 8);
33 assert.equal(shortWide.positions.length, 3);
21 assert.equal(narrow.mode, 'top', '720-wide keeps the top row');
34
35 const narrow = plan(720, 800, 2);
36 assert.equal(narrow.mode, 'top', '720-tall-ish keeps the top row');
22 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');
23 assert.equal(narrow.positions.length, 0);
38 assert.equal(narrow.positions.length, 0);
24
39
25 const mobile = MiniLayout.plan(393, 851, 1, 60, 6);
40 const mobile = plan(393, 851, 1);
26 assert.equal(mobile.mode, 'top', 'phone stays on the top layout');
41 assert.equal(mobile.mode, 'top', 'phone stays on the top layout');
27 });
42 });
28
43
29 it('alternates first left, second right, third left, and stacks upward', () =>
44 it('anchors minis to the outer edges and fills inward, bottom-aligned (t1133)', () =>
30 {
45 {
31 const plan = MiniLayout.plan(1400, 900, 6, 70, 8);
46 const p = plan(1024, 532, 3);
32 assert.equal(plan.mode, 'sides');
47 assert.equal(p.mode, 'sides');
33 assert.equal(plan.positions.length, 6);
48 assert.equal(p.positions.length, 3);
34 const sides = plan.positions.map(p => p.side);
49 assert.deepEqual(p.positions.map(x => x.side), ['left', 'right', 'left']);
35 assert.deepEqual(sides, ['left', 'right', 'left', 'right', 'left', 'right']);
50 assert.deepEqual(p.positions.map(x => x.row), [0, 0, 0], '3 bots fit in one row');
36 const rows = plan.positions.map(p => p.row);
51 assert.deepEqual(p.positions.map(x => x.fromOuter), [0, 0, 1]);
37 assert.deepEqual(rows, [0, 0, 1, 1, 2, 2]);
52
38
53 const [a, b, c] = p.positions;
39 // Lowest row aligns with (or near) the field bottom; higher rows go up.
54 assert.ok(Math.abs(a.x - MiniLayout.EDGE) <= 1, 'bot 1 sits at the left screen edge, x=' + a.x);
40 const lefts = plan.positions.filter(p => p.side === 'left');
55 assert.ok(Math.abs((b.x + b.w) - (1024 - MiniLayout.EDGE)) <= 1,
41 assert.ok(lefts[0].y + lefts[0].h <= plan.fieldY + plan.fieldH + 2,
56 'bot 2 sits at the right screen edge');
42 'first row sits at the field bottom');
57 assert.ok(c.x > a.x, 'bot 3 is inward of bot 1, toward the field');
43 assert.ok(lefts[1].y < lefts[0].y, 'second row is above the first');
58 assert.ok(c.x + c.w + MiniLayout.GAP <= p.fieldX + 0.5,
44 assert.ok(lefts[2].y < lefts[1].y, 'third row is above the second');
59 'bot 3 does not overlap the field');
45 // Same x for a column
60 const bottom = p.fieldY + p.fieldH;
46 assert.equal(lefts[0].x, lefts[1].x);
61 for (const m of p.positions)
47 assert.ok(lefts[0].x + lefts[0].w <= plan.fieldX - MiniLayout.GAP + 0.5);
62 {
48 const rights = plan.positions.filter(p => p.side === 'right');
63 assert.ok(Math.abs((m.y + m.h) - bottom) <= 2,
49 assert.ok(rights[0].x >= plan.fieldX + plan.fieldW + MiniLayout.GAP - 0.5);
64 'mini ' + m.index + ' is bottom-aligned with the field');
65 }
66 });
67
68 it('fits 8 bots in a single row at 1400 and 1920, and wraps on a narrower wide screen (t1127)', () =>
69 {
70 const wide = plan(1400, 900, 8);
71 assert.equal(wide.mode, 'sides');
72 assert.equal(wide.positions.length, 8);
73 assert.ok(wide.positions.every(x => x.row === 0), '1400×900: all 8 in one row');
74 assert.ok(wide.colsPerSide >= 4, 'at least 4 columns per side, got ' + wide.colsPerSide);
75 const lefts = wide.positions.filter(x => x.side === 'left');
76 const rights = wide.positions.filter(x => x.side === 'right');
77 assert.equal(lefts.length, 4);
78 assert.equal(rights.length, 4);
79 // Outer to inward: x increases on the left, decreases on the right.
80 for (let i = 1; i < lefts.length; i++)
81 { assert.ok(lefts[i].x > lefts[i - 1].x, 'left fills inward'); }
82 for (let i = 1; i < rights.length; i++)
83 { assert.ok(rights[i].x < rights[i - 1].x, 'right fills inward'); }
84 assert.ok(Math.abs(lefts[0].x - MiniLayout.EDGE) <= 1, 'first left is at the outer edge');
85 assert.ok(Math.abs((rights[0].x + rights[0].w) - (1400 - MiniLayout.EDGE)) <= 1,
86 'first right is at the outer edge');
87
88 const fullhd = plan(1920, 1080, 8);
89 assert.equal(fullhd.mode, 'sides');
90 assert.ok(fullhd.positions.every(x => x.row === 0), '1920×1080: all 8 in one row');
91 assert.ok(fullhd.colsPerSide >= 4);
92
93 const narrower = plan(1280, 900, 8);
94 assert.equal(narrower.mode, 'sides');
95 const rowsUsed = Math.max(...narrower.positions.map(x => x.row));
96 assert.ok(rowsUsed >= 1, '1280×900 wraps to a second row for 8 bots');
97 const row0 = narrower.positions.filter(x => x.row === 0);
98 const row1 = narrower.positions.filter(x => x.row === 1);
99 assert.ok(row0.length >= 2 && row1.length >= 2);
100 // New row starts again at the outer edges.
101 const r1L = row1.find(x => x.side === 'left');
102 const r0L = row0.find(x => x.side === 'left' && x.fromOuter === 0);
103 assert.ok(r1L && r0L);
104 assert.equal(r1L.x, r0L.x, 'wrapped left mini is again at the outer edge');
105 assert.ok(r1L.y < r0L.y, 'wrapped row sits above the first');
106 assert.ok(r1L.y >= hudOf(900) + 3, 'wrapped row stays under the HUD');
50 });
107 });
51
108
52 it('shrinks minis so stacked rows stay under the HUD', () =>
109 it('shrinks minis so stacked rows stay under the HUD', () =>
53 {
110 {
54 const plan = MiniLayout.plan(1400, 800, 12, 70, 8);
111 const p = plan(1100, 700, 16);
55 assert.equal(plan.mode, 'sides');
112 assert.equal(p.mode, 'sides');
56 for (const p of plan.positions)
113 for (const m of p.positions)
57 {
114 {
58 assert.ok(p.y >= 70 + 3, 'mini top stays below the HUD, y=' + p.y);
115 assert.ok(m.y >= hudOf(700) + 3, 'mini top stays below the HUD, y=' + m.y);
59 assert.ok(p.canvasH >= 40, 'minis do not shrink below a readable size');
116 assert.ok(m.canvasH >= 40, 'minis do not shrink below a readable size');
60 }
117 }
61 });
118 });
62
119
63 it('solo (n=0) never reserves minis', () =>
120 it('solo (n=0) never reserves minis', () =>
64 {
121 {
65 const plan = MiniLayout.plan(1280, 900, 0, 70, 8);
122 const p = plan(1280, 900, 0);
66 assert.equal(plan.mode, 'top');
123 assert.equal(p.mode, 'top');
67 assert.equal(plan.miniH, 0);
124 assert.equal(p.miniH, 0);
68 assert.equal(plan.positions.length, 0);
125 assert.equal(p.positions.length, 0);
69 });
126 });
70});
127});
71
128
@@ -95,13 +152,11 @@ describe('Online flight visuals (t1125)', () =>
95 const h = 80;
152 const h = 80;
96 const mid = Online.arcPoint(start, end, 0.5, h);
153 const mid = Online.arcPoint(start, end, 0.5, h);
97 assert.equal(mid.x, 50);
154 assert.equal(mid.x, 50);
98 // 4*h*t*(1-t) at t=0.5 is h, so y = 200 - 80
99 assert.equal(mid.y, 120);
155 assert.equal(mid.y, 120);
100 const a = Online.arcPoint(start, end, 0, h);
156 const a = Online.arcPoint(start, end, 0, h);
101 const b = Online.arcPoint(start, end, 1, h);
157 const b = Online.arcPoint(start, end, 1, h);
102 assert.deepEqual(a, start);
158 assert.deepEqual(a, start);
103 assert.deepEqual(b, end);
159 assert.deepEqual(b, end);
104 // Symmetric and always above (smaller y) the chord
105 const q1 = Online.arcPoint(start, end, 0.25, h);
160 const q1 = Online.arcPoint(start, end, 0.25, h);
106 const q3 = Online.arcPoint(start, end, 0.75, h);
161 const q3 = Online.arcPoint(start, end, 0.75, h);
107 assert.equal(q1.y, q3.y);
162 assert.equal(q1.y, q3.y);
test/minis-flights-playwright.py +91 −45
@@ -126,10 +126,7 @@ INJECT_FLIGHTS = """(age) => {
126 126 if (!el) return { x: 80, y: 80 };
127 127 const r = el.getBoundingClientRect();
128 128 if (plan && plan.mode === 'sides') {
129 const mid = field.left + field.width / 2;
130 const left = (r.left + r.width / 2) < mid;
131 if (inner) return { x: left ? r.right : r.left, y: r.top + r.height / 2 };
132 return { x: r.left + r.width / 2, y: r.top + r.height / 2 };
129 return { x: r.left + r.width / 2, y: r.top + 4 };
133 130 }
134 131 return { x: r.left + r.width / 2, y: inner ? r.bottom : r.top };
135 132 }
@@ -222,37 +219,81 @@ INJECT_FLIGHTS = """(age) => {
222 219 }"""
223 220
224 221
225 def assert_sides(info, tag, expect_rows=False):
222
223 EDGE = 16
224
225
226 def assert_sides(info, tag, expect_rows=False, expect_one_row=False, n=None):
226 227 check(info["mode"] == "sides", f"{tag}: mode is sides (got {info['mode']})")
227 228 check(info["sidesClass"], f"{tag}: #minis has .sides")
228 229 field = info["field"]
229 230 minis = info["minis"]
231 positions = info.get("positions") or []
232 vw = info.get("vw") or 0
230 233 check(len(minis) >= 1, f"{tag}: at least one mini ({len(minis)})")
234 if n is not None:
235 check(len(minis) == n, f"{tag}: expected {n} minis, got {len(minis)}")
231 236 if field:
232 # t1129: room above the field for around-the-top arcs
233 gap = field["top"] - 50 # HUD is ~56–80; require a clear pad
234 check(field["top"] >= (info.get("hud") or 70) + 80
235 or field["y"] >= 70 + 80,
237 check(field["top"] >= 56 + 70 or field.get("y", 0) >= 56 + 70
238 or (info.get("vh") or 900) < 600 and field["top"] >= 56 + 80,
236 239 f"{tag}: wide layout has top padding (field.top={field['top']:.1f}, y={field.get('y')})")
237 240 if not field or not minis:
238 241 return
242
243 # Bottom-aligned with the field (row 0).
244 row0 = []
239 245 for i, m in enumerate(minis):
240 if i % 2 == 0:
241 check(m["right"] <= field["left"] + 2,
242 f"{tag}: mini {i} ({m['id']}) is on the left of the field "
243 f"(right={m['right']:.1f} field.left={field['left']:.1f})")
244 else:
245 check(m["left"] >= field["right"] - 2,
246 f"{tag}: mini {i} ({m['id']}) is on the right of the field "
247 f"(left={m['left']:.1f} field.right={field['right']:.1f})")
248 check(m["bottom"] <= field["bottom"] + 8,
249 f"{tag}: mini {i} does not hang below the field")
250 check(m["top"] >= 50,
246 pos = positions[i] if i < len(positions) else {}
247 if pos.get("row", 0) == 0:
248 row0.append(m)
249 check(abs(m["bottom"] - field["bottom"]) <= 10,
250 f"{tag}: mini {i} ({m['id']}) is bottom-aligned "
251 f"(bottom={m['bottom']:.1f} field.bottom={field['bottom']:.1f})")
252 check(m["top"] >= 40,
251 253 f"{tag}: mini {i} stays under the HUD (top={m['top']:.1f})")
252 if expect_rows and len(minis) >= 3:
253 check(minis[2]["bottom"] <= minis[0]["top"] + 4,
254 f"{tag}: third mini is stacked above the first "
255 f"(b={minis[2]['bottom']:.1f} vs top={minis[0]['top']:.1f})")
254 # Every mini sits entirely to the left or right of the field.
255 left_of = m["right"] <= field["left"] + 2
256 right_of = m["left"] >= field["right"] - 2
257 check(left_of or right_of,
258 f"{tag}: mini {i} is beside the field, not above it")
259
260 # Alternating sides, outer-edge anchored, filling inward (t1133).
261 if len(minis) >= 1:
262 check(minis[0]["left"] <= EDGE + 6,
263 f"{tag}: bot 1 is at the left outer edge (left={minis[0]['left']:.1f})")
264 if len(minis) >= 2:
265 check(minis[1]["right"] >= vw - EDGE - 6,
266 f"{tag}: bot 2 is at the right outer edge (right={minis[1]['right']:.1f} vw={vw})")
267 if len(minis) >= 3:
268 check(minis[2]["left"] > minis[0]["left"] + 20,
269 f"{tag}: bot 3 is inward of bot 1, toward the field "
270 f"({minis[0]['left']:.1f} → {minis[2]['left']:.1f})")
271 # Same row when they fit (3 bots on a wide-enough side).
272 if positions and positions[0].get("row") == 0 and positions[2].get("row") == 0:
273 check(abs(minis[2]["bottom"] - minis[0]["bottom"]) <= 6,
274 f"{tag}: bot 3 shares the bottom row with bot 1")
275 if len(minis) >= 4:
276 check(minis[3]["right"] < minis[1]["right"] - 20,
277 f"{tag}: bot 4 is inward of bot 2, toward the field")
278
279 if expect_one_row:
280 rows = [p.get("row", 0) for p in positions] if positions else []
281 check(rows and all(r == 0 for r in rows),
282 f"{tag}: all minis sit in a single row (rows={rows})")
283 if expect_rows:
284 rows = [p.get("row", 0) for p in positions] if positions else []
285 check(any(r >= 1 for r in rows),
286 f"{tag}: wraps to a second row (rows={rows})")
287 # Wrapped minis start again at the outer edges and sit above row 0.
288 lefts = [(i, minis[i], positions[i]) for i in range(len(minis))
289 if i < len(positions) and positions[i].get("side") == "left"]
290 r0 = [t for t in lefts if t[2].get("row") == 0 and t[2].get("fromOuter") == 0]
291 r1 = [t for t in lefts if t[2].get("row") == 1 and t[2].get("fromOuter") == 0]
292 if r0 and r1:
293 check(abs(r1[0][1]["left"] - r0[0][1]["left"]) <= 4,
294 f"{tag}: wrapped left mini is again at the outer edge")
295 check(r1[0][1]["bottom"] <= r0[0][1]["top"] + 8,
296 f"{tag}: wrapped row sits above the first")
256 297
257 298
258 299 def assert_top(info, tag):
@@ -281,6 +322,11 @@ def assert_flights(info, tag, expect_behind=True, expect_around=True):
281 322 f"{tag}: player-to-enemy shrinks ({k['startScale']:.2f}→{k['endScale']:.2f})")
282 323 check("gray" in (k.get("src") or "").lower() or k.get("color") == -1,
283 324 f"{tag}: player-to-enemy is grey (src={k.get('src')} color={k.get('color')})")
325 if expect_around:
326 inside = [s for s in (k.get("samples") or []) if s.get("inside")]
327 check(len(inside) == 0,
328 f"{tag}: player-to-enemy path stays outside the field "
329 f"({len(inside)} interior samples {inside[:3]})")
284 330 if "enemy-to-player" in kinds:
285 331 k = kinds["enemy-to-player"]
286 332 check(k["endScale"] > k["startScale"],
@@ -300,12 +346,6 @@ def assert_flights(info, tag, expect_behind=True, expect_around=True):
300 346 f"({len(inside)} interior samples {inside[:3]})")
301 347 check(not k.get("insideNow"),
302 348 f"{tag}: enemy-to-player mid-arc is not over the field interior")
303 if "player-to-enemy" in kinds and expect_around:
304 k = kinds["player-to-enemy"]
305 inside = [s for s in (k.get("samples") or []) if s.get("inside")]
306 check(len(inside) == 0,
307 f"{tag}: player-to-enemy path stays outside the field "
308 f"({len(inside)} interior samples {inside[:3]})")
309 349 if "enemy-to-enemy" in kinds:
310 350 k = kinds["enemy-to-enemy"]
311 351 check(abs(k["startScale"] - k["endScale"]) < 0.05,
@@ -322,12 +362,12 @@ def assert_flights(info, tag, expect_behind=True, expect_around=True):
322 362 f"{tag}: enemy-miss starts small ({k['startScale']:.2f})")
323 363 check(k["parent"] == "flights",
324 364 f"{tag}: enemy-miss is in #flights (got {k['parent']})")
325 # Misses keep the sender colour (not forced grey).
326 365 check(k.get("color") != -1,
327 366 f"{tag}: enemy-miss keeps the sender colour (color={k.get('color')})")
328 367
329 368
330 def run_viewport(browser, url, name, width, height, is_mobile, round_n, expect_mode):
369 def run_viewport(browser, url, name, width, height, is_mobile, round_n, expect_mode,
370 expect_one_row=False, expect_rows=False, n_minis=None):
331 371 context = browser.new_context(
332 372 viewport={"width": width, "height": height},
333 373 device_scale_factor=1,
@@ -338,16 +378,17 @@ def run_viewport(browser, url, name, width, height, is_mobile, round_n, expect_m
338 378 open_offline(page, url, round_n=round_n)
339 379 page.wait_for_timeout(300)
340 380 info = page.evaluate(LAYOUT_INFO)
381 field = info.get("field") or {}
341 382 print(f"--- {name} layout:", {k: info[k] for k in ('mode', 'n', 'tile', 'vw', 'vh', 'sidesClass')},
342 "fieldY", info.get("field") and info["field"].get("y"),
343 "field.top", info.get("field") and info["field"].get("top"))
383 "fieldY", field.get("y"), "field.top", field.get("top"),
384 "positions", info.get("positions"))
344 385 if expect_mode == "sides":
345 assert_sides(info, name, expect_rows=(round_n >= 12))
386 assert_sides(info, name, expect_rows=expect_rows, expect_one_row=expect_one_row,
387 n=n_minis)
346 388 else:
347 389 assert_top(info, name)
348 shot(page, f"t1126-{name}-layout.png")
390 shot(page, f"t1127-{name}-layout.png")
349 391
350 # Mid-arc (age 0.55 of 1.2 s) — main verification frame
351 392 flights = page.evaluate(INJECT_FLIGHTS, 0.55)
352 393 print(f"--- {name} flights:", {k: flights[k] for k in ('front', 'back', 'expectedEndX', 'hudH', 'mode') if k in flights})
353 394 for knd in flights["kinds"]:
@@ -355,13 +396,12 @@ def run_viewport(browser, url, name, width, height, is_mobile, round_n, expect_m
355 396 f"src={knd.get('src')} insideNow={knd.get('insideNow')} "
356 397 f"end={knd.get('end')} pos={knd.get('pos')}")
357 398 assert_flights(flights, name)
358 shot(page, f"t1126-{name}-midarc.png")
399 shot(page, f"t1127-{name}-midarc.png")
359 400
360 # Extra mid-path frames on the wide 2-bot view so the around-route is visible
361 if name == "desktop-wide":
401 if name in ("1024x532-3bots", "1920x1080-8bots", "desktop-wide"):
362 402 for age, label in ((0.25, "early"), (0.85, "late")):
363 403 page.evaluate(INJECT_FLIGHTS, age)
364 shot(page, f"t1126-{name}-midarc-{label}.png")
404 shot(page, f"t1127-{name}-midarc-{label}.png")
365 405 context.close()
366 406
367 407
@@ -376,10 +416,16 @@ def main():
376 416 args=CHROME_ARGS,
377 417 headless=True,
378 418 )
379 run_viewport(browser, url, "desktop-wide", 1280, 900, False, 2, "sides")
380 run_viewport(browser, url, "desktop-wide-many", 1400, 900, False, 25, "sides")
381 run_viewport(browser, url, "desktop-narrow", 720, 800, False, 2, "top")
382 run_viewport(browser, url, "mobile", 393, 851, True, 2, "top")
419 # Tim's short wide window, 3 bots (ronde 3)
420 run_viewport(browser, url, "1024x532-3bots", 1024, 532, False, 3, "sides",
421 expect_one_row=True, n_minis=3)
422 # 8 bots: wrap on 1280, one row on 1400 and 1920
423 run_viewport(browser, url, "1280x900-8bots", 1280, 900, False, 25, "sides",
424 expect_rows=True, n_minis=8)
425 run_viewport(browser, url, "1400x900-8bots", 1400, 900, False, 25, "sides",
426 expect_one_row=True, n_minis=8)
427 run_viewport(browser, url, "1920x1080-8bots", 1920, 1080, False, 25, "sides",
428 expect_one_row=True, n_minis=8)
383 429 browser.close()
384 430 finally:
385 431 http.terminate()
@@ -126,10 +126,7 @@ INJECT_FLIGHTS = """(age) => {
126 if (!el) return { x: 80, y: 80 };
126 if (!el) return { x: 80, y: 80 };
127 const r = el.getBoundingClientRect();
127 const r = el.getBoundingClientRect();
128 if (plan && plan.mode === 'sides') {
128 if (plan && plan.mode === 'sides') {
129 const mid = field.left + field.width / 2;
129 return { x: r.left + r.width / 2, y: r.top + 4 };
130 const left = (r.left + r.width / 2) < mid;
131 if (inner) return { x: left ? r.right : r.left, y: r.top + r.height / 2 };
132 return { x: r.left + r.width / 2, y: r.top + r.height / 2 };
133 }
130 }
134 return { x: r.left + r.width / 2, y: inner ? r.bottom : r.top };
131 return { x: r.left + r.width / 2, y: inner ? r.bottom : r.top };
135 }
132 }
@@ -222,37 +219,81 @@ INJECT_FLIGHTS = """(age) => {
222}"""
219}"""
223
220
224
221
225def assert_sides(info, tag, expect_rows=False):
222
223EDGE = 16
224
225
226def assert_sides(info, tag, expect_rows=False, expect_one_row=False, n=None):
226 check(info["mode"] == "sides", f"{tag}: mode is sides (got {info['mode']})")
227 check(info["mode"] == "sides", f"{tag}: mode is sides (got {info['mode']})")
227 check(info["sidesClass"], f"{tag}: #minis has .sides")
228 check(info["sidesClass"], f"{tag}: #minis has .sides")
228 field = info["field"]
229 field = info["field"]
229 minis = info["minis"]
230 minis = info["minis"]
231 positions = info.get("positions") or []
232 vw = info.get("vw") or 0
230 check(len(minis) >= 1, f"{tag}: at least one mini ({len(minis)})")
233 check(len(minis) >= 1, f"{tag}: at least one mini ({len(minis)})")
234 if n is not None:
235 check(len(minis) == n, f"{tag}: expected {n} minis, got {len(minis)}")
231 if field:
236 if field:
232 # t1129: room above the field for around-the-top arcs
237 check(field["top"] >= 56 + 70 or field.get("y", 0) >= 56 + 70
233 gap = field["top"] - 50 # HUD is ~56–80; require a clear pad
238 or (info.get("vh") or 900) < 600 and field["top"] >= 56 + 80,
234 check(field["top"] >= (info.get("hud") or 70) + 80
235 or field["y"] >= 70 + 80,
236 f"{tag}: wide layout has top padding (field.top={field['top']:.1f}, y={field.get('y')})")
239 f"{tag}: wide layout has top padding (field.top={field['top']:.1f}, y={field.get('y')})")
237 if not field or not minis:
240 if not field or not minis:
238 return
241 return
242
243 # Bottom-aligned with the field (row 0).
244 row0 = []
239 for i, m in enumerate(minis):
245 for i, m in enumerate(minis):
240 if i % 2 == 0:
246 pos = positions[i] if i < len(positions) else {}
241 check(m["right"] <= field["left"] + 2,
247 if pos.get("row", 0) == 0:
242 f"{tag}: mini {i} ({m['id']}) is on the left of the field "
248 row0.append(m)
243 f"(right={m['right']:.1f} field.left={field['left']:.1f})")
249 check(abs(m["bottom"] - field["bottom"]) <= 10,
244 else:
250 f"{tag}: mini {i} ({m['id']}) is bottom-aligned "
245 check(m["left"] >= field["right"] - 2,
251 f"(bottom={m['bottom']:.1f} field.bottom={field['bottom']:.1f})")
246 f"{tag}: mini {i} ({m['id']}) is on the right of the field "
252 check(m["top"] >= 40,
247 f"(left={m['left']:.1f} field.right={field['right']:.1f})")
248 check(m["bottom"] <= field["bottom"] + 8,
249 f"{tag}: mini {i} does not hang below the field")
250 check(m["top"] >= 50,
251 f"{tag}: mini {i} stays under the HUD (top={m['top']:.1f})")
253 f"{tag}: mini {i} stays under the HUD (top={m['top']:.1f})")
252 if expect_rows and len(minis) >= 3:
254 # Every mini sits entirely to the left or right of the field.
253 check(minis[2]["bottom"] <= minis[0]["top"] + 4,
255 left_of = m["right"] <= field["left"] + 2
254 f"{tag}: third mini is stacked above the first "
256 right_of = m["left"] >= field["right"] - 2
255 f"(b={minis[2]['bottom']:.1f} vs top={minis[0]['top']:.1f})")
257 check(left_of or right_of,
258 f"{tag}: mini {i} is beside the field, not above it")
259
260 # Alternating sides, outer-edge anchored, filling inward (t1133).
261 if len(minis) >= 1:
262 check(minis[0]["left"] <= EDGE + 6,
263 f"{tag}: bot 1 is at the left outer edge (left={minis[0]['left']:.1f})")
264 if len(minis) >= 2:
265 check(minis[1]["right"] >= vw - EDGE - 6,
266 f"{tag}: bot 2 is at the right outer edge (right={minis[1]['right']:.1f} vw={vw})")
267 if len(minis) >= 3:
268 check(minis[2]["left"] > minis[0]["left"] + 20,
269 f"{tag}: bot 3 is inward of bot 1, toward the field "
270 f"({minis[0]['left']:.1f} → {minis[2]['left']:.1f})")
271 # Same row when they fit (3 bots on a wide-enough side).
272 if positions and positions[0].get("row") == 0 and positions[2].get("row") == 0:
273 check(abs(minis[2]["bottom"] - minis[0]["bottom"]) <= 6,
274 f"{tag}: bot 3 shares the bottom row with bot 1")
275 if len(minis) >= 4:
276 check(minis[3]["right"] < minis[1]["right"] - 20,
277 f"{tag}: bot 4 is inward of bot 2, toward the field")
278
279 if expect_one_row:
280 rows = [p.get("row", 0) for p in positions] if positions else []
281 check(rows and all(r == 0 for r in rows),
282 f"{tag}: all minis sit in a single row (rows={rows})")
283 if expect_rows:
284 rows = [p.get("row", 0) for p in positions] if positions else []
285 check(any(r >= 1 for r in rows),
286 f"{tag}: wraps to a second row (rows={rows})")
287 # Wrapped minis start again at the outer edges and sit above row 0.
288 lefts = [(i, minis[i], positions[i]) for i in range(len(minis))
289 if i < len(positions) and positions[i].get("side") == "left"]
290 r0 = [t for t in lefts if t[2].get("row") == 0 and t[2].get("fromOuter") == 0]
291 r1 = [t for t in lefts if t[2].get("row") == 1 and t[2].get("fromOuter") == 0]
292 if r0 and r1:
293 check(abs(r1[0][1]["left"] - r0[0][1]["left"]) <= 4,
294 f"{tag}: wrapped left mini is again at the outer edge")
295 check(r1[0][1]["bottom"] <= r0[0][1]["top"] + 8,
296 f"{tag}: wrapped row sits above the first")
256
297
257
298
258def assert_top(info, tag):
299def assert_top(info, tag):
@@ -281,6 +322,11 @@ def assert_flights(info, tag, expect_behind=True, expect_around=True):
281 f"{tag}: player-to-enemy shrinks ({k['startScale']:.2f}→{k['endScale']:.2f})")
322 f"{tag}: player-to-enemy shrinks ({k['startScale']:.2f}→{k['endScale']:.2f})")
282 check("gray" in (k.get("src") or "").lower() or k.get("color") == -1,
323 check("gray" in (k.get("src") or "").lower() or k.get("color") == -1,
283 f"{tag}: player-to-enemy is grey (src={k.get('src')} color={k.get('color')})")
324 f"{tag}: player-to-enemy is grey (src={k.get('src')} color={k.get('color')})")
325 if expect_around:
326 inside = [s for s in (k.get("samples") or []) if s.get("inside")]
327 check(len(inside) == 0,
328 f"{tag}: player-to-enemy path stays outside the field "
329 f"({len(inside)} interior samples {inside[:3]})")
284 if "enemy-to-player" in kinds:
330 if "enemy-to-player" in kinds:
285 k = kinds["enemy-to-player"]
331 k = kinds["enemy-to-player"]
286 check(k["endScale"] > k["startScale"],
332 check(k["endScale"] > k["startScale"],
@@ -300,12 +346,6 @@ def assert_flights(info, tag, expect_behind=True, expect_around=True):
300 f"({len(inside)} interior samples {inside[:3]})")
346 f"({len(inside)} interior samples {inside[:3]})")
301 check(not k.get("insideNow"),
347 check(not k.get("insideNow"),
302 f"{tag}: enemy-to-player mid-arc is not over the field interior")
348 f"{tag}: enemy-to-player mid-arc is not over the field interior")
303 if "player-to-enemy" in kinds and expect_around:
304 k = kinds["player-to-enemy"]
305 inside = [s for s in (k.get("samples") or []) if s.get("inside")]
306 check(len(inside) == 0,
307 f"{tag}: player-to-enemy path stays outside the field "
308 f"({len(inside)} interior samples {inside[:3]})")
309 if "enemy-to-enemy" in kinds:
349 if "enemy-to-enemy" in kinds:
310 k = kinds["enemy-to-enemy"]
350 k = kinds["enemy-to-enemy"]
311 check(abs(k["startScale"] - k["endScale"]) < 0.05,
351 check(abs(k["startScale"] - k["endScale"]) < 0.05,
@@ -322,12 +362,12 @@ def assert_flights(info, tag, expect_behind=True, expect_around=True):
322 f"{tag}: enemy-miss starts small ({k['startScale']:.2f})")
362 f"{tag}: enemy-miss starts small ({k['startScale']:.2f})")
323 check(k["parent"] == "flights",
363 check(k["parent"] == "flights",
324 f"{tag}: enemy-miss is in #flights (got {k['parent']})")
364 f"{tag}: enemy-miss is in #flights (got {k['parent']})")
325 # Misses keep the sender colour (not forced grey).
326 check(k.get("color") != -1,
365 check(k.get("color") != -1,
327 f"{tag}: enemy-miss keeps the sender colour (color={k.get('color')})")
366 f"{tag}: enemy-miss keeps the sender colour (color={k.get('color')})")
328
367
329
368
330def run_viewport(browser, url, name, width, height, is_mobile, round_n, expect_mode):
369def run_viewport(browser, url, name, width, height, is_mobile, round_n, expect_mode,
370 expect_one_row=False, expect_rows=False, n_minis=None):
331 context = browser.new_context(
371 context = browser.new_context(
332 viewport={"width": width, "height": height},
372 viewport={"width": width, "height": height},
333 device_scale_factor=1,
373 device_scale_factor=1,
@@ -338,16 +378,17 @@ def run_viewport(browser, url, name, width, height, is_mobile, round_n, expect_m
338 open_offline(page, url, round_n=round_n)
378 open_offline(page, url, round_n=round_n)
339 page.wait_for_timeout(300)
379 page.wait_for_timeout(300)
340 info = page.evaluate(LAYOUT_INFO)
380 info = page.evaluate(LAYOUT_INFO)
381 field = info.get("field") or {}
341 print(f"--- {name} layout:", {k: info[k] for k in ('mode', 'n', 'tile', 'vw', 'vh', 'sidesClass')},
382 print(f"--- {name} layout:", {k: info[k] for k in ('mode', 'n', 'tile', 'vw', 'vh', 'sidesClass')},
342 "fieldY", info.get("field") and info["field"].get("y"),
383 "fieldY", field.get("y"), "field.top", field.get("top"),
343 "field.top", info.get("field") and info["field"].get("top"))
384 "positions", info.get("positions"))
344 if expect_mode == "sides":
385 if expect_mode == "sides":
345 assert_sides(info, name, expect_rows=(round_n >= 12))
386 assert_sides(info, name, expect_rows=expect_rows, expect_one_row=expect_one_row,
387 n=n_minis)
346 else:
388 else:
347 assert_top(info, name)
389 assert_top(info, name)
348 shot(page, f"t1126-{name}-layout.png")
390 shot(page, f"t1127-{name}-layout.png")
349
391
350 # Mid-arc (age 0.55 of 1.2 s) — main verification frame
351 flights = page.evaluate(INJECT_FLIGHTS, 0.55)
392 flights = page.evaluate(INJECT_FLIGHTS, 0.55)
352 print(f"--- {name} flights:", {k: flights[k] for k in ('front', 'back', 'expectedEndX', 'hudH', 'mode') if k in flights})
393 print(f"--- {name} flights:", {k: flights[k] for k in ('front', 'back', 'expectedEndX', 'hudH', 'mode') if k in flights})
353 for knd in flights["kinds"]:
394 for knd in flights["kinds"]:
@@ -355,13 +396,12 @@ def run_viewport(browser, url, name, width, height, is_mobile, round_n, expect_m
355 f"src={knd.get('src')} insideNow={knd.get('insideNow')} "
396 f"src={knd.get('src')} insideNow={knd.get('insideNow')} "
356 f"end={knd.get('end')} pos={knd.get('pos')}")
397 f"end={knd.get('end')} pos={knd.get('pos')}")
357 assert_flights(flights, name)
398 assert_flights(flights, name)
358 shot(page, f"t1126-{name}-midarc.png")
399 shot(page, f"t1127-{name}-midarc.png")
359
400
360 # Extra mid-path frames on the wide 2-bot view so the around-route is visible
401 if name in ("1024x532-3bots", "1920x1080-8bots", "desktop-wide"):
361 if name == "desktop-wide":
362 for age, label in ((0.25, "early"), (0.85, "late")):
402 for age, label in ((0.25, "early"), (0.85, "late")):
363 page.evaluate(INJECT_FLIGHTS, age)
403 page.evaluate(INJECT_FLIGHTS, age)
364 shot(page, f"t1126-{name}-midarc-{label}.png")
404 shot(page, f"t1127-{name}-midarc-{label}.png")
365 context.close()
405 context.close()
366
406
367
407
@@ -376,10 +416,16 @@ def main():
376 args=CHROME_ARGS,
416 args=CHROME_ARGS,
377 headless=True,
417 headless=True,
378 )
418 )
379 run_viewport(browser, url, "desktop-wide", 1280, 900, False, 2, "sides")
419 # Tim's short wide window, 3 bots (ronde 3)
380 run_viewport(browser, url, "desktop-wide-many", 1400, 900, False, 25, "sides")
420 run_viewport(browser, url, "1024x532-3bots", 1024, 532, False, 3, "sides",
381 run_viewport(browser, url, "desktop-narrow", 720, 800, False, 2, "top")
421 expect_one_row=True, n_minis=3)
382 run_viewport(browser, url, "mobile", 393, 851, True, 2, "top")
422 # 8 bots: wrap on 1280, one row on 1400 and 1920
423 run_viewport(browser, url, "1280x900-8bots", 1280, 900, False, 25, "sides",
424 expect_rows=True, n_minis=8)
425 run_viewport(browser, url, "1400x900-8bots", 1400, 900, False, 25, "sides",
426 expect_one_row=True, n_minis=8)
427 run_viewport(browser, url, "1920x1080-8bots", 1920, 1080, False, 25, "sides",
428 expect_one_row=True, n_minis=8)
383 browser.close()
429 browser.close()
384 finally:
430 finally:
385 http.terminate()
431 http.terminate()