Marc Di Luzio
8b83672dcc
Only track lower and upper bounds in world space, and speak in terms of world space and chunks
250 lines
7.1 KiB
Go
250 lines
7.1 KiB
Go
package atlas
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/mdiluz/rove/pkg/objects"
|
|
"github.com/mdiluz/rove/pkg/vector"
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func TestAtlas_NewAtlas(t *testing.T) {
|
|
a := NewAtlas(1)
|
|
assert.NotNil(t, a)
|
|
assert.Equal(t, 1, a.ChunkSize)
|
|
assert.Equal(t, 1, len(a.Chunks)) // Should start empty
|
|
}
|
|
|
|
func TestAtlas_toChunk(t *testing.T) {
|
|
a := NewAtlas(1)
|
|
assert.NotNil(t, a)
|
|
|
|
// Get a tile to spawn the chunks
|
|
a.QueryPosition(vector.Vector{X: -1, Y: -1})
|
|
a.QueryPosition(vector.Vector{X: 0, Y: 0})
|
|
assert.Equal(t, 2*2, len(a.Chunks))
|
|
|
|
// Chunks should look like:
|
|
// 2 | 3
|
|
// -----
|
|
// 0 | 1
|
|
chunkID := a.worldSpaceToChunkIndex(vector.Vector{X: 0, Y: 0})
|
|
assert.Equal(t, 3, chunkID)
|
|
chunkID = a.worldSpaceToChunkIndex(vector.Vector{X: 0, Y: -1})
|
|
assert.Equal(t, 1, chunkID)
|
|
chunkID = a.worldSpaceToChunkIndex(vector.Vector{X: -1, Y: -1})
|
|
assert.Equal(t, 0, chunkID)
|
|
chunkID = a.worldSpaceToChunkIndex(vector.Vector{X: -1, Y: 0})
|
|
assert.Equal(t, 2, chunkID)
|
|
|
|
a = NewAtlas(2)
|
|
assert.NotNil(t, a)
|
|
// Get a tile to spawn the chunks
|
|
a.QueryPosition(vector.Vector{X: -2, Y: -2})
|
|
assert.Equal(t, 2*2, len(a.Chunks))
|
|
a.QueryPosition(vector.Vector{X: 1, Y: 1})
|
|
assert.Equal(t, 2*2, len(a.Chunks))
|
|
// Chunks should look like:
|
|
// 2 | 3
|
|
// -----
|
|
// 0 | 1
|
|
chunkID = a.worldSpaceToChunkIndex(vector.Vector{X: 1, Y: 1})
|
|
assert.Equal(t, 3, chunkID)
|
|
chunkID = a.worldSpaceToChunkIndex(vector.Vector{X: 1, Y: -2})
|
|
assert.Equal(t, 1, chunkID)
|
|
chunkID = a.worldSpaceToChunkIndex(vector.Vector{X: -2, Y: -2})
|
|
assert.Equal(t, 0, chunkID)
|
|
chunkID = a.worldSpaceToChunkIndex(vector.Vector{X: -2, Y: 1})
|
|
assert.Equal(t, 2, chunkID)
|
|
|
|
a = NewAtlas(2)
|
|
assert.NotNil(t, a)
|
|
// Get a tile to spawn a 4x4 grid of chunks
|
|
a.QueryPosition(vector.Vector{X: 3, Y: 3})
|
|
assert.Equal(t, 2*2, len(a.Chunks))
|
|
a.QueryPosition(vector.Vector{X: -3, Y: -3})
|
|
assert.Equal(t, 4*4, len(a.Chunks))
|
|
|
|
// Chunks should look like:
|
|
// 12| 13|| 14| 15
|
|
// ----------------
|
|
// 8 | 9 || 10| 11
|
|
// ================
|
|
// 4 | 5 || 6 | 7
|
|
// ----------------
|
|
// 0 | 1 || 2 | 3
|
|
chunkID = a.worldSpaceToChunkIndex(vector.Vector{X: 1, Y: 3})
|
|
assert.Equal(t, 14, chunkID)
|
|
chunkID = a.worldSpaceToChunkIndex(vector.Vector{X: 1, Y: -3})
|
|
assert.Equal(t, 2, chunkID)
|
|
chunkID = a.worldSpaceToChunkIndex(vector.Vector{X: -1, Y: -1})
|
|
assert.Equal(t, 5, chunkID)
|
|
chunkID = a.worldSpaceToChunkIndex(vector.Vector{X: -2, Y: 2})
|
|
assert.Equal(t, 13, chunkID)
|
|
|
|
a = NewAtlas(3)
|
|
assert.NotNil(t, a)
|
|
// Get a tile to spawn a 4x4 grid of chunks
|
|
a.QueryPosition(vector.Vector{X: 3, Y: 3})
|
|
assert.Equal(t, 2*2, len(a.Chunks))
|
|
|
|
// Chunks should look like:
|
|
// || 2| 3
|
|
// -------
|
|
// || 0| 1
|
|
// =======
|
|
chunkID = a.worldSpaceToChunkIndex(vector.Vector{X: 1, Y: 1})
|
|
assert.Equal(t, 0, chunkID)
|
|
chunkID = a.worldSpaceToChunkIndex(vector.Vector{X: 3, Y: 1})
|
|
assert.Equal(t, 1, chunkID)
|
|
chunkID = a.worldSpaceToChunkIndex(vector.Vector{X: 1, Y: 4})
|
|
assert.Equal(t, 2, chunkID)
|
|
chunkID = a.worldSpaceToChunkIndex(vector.Vector{X: 5, Y: 5})
|
|
assert.Equal(t, 3, chunkID)
|
|
}
|
|
|
|
func TestAtlas_toWorld(t *testing.T) {
|
|
a := NewAtlas(1)
|
|
assert.NotNil(t, a)
|
|
|
|
// Get a tile to spawn some chunks
|
|
a.QueryPosition(vector.Vector{X: -1, Y: -1})
|
|
assert.Equal(t, 2*2, len(a.Chunks))
|
|
|
|
// Chunks should look like:
|
|
// 2 | 3
|
|
// -----
|
|
// 0 | 1
|
|
assert.Equal(t, vector.Vector{X: -1, Y: -1}, a.chunkOriginInWorldSpace(0))
|
|
assert.Equal(t, vector.Vector{X: 0, Y: -1}, a.chunkOriginInWorldSpace(1))
|
|
|
|
a = NewAtlas(2)
|
|
assert.NotNil(t, a)
|
|
// Get a tile to spawn the chunks
|
|
a.QueryPosition(vector.Vector{X: -2, Y: -2})
|
|
assert.Equal(t, 2*2, len(a.Chunks))
|
|
a.QueryPosition(vector.Vector{X: 1, Y: 1})
|
|
assert.Equal(t, 2*2, len(a.Chunks))
|
|
// Chunks should look like:
|
|
// 2 | 3
|
|
// -----
|
|
// 0 | 1
|
|
assert.Equal(t, vector.Vector{X: -2, Y: -2}, a.chunkOriginInWorldSpace(0))
|
|
assert.Equal(t, vector.Vector{X: -2, Y: 0}, a.chunkOriginInWorldSpace(2))
|
|
|
|
a = NewAtlas(2)
|
|
assert.NotNil(t, a)
|
|
// Get a tile to spawn a 4x4 grid of chunks
|
|
a.QueryPosition(vector.Vector{X: 3, Y: 3})
|
|
assert.Equal(t, 2*2, len(a.Chunks))
|
|
a.QueryPosition(vector.Vector{X: -3, Y: -3})
|
|
assert.Equal(t, 4*4, len(a.Chunks))
|
|
|
|
// Chunks should look like:
|
|
// 12| 13|| 14| 15
|
|
// ----------------
|
|
// 8 | 9 || 10| 11
|
|
// ================
|
|
// 4 | 5 || 6 | 7
|
|
// ----------------
|
|
// 0 | 1 || 2 | 3
|
|
assert.Equal(t, vector.Vector{X: -4, Y: -4}, a.chunkOriginInWorldSpace(0))
|
|
assert.Equal(t, vector.Vector{X: 2, Y: -2}, a.chunkOriginInWorldSpace(7))
|
|
|
|
a = NewAtlas(3)
|
|
assert.NotNil(t, a)
|
|
// Get a tile to spawn a 4x4 grid of chunks
|
|
a.QueryPosition(vector.Vector{X: 3, Y: 3})
|
|
assert.Equal(t, 2*2, len(a.Chunks))
|
|
|
|
// Chunks should look like:
|
|
// || 2| 3
|
|
// -------
|
|
// || 0| 1
|
|
// =======
|
|
assert.Equal(t, vector.Vector{X: 0, Y: 0}, a.chunkOriginInWorldSpace(0))
|
|
}
|
|
|
|
func TestAtlas_GetSetTile(t *testing.T) {
|
|
a := NewAtlas(10)
|
|
assert.NotNil(t, a)
|
|
|
|
// Set the origin tile to 1 and test it
|
|
a.SetTile(vector.Vector{X: 0, Y: 0}, 1)
|
|
tile, _ := a.QueryPosition(vector.Vector{X: 0, Y: 0})
|
|
assert.Equal(t, byte(1), tile)
|
|
|
|
// Set another tile to 1 and test it
|
|
a.SetTile(vector.Vector{X: 5, Y: -2}, 2)
|
|
tile, _ = a.QueryPosition(vector.Vector{X: 5, Y: -2})
|
|
assert.Equal(t, byte(2), tile)
|
|
}
|
|
|
|
func TestAtlas_GetSetObject(t *testing.T) {
|
|
a := NewAtlas(10)
|
|
assert.NotNil(t, a)
|
|
|
|
// Set the origin tile to 1 and test it
|
|
a.SetObject(vector.Vector{X: 0, Y: 0}, objects.Object{Type: objects.LargeRock})
|
|
_, obj := a.QueryPosition(vector.Vector{X: 0, Y: 0})
|
|
assert.Equal(t, objects.Object{Type: objects.LargeRock}, obj)
|
|
|
|
// Set another tile to 1 and test it
|
|
a.SetObject(vector.Vector{X: 5, Y: -2}, objects.Object{Type: objects.SmallRock})
|
|
_, obj = a.QueryPosition(vector.Vector{X: 5, Y: -2})
|
|
assert.Equal(t, objects.Object{Type: objects.SmallRock}, obj)
|
|
}
|
|
|
|
func TestAtlas_Grown(t *testing.T) {
|
|
// Start with a small example
|
|
a := NewAtlas(2)
|
|
assert.NotNil(t, a)
|
|
assert.Equal(t, 1, len(a.Chunks))
|
|
|
|
// Set a few tiles to values
|
|
a.SetTile(vector.Vector{X: 0, Y: 0}, 1)
|
|
a.SetTile(vector.Vector{X: -1, Y: -1}, 2)
|
|
a.SetTile(vector.Vector{X: 1, Y: -2}, 3)
|
|
|
|
// Check tile values
|
|
tile, _ := a.QueryPosition(vector.Vector{X: 0, Y: 0})
|
|
assert.Equal(t, byte(1), tile)
|
|
|
|
tile, _ = a.QueryPosition(vector.Vector{X: -1, Y: -1})
|
|
assert.Equal(t, byte(2), tile)
|
|
|
|
tile, _ = a.QueryPosition(vector.Vector{X: 1, Y: -2})
|
|
assert.Equal(t, byte(3), tile)
|
|
|
|
tile, _ = a.QueryPosition(vector.Vector{X: 0, Y: 0})
|
|
assert.Equal(t, byte(1), tile)
|
|
|
|
tile, _ = a.QueryPosition(vector.Vector{X: -1, Y: -1})
|
|
assert.Equal(t, byte(2), tile)
|
|
|
|
tile, _ = a.QueryPosition(vector.Vector{X: 1, Y: -2})
|
|
assert.Equal(t, byte(3), tile)
|
|
}
|
|
|
|
func TestAtlas_GetSetCorrect(t *testing.T) {
|
|
// Big stress test to ensure we do actually properly expand for all reasonable values
|
|
for i := 1; i <= 4; i++ {
|
|
|
|
for x := -i * 2; x < i*2; x++ {
|
|
for y := -i * 2; y < i*2; y++ {
|
|
a := NewAtlas(i)
|
|
assert.NotNil(t, a)
|
|
assert.Equal(t, 1, len(a.Chunks))
|
|
|
|
pos := vector.Vector{X: x, Y: y}
|
|
a.SetTile(pos, TileRock)
|
|
a.SetObject(pos, objects.Object{Type: objects.LargeRock})
|
|
tile, obj := a.QueryPosition(pos)
|
|
|
|
assert.Equal(t, TileRock, Tile(tile))
|
|
assert.Equal(t, objects.Object{Type: objects.LargeRock}, obj)
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|