Merge branch 'feature/t1127-horizontal-outer-minis'
@@ -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 Strijd3782
* Wide screens: alternating left/right of the player's field, extra3782
* (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 outer3784
* screen edges, filling inward (1 = left outer, 2 = right outer,3785
* 3 = left next inward, …). Extra minis wrap to a new row upward3786
* only when a side's row is full. Narrow / portrait: a row above3787
* the field.3784
*/3788
*/3785
3789
3786
var MiniLayout = (function ()3790
var MiniLayout = (function ()@@ -3790,27 +3794,38 @@ var GAP = 12;3790
var VGAP = 8;3794
var VGAP = 8;3791
var EDGE = 16;3795
var EDGE = 16;3792
var MIN_TILE_FOR_SIDES = 18;3796
var MIN_TILE_FOR_SIDES = 18;3793
var MIN_VIEWPORT_FOR_SIDES = 960;3794
var LABEL_H = 32;3797
var LABEL_H = 32;3795
/* Extra space above the field in the wide (sides) layout so3798
/* Extra space above the field in the wide (sides) layout so3796
enemy↔player arcs can route around the top edge (t1129). */3799
enemy↔player arcs can route around the top edge (t1129). */3797
var ARC_TOP_PAD = 100;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
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_H3823
h: ch,3813
};3824
outerW: Math.max(cw + 8, 56),3825
outerH: ch + LABEL_H3826
};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
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 edge3839
* 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, filling3853
* inward toward the field (t1133). Row 0 is bottom-aligned with the3854
* field; further rows stack upward only after a side's row is full3855
* (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
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) : 13879
);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 === 03893
var cols = isLeft ? colsL : colsR;3841
? fieldX - GAP - mini.outerW3894
var row = Math.floor(slot / cols);3842
: fieldX + fieldW + GAP;3895
var fromOuter = slot % cols;3896
var x = isLeft3897
? 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
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
* 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: n3951
n: n3884
};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 >= need3980
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_PAD3984
var fieldY = hudH + ARC_TOP_PAD3903
+ 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
3931
var api = {4025
var 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: plan4036
plan: plan3942
};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
}@@ -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 velden553
## t1125 — mini's links/rechts en boogjes tussen velden554
554
555
- **Breed scherm:** als het venster minstens 960 px breed is, er aan555
- **Breed scherm:** als er aan weerszijden van het geschaalde veld556
weerszijden van het geschaalde veld genoeg marge is voor één mini556
genoeg marge is voor minstens één mini (eventueel een kleinere)557
(buitenmaat + 12 px tussenruimte + 16 px rand) én de tegels557
én de tegels minstens 18 px blijven, staan de tegenstanders558
minstens 18 px blijven, staan de tegenstanders om-en-om558
**naast** het veld. Alleen écht smalle of staande vensters559
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 rij560
3e links, …). De onderste rij sluit aan op de onderkant van het560
boven het veld (t1131). Geen harde 960 px-drempel: een kort561
veld. Extra tegenstanders vormen rijen daarboven (kolommen die561
liggend venster zoals 1024×532 met 3 bots is dus sides.562
omhoog groeien). Mini's worden kleiner als dat nodig is om onder562
- **Plaatsing (t1127, t1133):** mini's worden aan de **buitenrand**563
de HUD te blijven. Het veld gebruikt de volle hoogte onder de HUD563
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 stap565
naar binnen, 4e rechts één stap naar binnen, enzovoort. De566
onderste rij sluit aan op de onderkant van het veld. Eerst wordt567
een rij horizontaal volgelegd; pas als er aan die kant geen568
kolom meer bij past, komt er een extra rij naar boven (weer569
beginnend aan de buitenrand). Mini's worden kleiner als gestapelde570
rijen anders in de HUD zouden lopen. Het veld gebruikt de volle571
hoogte onder de HUD plus de boog-padding (`miniH = 0`).565
- **Smal scherm / telefoon:** de bestaande layout blijft: mini's in572
- **Smal scherm / telefoon:** de bestaande layout blijft: mini's in566
een wrappende rij boven het veld.573
een wrappende rij boven het veld.567
- **Boogjes** zijn puur visueel. De vluchttijd blijft 1,2 s, gelijk574
- **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 niets648
- Missers houden de kleur van de schutter: daar wordt niets642
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 eerst652
653
- Tim wilde eerst horizontaal plaatsen en pas verticaal stapelen als654
de marge vol is (t1127), en de mini's „uitgelijnd van ons veld655
weg” (t1131 / t1133): verankerd aan de **buitenrand** van het656
scherm, elke volgende op die kant één stap verder naar het veld657
toe. Dat is het omgekeerde van „eerst tegen het veld, dan naar658
buiten”.659
- Bij 8 tegenstanders past één rij op 1400×900 en 1920×1080; op een660
smaller breed scherm (bijv. 1280×900) wrapt de vierde per kant661
naar een rij daarboven, opnieuw aan de buitenrand.662
- De drempel voor sides is versoepeld (t1131): zodra er een mini663
naast het veld past — ook een kleinere — kiezen we sides, ook in664
een kort liggend venster (1024×532, 3 bots). Boogjes vertrekken665
vanaf de **bovenkant** van de mini, gaan omhoog en in een ruime666
boog over de bovenrand naar de landingskolom, niet over de mini's667
of over het binnenveld.@@ -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
}@@ -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 Strijd5
* Wide screens: alternating left/right of the player's field, extra5
* (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 outer7
* screen edges, filling inward (1 = left outer, 2 = right outer,8
* 3 = left next inward, …). Extra minis wrap to a new row upward9
* only when a side's row is full. Narrow / portrait: a row above10
* the field.7
*/11
*/8
12
9
var MiniLayout = (function ()13
var MiniLayout = (function ()@@ -13,27 +17,38 @@ var GAP = 12;13
var VGAP = 8;17
var VGAP = 8;14
var EDGE = 16;18
var EDGE = 16;15
var MIN_TILE_FOR_SIDES = 18;19
var MIN_TILE_FOR_SIDES = 18;16
var MIN_VIEWPORT_FOR_SIDES = 960;17
var LABEL_H = 32;20
var LABEL_H = 32;18
/* Extra space above the field in the wide (sides) layout so21
/* Extra space above the field in the wide (sides) layout so19
enemy↔player arcs can route around the top edge (t1129). */22
enemy↔player arcs can route around the top edge (t1129). */20
var ARC_TOP_PAD = 100;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
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_H46
h: ch,36
};47
outerW: Math.max(cw + 8, 56),48
outerH: ch + LABEL_H49
};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
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 edge62
* 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, filling76
* inward toward the field (t1133). Row 0 is bottom-aligned with the77
* field; further rows stack upward only after a side's row is full78
* (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
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) : 1102
);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 === 0116
var cols = isLeft ? colsL : colsR;64
? fieldX - GAP - mini.outerW117
var row = Math.floor(slot / cols);65
: fieldX + fieldW + GAP;118
var fromOuter = slot % cols;119
var x = isLeft120
? 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
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
* 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: n174
n: n107
};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 >= need203
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_PAD207
var fieldY = hudH + ARC_TOP_PAD126
+ 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
154
var api = {248
var 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: plan259
plan: plan165
};260
};@@ -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');5
const MiniLayout = require('../src/miniLayout.js');5
const MiniLayout = require('../src/miniLayout.js');6
const Online = require('../src/online.js');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
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 column60
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 - 8099
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 chord105
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);@@ -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
225
def assert_sides(info, tag, expect_rows=False):222
223
EDGE = 16224
225
226
def 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 0230
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 arcs237
check(field["top"] >= 56 + 70 or field.get("y", 0) >= 56 + 70233
gap = field["top"] - 50 # HUD is ~56–80; require a clear pad238
or (info.get("vh") or 900) < 600 and field["top"] >= 56 + 80,234
check(field["top"] >= (info.get("hud") or 70) + 80235
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
return241
return242
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"] + 2254
f"{tag}: third mini is stacked above the first "256
right_of = m["left"] >= field["right"] - 2255
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
258
def assert_top(info, tag):299
def 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
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
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_m338
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 frame351
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_m355
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 visible401
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 1920423
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()