Ilia Denisov
443 lines
7.9 KiB
Go
443 lines
7.9 KiB
Go
package world
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestWorldFixedToCameraZoom(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := []struct {
|
|
name string
|
|
zoomFp int
|
|
want float64
|
|
}{
|
|
{name: "zero", zoomFp: 0, want: 0},
|
|
{name: "neutral", zoomFp: SCALE, want: 1.0},
|
|
{name: "fractional", zoomFp: 1250, want: 1.25},
|
|
{name: "integer multiple", zoomFp: 3 * SCALE, want: 3.0},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
tt := tt
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got := worldFixedToCameraZoom(tt.zoomFp)
|
|
require.Equal(t, tt.want, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestRequiredZoomToFitWorld(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := []struct {
|
|
name string
|
|
viewportSpanPx int
|
|
worldSpanFp int
|
|
want int
|
|
}{
|
|
{
|
|
name: "zero viewport span",
|
|
viewportSpanPx: 0,
|
|
worldSpanFp: 10 * SCALE,
|
|
want: 0,
|
|
},
|
|
{
|
|
name: "exact neutral fit",
|
|
viewportSpanPx: 10,
|
|
worldSpanFp: 10 * SCALE,
|
|
want: SCALE,
|
|
},
|
|
{
|
|
name: "exact 2x fit",
|
|
viewportSpanPx: 20,
|
|
worldSpanFp: 10 * SCALE,
|
|
want: 2 * SCALE,
|
|
},
|
|
{
|
|
name: "fractional fit rounded up",
|
|
viewportSpanPx: 11,
|
|
worldSpanFp: 10 * SCALE,
|
|
want: 1100,
|
|
},
|
|
{
|
|
name: "small world requires larger zoom",
|
|
viewportSpanPx: 320,
|
|
worldSpanFp: 80 * SCALE,
|
|
want: 4 * SCALE,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
tt := tt
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got := requiredZoomToFitWorld(tt.viewportSpanPx, tt.worldSpanFp)
|
|
require.Equal(t, tt.want, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestRequiredZoomToFitWorldPanics(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := []struct {
|
|
name string
|
|
viewportSpanPx int
|
|
worldSpanFp int
|
|
}{
|
|
{
|
|
name: "negative viewport span",
|
|
viewportSpanPx: -1,
|
|
worldSpanFp: 10 * SCALE,
|
|
},
|
|
{
|
|
name: "zero world span",
|
|
viewportSpanPx: 10,
|
|
worldSpanFp: 0,
|
|
},
|
|
{
|
|
name: "negative world span",
|
|
viewportSpanPx: 10,
|
|
worldSpanFp: -1,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
tt := tt
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
require.Panics(t, func() {
|
|
_ = requiredZoomToFitWorld(tt.viewportSpanPx, tt.worldSpanFp)
|
|
})
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCorrectCameraZoomFpReturnsCurrentWhenNoCorrectionNeeded(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got := correctCameraZoomFp(
|
|
2*SCALE,
|
|
40, 30,
|
|
100*SCALE, 100*SCALE,
|
|
MIN_ZOOM, MAX_ZOOM,
|
|
)
|
|
|
|
require.Equal(t, 2*SCALE, got)
|
|
}
|
|
|
|
func TestCorrectCameraZoomFpRaisesZoomToFitWorldWidth(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got := correctCameraZoomFp(
|
|
SCALE,
|
|
120, 20,
|
|
100*SCALE, 100*SCALE,
|
|
0, 0,
|
|
)
|
|
|
|
require.Equal(t, 1200, got)
|
|
}
|
|
|
|
func TestCorrectCameraZoomFpRaisesZoomToFitWorldHeight(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got := correctCameraZoomFp(
|
|
SCALE,
|
|
20, 150,
|
|
100*SCALE, 100*SCALE,
|
|
0, 0,
|
|
)
|
|
|
|
require.Equal(t, 1500, got)
|
|
}
|
|
|
|
func TestCorrectCameraZoomFpUsesMaxFitAcrossAxes(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got := correctCameraZoomFp(
|
|
SCALE,
|
|
120, 150,
|
|
100*SCALE, 100*SCALE,
|
|
0, 0,
|
|
)
|
|
|
|
require.Equal(t, 1500, got)
|
|
}
|
|
|
|
func TestCorrectCameraZoomFpAppliesMinZoomWhenLargerThanCurrentAndFit(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got := correctCameraZoomFp(
|
|
SCALE,
|
|
20, 20,
|
|
100*SCALE, 100*SCALE,
|
|
1500, 0,
|
|
)
|
|
|
|
require.Equal(t, 1500, got)
|
|
}
|
|
|
|
func TestCorrectCameraZoomFpAppliesMaxZoomWhenNoFitConflict(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got := correctCameraZoomFp(
|
|
4*SCALE,
|
|
20, 20,
|
|
100*SCALE, 100*SCALE,
|
|
0, 3*SCALE,
|
|
)
|
|
|
|
require.Equal(t, 3*SCALE, got)
|
|
}
|
|
|
|
func TestCorrectCameraZoomFpIgnoresMaxZoomWhenFitNeedsMore(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got := correctCameraZoomFp(
|
|
SCALE,
|
|
200, 20,
|
|
100*SCALE, 100*SCALE,
|
|
0, 1500,
|
|
)
|
|
|
|
require.Equal(t, 2*SCALE, got)
|
|
}
|
|
|
|
func TestCorrectCameraZoomFpAppliesMinThenMaxWhenBothValid(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got := correctCameraZoomFp(
|
|
SCALE,
|
|
20, 20,
|
|
100*SCALE, 100*SCALE,
|
|
1500, 1600,
|
|
)
|
|
|
|
require.Equal(t, 1500, got)
|
|
}
|
|
|
|
func TestCorrectCameraZoomFpCurrentAboveMaxGetsClamped(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got := correctCameraZoomFp(
|
|
5*SCALE,
|
|
20, 20,
|
|
100*SCALE, 100*SCALE,
|
|
0, 3*SCALE,
|
|
)
|
|
|
|
require.Equal(t, 3*SCALE, got)
|
|
}
|
|
|
|
func TestCorrectCameraZoomFpZeroViewportUsesOnlyBounds(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got := correctCameraZoomFp(
|
|
SCALE,
|
|
0, 0,
|
|
100*SCALE, 100*SCALE,
|
|
1500, 0,
|
|
)
|
|
|
|
require.Equal(t, 1500, got)
|
|
}
|
|
|
|
func TestCorrectCameraZoomFpZeroBoundsAreIgnored(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got := correctCameraZoomFp(
|
|
1250,
|
|
20, 20,
|
|
100*SCALE, 100*SCALE,
|
|
0, 0,
|
|
)
|
|
|
|
require.Equal(t, 1250, got)
|
|
}
|
|
|
|
func TestCorrectCameraZoomFpPanics(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := []struct {
|
|
name string
|
|
fn func()
|
|
}{
|
|
{
|
|
name: "non-positive current zoom",
|
|
fn: func() {
|
|
_ = correctCameraZoomFp(0, 10, 10, 100*SCALE, 100*SCALE, 0, 0)
|
|
},
|
|
},
|
|
{
|
|
name: "negative viewport width",
|
|
fn: func() {
|
|
_ = correctCameraZoomFp(SCALE, -1, 10, 100*SCALE, 100*SCALE, 0, 0)
|
|
},
|
|
},
|
|
{
|
|
name: "negative viewport height",
|
|
fn: func() {
|
|
_ = correctCameraZoomFp(SCALE, 10, -1, 100*SCALE, 100*SCALE, 0, 0)
|
|
},
|
|
},
|
|
{
|
|
name: "non-positive world width",
|
|
fn: func() {
|
|
_ = correctCameraZoomFp(SCALE, 10, 10, 0, 100*SCALE, 0, 0)
|
|
},
|
|
},
|
|
{
|
|
name: "non-positive world height",
|
|
fn: func() {
|
|
_ = correctCameraZoomFp(SCALE, 10, 10, 100*SCALE, 0, 0, 0)
|
|
},
|
|
},
|
|
{
|
|
name: "negative min zoom",
|
|
fn: func() {
|
|
_ = correctCameraZoomFp(SCALE, 10, 10, 100*SCALE, 100*SCALE, -1, 0)
|
|
},
|
|
},
|
|
{
|
|
name: "negative max zoom",
|
|
fn: func() {
|
|
_ = correctCameraZoomFp(SCALE, 10, 10, 100*SCALE, 100*SCALE, 0, -1)
|
|
},
|
|
},
|
|
{
|
|
name: "min greater than max",
|
|
fn: func() {
|
|
_ = correctCameraZoomFp(SCALE, 10, 10, 100*SCALE, 100*SCALE, 2000, 1500)
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
tt := tt
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
require.Panics(t, tt.fn)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestWorldCorrectCameraZoomReturnsFloatValue(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
w := NewWorld(100, 100)
|
|
|
|
got := w.CorrectCameraZoom(1.0, 120, 20)
|
|
|
|
require.Equal(t, 1.2, got)
|
|
}
|
|
|
|
func TestWorldCorrectCameraZoomAppliesDefaultBounds(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
w := NewWorld(100, 100)
|
|
|
|
got := w.CorrectCameraZoom(100.0, 20, 20)
|
|
|
|
require.Equal(t, worldFixedToCameraZoom(MAX_ZOOM), got)
|
|
}
|
|
|
|
func TestWorldCorrectCameraZoomFitBeatsDefaultMaxBound(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
w := NewWorld(1, 100)
|
|
|
|
got := w.CorrectCameraZoom(1.0, 40, 10)
|
|
|
|
require.Equal(t, 40.0, got)
|
|
}
|
|
|
|
func TestCorrectCameraZoomFp_DoesNotLowerZoomWhenViewportIsSmallerThanWorld(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got := correctCameraZoomFp(
|
|
SCALE, // currentZoomFp = 1.0x
|
|
80, 80, // viewport px
|
|
100*SCALE, 100*SCALE, // world fp
|
|
0, 0,
|
|
)
|
|
|
|
// No anti-wrap needed, and we do not auto-fit by lowering zoom.
|
|
require.Equal(t, SCALE, got)
|
|
}
|
|
|
|
func TestCorrectCameraZoomFp_RaisesZoomToPreventWrapWhenViewportIsLarger(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// World width = 100 units, viewport width = 120 px, at zoom=1 visible span = 120 units => too large.
|
|
got := correctCameraZoomFp(
|
|
SCALE,
|
|
120, 20,
|
|
100*SCALE, 100*SCALE,
|
|
0, 0,
|
|
)
|
|
|
|
require.Equal(t, 1200, got) // 1.2x
|
|
}
|
|
|
|
func TestCorrectCameraZoomFp_AppliesMaxZoomWhenNoWrapConflict(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got := correctCameraZoomFp(
|
|
4*SCALE, // user wants 4x
|
|
20, 20,
|
|
100*SCALE, 100*SCALE,
|
|
0, 3*SCALE, // max 3x
|
|
)
|
|
|
|
require.Equal(t, 3*SCALE, got)
|
|
}
|
|
|
|
func TestCorrectCameraZoomFp_AntiWrapBeatsMaxZoom(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// requiredFit = 2x, but max is 1.5x => must return 2x.
|
|
got := correctCameraZoomFp(
|
|
SCALE,
|
|
200, 20,
|
|
100*SCALE, 100*SCALE,
|
|
0, 1500,
|
|
)
|
|
|
|
require.Equal(t, 2*SCALE, got)
|
|
}
|
|
|
|
func TestCorrectCameraZoomFp_AppliesMinZoom(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got := correctCameraZoomFp(
|
|
800, // 0.8x
|
|
20, 20,
|
|
100*SCALE, 100*SCALE,
|
|
SCALE, 0, // min 1.0x
|
|
)
|
|
|
|
require.Equal(t, SCALE, got)
|
|
}
|
|
|
|
func TestCorrectCameraZoomFp_ZeroViewportUsesOnlyBounds(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got := correctCameraZoomFp(
|
|
SCALE,
|
|
0, 0,
|
|
100*SCALE, 100*SCALE,
|
|
1500, 0,
|
|
)
|
|
|
|
require.Equal(t, 1500, got)
|
|
}
|