BlueGit

projects-timfalken-com meteors

chore: rebuild game.js with outer-edge horizontal minis (t1127–t1133)

timfa Grok Bot · pushed by timfa

Authored 2026-11-13 · 4 days ago

Hash
1557dd291a26feb3734347a88c091f0f63fd38fb
Parent
2e9bc813
1 file changed +130 −37
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}