876 lines
20 KiB
Go
876 lines
20 KiB
Go
package rulesets
|
|
|
|
import (
|
|
"math"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestSanity(t *testing.T) {
|
|
r := StandardRuleset{}
|
|
next, err := r.ResolveMoves(
|
|
&Game{},
|
|
&GameState{},
|
|
[]*SnakeMove{},
|
|
)
|
|
|
|
require.NoError(t, err)
|
|
require.NotNil(t, next)
|
|
}
|
|
|
|
func TestMoveSnakes(t *testing.T) {
|
|
gs := &GameState{
|
|
Snakes: []*Snake{
|
|
{
|
|
ID: "one",
|
|
Body: []*Point{{10, 110}, {11, 110}},
|
|
Health: 111111,
|
|
},
|
|
{
|
|
ID: "two",
|
|
Body: []*Point{{23, 220}, {22, 220}, {21, 220}, {20, 220}},
|
|
Health: 222222,
|
|
},
|
|
},
|
|
}
|
|
|
|
tests := []struct {
|
|
MoveOne string
|
|
ExpectedOne []*Point
|
|
MoveTwo string
|
|
ExpectedTwo []*Point
|
|
}{
|
|
{
|
|
MOVE_UP,
|
|
[]*Point{{10, 109}, {10, 110}},
|
|
MOVE_DOWN,
|
|
[]*Point{{23, 221}, {23, 220}, {22, 220}, {21, 220}},
|
|
},
|
|
{
|
|
MOVE_RIGHT,
|
|
[]*Point{{11, 109}, {10, 109}},
|
|
MOVE_LEFT,
|
|
[]*Point{{22, 221}, {23, 221}, {23, 220}, {22, 220}},
|
|
},
|
|
{
|
|
MOVE_RIGHT,
|
|
[]*Point{{12, 109}, {11, 109}},
|
|
MOVE_LEFT,
|
|
[]*Point{{21, 221}, {22, 221}, {23, 221}, {23, 220}},
|
|
},
|
|
{
|
|
MOVE_RIGHT,
|
|
[]*Point{{13, 109}, {12, 109}},
|
|
MOVE_LEFT,
|
|
[]*Point{{20, 221}, {21, 221}, {22, 221}, {23, 221}},
|
|
},
|
|
{
|
|
MOVE_UP,
|
|
[]*Point{{13, 108}, {13, 109}},
|
|
MOVE_DOWN,
|
|
[]*Point{{20, 222}, {20, 221}, {21, 221}, {22, 221}},
|
|
},
|
|
}
|
|
|
|
r := StandardRuleset{}
|
|
for _, test := range tests {
|
|
moves := []*SnakeMove{
|
|
{Snake: gs.Snakes[0], Move: test.MoveOne},
|
|
{Snake: gs.Snakes[1], Move: test.MoveTwo},
|
|
}
|
|
err := r.moveSnakes(gs, moves)
|
|
|
|
require.NoError(t, err)
|
|
require.Len(t, gs.Snakes, 2)
|
|
require.Equal(t, int32(111111), gs.Snakes[0].Health)
|
|
require.Equal(t, int32(222222), gs.Snakes[1].Health)
|
|
require.Len(t, gs.Snakes[0].Body, 2)
|
|
require.Len(t, gs.Snakes[1].Body, 4)
|
|
|
|
require.Equal(t, len(gs.Snakes[0].Body), len(test.ExpectedOne))
|
|
for i, e := range test.ExpectedOne {
|
|
require.Equal(t, *e, *gs.Snakes[0].Body[i])
|
|
}
|
|
require.Equal(t, len(gs.Snakes[1].Body), len(test.ExpectedTwo))
|
|
for i, e := range test.ExpectedTwo {
|
|
require.Equal(t, *e, *gs.Snakes[1].Body[i])
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMoveSnakesDefault(t *testing.T) {
|
|
tests := []struct {
|
|
Body []*Point
|
|
Move string
|
|
Expected []*Point
|
|
}{
|
|
{
|
|
Body: []*Point{{0, 0}},
|
|
Move: "asdf",
|
|
Expected: []*Point{{0, -1}},
|
|
},
|
|
{
|
|
Body: []*Point{{5, 5}, {5, 5}},
|
|
Move: "",
|
|
Expected: []*Point{{5, 4}, {5, 5}},
|
|
},
|
|
{
|
|
Body: []*Point{{5, 5}, {5, 4}},
|
|
Expected: []*Point{{5, 6}, {5, 5}},
|
|
},
|
|
{
|
|
Body: []*Point{{5, 4}, {5, 5}},
|
|
Expected: []*Point{{5, 3}, {5, 4}},
|
|
},
|
|
{
|
|
Body: []*Point{{5, 4}, {5, 5}},
|
|
Expected: []*Point{{5, 3}, {5, 4}},
|
|
},
|
|
{
|
|
Body: []*Point{{4, 5}, {5, 5}},
|
|
Expected: []*Point{{3, 5}, {4, 5}},
|
|
},
|
|
{
|
|
Body: []*Point{{5, 5}, {4, 5}},
|
|
Expected: []*Point{{6, 5}, {5, 5}},
|
|
},
|
|
}
|
|
|
|
r := StandardRuleset{}
|
|
for _, test := range tests {
|
|
gs := &GameState{
|
|
Snakes: []*Snake{
|
|
{Body: test.Body},
|
|
},
|
|
}
|
|
moves := []*SnakeMove{{Snake: gs.Snakes[0], Move: test.Move}}
|
|
|
|
err := r.moveSnakes(gs, moves)
|
|
require.NoError(t, err)
|
|
require.Len(t, gs.Snakes, 1)
|
|
require.Equal(t, len(test.Body), len(gs.Snakes[0].Body))
|
|
require.Equal(t, len(test.Expected), len(gs.Snakes[0].Body))
|
|
for i, e := range test.Expected {
|
|
require.Equal(t, *e, *gs.Snakes[0].Body[i])
|
|
}
|
|
}
|
|
}
|
|
|
|
// func TestMoveSnakesDefault(t *testing.T) {
|
|
// gs := &GameState{
|
|
// Snakes: []*Snake{
|
|
// {
|
|
// ID: "one",
|
|
// Body: []*Point{{10, 110}, {11, 110}, {12, 110}},
|
|
// Health: 111111,
|
|
// },
|
|
// },
|
|
// }
|
|
|
|
// tests := []struct {
|
|
// Move string
|
|
// Expected []*Point
|
|
// }{
|
|
// {"asdf", []*Point{{10, 109}, {10, 110}, {10, 111}}},
|
|
// {"asdf", []*Point{{10, 108}, {10, 109}, {10, 110}}},
|
|
// {"asdf", []*Point{{10, 107}, {10, 108}, {10, 109}}},
|
|
// {"asdf", []*Point{{10, 106}, {10, 107}, {10, 108}}},
|
|
// }
|
|
|
|
// r := StandardRuleset{}
|
|
// for _, test := range tests {
|
|
// moves := []*SnakeMove{
|
|
// {Snake: gs.Snakes[0], Move: test.Move},
|
|
// }
|
|
// err := r.moveSnakes(gs, moves)
|
|
|
|
// require.NoError(t, err)
|
|
// require.Len(t, gs.Snakes, 1)
|
|
// require.Equal(t, int32(111111), gs.Snakes[0].Health)
|
|
// require.Len(t, gs.Snakes[0].Body, 3)
|
|
|
|
// require.Equal(t, len(gs.Snakes[0].Body), len(test.Expected))
|
|
// for i, e := range test.ExpectedOne {
|
|
// require.Equal(t, *e, *gs.Snakes[0].Body[i])
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// func TestMoveSnakesDefault(t *testing.T) {
|
|
// tests := []struct {
|
|
// Body []*Point
|
|
// Expected string
|
|
// }{
|
|
// {
|
|
// Body: []*Point{},
|
|
// Expected: MOVE_UP,
|
|
// },
|
|
// {
|
|
// Body: []*Point{
|
|
// {X: 0, Y: 0},
|
|
// },
|
|
// Expected: MOVE_UP,
|
|
// },
|
|
// {
|
|
// Body: []*Point{
|
|
// {X: 5, Y: 5},
|
|
// {X: 5, Y: 5},
|
|
// },
|
|
// Expected: MOVE_UP,
|
|
// },
|
|
// {
|
|
// Body: []*Point{
|
|
// {X: 5, Y: 5},
|
|
// {X: 5, Y: 4},
|
|
// },
|
|
// Expected: MOVE_DOWN,
|
|
// },
|
|
// {
|
|
// Body: []*Point{
|
|
// {X: 5, Y: 4},
|
|
// {X: 5, Y: 5},
|
|
// },
|
|
// Expected: MOVE_UP,
|
|
// },
|
|
// {
|
|
// Body: []*Point{
|
|
// {X: 4, Y: 5},
|
|
// {X: 5, Y: 5},
|
|
// },
|
|
// Expected: MOVE_LEFT,
|
|
// },
|
|
// {
|
|
// Body: []*Point{
|
|
// {X: 5, Y: 5},
|
|
// {X: 4, Y: 5},
|
|
// },
|
|
// Expected: MOVE_RIGHT,
|
|
// },
|
|
// }
|
|
|
|
// r := StandardRuleset{}
|
|
// for _, test := range tests {
|
|
// s := &Snake{Body: test.Body}
|
|
// actual := r.getDefaultMove(s)
|
|
// require.Equal(t, test.Expected, actual)
|
|
// }
|
|
// }
|
|
|
|
func TestReduceSnakeHealth(t *testing.T) {
|
|
var err error
|
|
r := StandardRuleset{}
|
|
gs := &GameState{
|
|
Snakes: []*Snake{
|
|
&Snake{
|
|
Body: []*Point{{0, 0}, {0, 1}},
|
|
Health: 99,
|
|
},
|
|
&Snake{
|
|
Body: []*Point{{5, 8}, {6, 8}, {7, 8}},
|
|
Health: 2,
|
|
},
|
|
},
|
|
}
|
|
|
|
err = r.reduceSnakeHealth(gs)
|
|
require.NoError(t, err)
|
|
require.Equal(t, gs.Snakes[0].Health, int32(98))
|
|
require.Equal(t, gs.Snakes[1].Health, int32(1))
|
|
|
|
err = r.reduceSnakeHealth(gs)
|
|
require.NoError(t, err)
|
|
require.Equal(t, gs.Snakes[0].Health, int32(97))
|
|
require.Equal(t, gs.Snakes[1].Health, int32(0))
|
|
|
|
err = r.reduceSnakeHealth(gs)
|
|
require.NoError(t, err)
|
|
require.Equal(t, gs.Snakes[0].Health, int32(96))
|
|
require.Equal(t, gs.Snakes[1].Health, int32(-1))
|
|
|
|
err = r.reduceSnakeHealth(gs)
|
|
require.NoError(t, err)
|
|
require.Equal(t, gs.Snakes[0].Health, int32(95))
|
|
require.Equal(t, gs.Snakes[1].Health, int32(-2))
|
|
}
|
|
|
|
func TestSnakeHasStarved(t *testing.T) {
|
|
tests := []struct {
|
|
Health int32
|
|
Expected bool
|
|
}{
|
|
{Health: math.MinInt32, Expected: true},
|
|
{Health: -10, Expected: true},
|
|
{Health: -2, Expected: true},
|
|
{Health: -1, Expected: true},
|
|
{Health: 0, Expected: true},
|
|
{Health: 1, Expected: false},
|
|
{Health: 2, Expected: false},
|
|
{Health: 10, Expected: false},
|
|
{Health: math.MaxInt32, Expected: false},
|
|
}
|
|
|
|
r := StandardRuleset{}
|
|
for _, test := range tests {
|
|
s := &Snake{Health: test.Health}
|
|
require.Equal(t, test.Expected, r.snakeHasStarved(s), "Health: %+v", test.Health)
|
|
}
|
|
}
|
|
|
|
func TestSnakeIsOutOfBounds(t *testing.T) {
|
|
var boardWidth int32 = 10
|
|
var boardHeight int32 = 100
|
|
|
|
tests := []struct {
|
|
Point Point
|
|
Expected bool
|
|
}{
|
|
{Point{X: math.MinInt32, Y: math.MinInt32}, true},
|
|
{Point{X: math.MinInt32, Y: 0}, true},
|
|
{Point{X: 0, Y: math.MinInt32}, true},
|
|
{Point{X: -1, Y: -1}, true},
|
|
{Point{X: -1, Y: 0}, true},
|
|
{Point{X: 0, Y: -1}, true},
|
|
{Point{X: 0, Y: 0}, false},
|
|
{Point{X: 1, Y: 0}, false},
|
|
{Point{X: 0, Y: 1}, false},
|
|
{Point{X: 1, Y: 1}, false},
|
|
{Point{X: 9, Y: 9}, false},
|
|
{Point{X: 9, Y: 10}, false},
|
|
{Point{X: 9, Y: 11}, false},
|
|
{Point{X: 10, Y: 9}, true},
|
|
{Point{X: 10, Y: 10}, true},
|
|
{Point{X: 10, Y: 11}, true},
|
|
{Point{X: 11, Y: 9}, true},
|
|
{Point{X: 11, Y: 10}, true},
|
|
{Point{X: 11, Y: 11}, true},
|
|
{Point{X: math.MaxInt32, Y: 11}, true},
|
|
{Point{X: 9, Y: 99}, false},
|
|
{Point{X: 9, Y: 100}, true},
|
|
{Point{X: 9, Y: 101}, true},
|
|
{Point{X: 9, Y: math.MaxInt32}, true},
|
|
{Point{X: math.MaxInt32, Y: math.MaxInt32}, true},
|
|
}
|
|
|
|
var s *Snake
|
|
r := StandardRuleset{}
|
|
for _, test := range tests {
|
|
// Test with point as head
|
|
s = &Snake{Body: []*Point{&test.Point}}
|
|
require.Equal(t, test.Expected, r.snakeIsOutOfBounds(s, boardWidth, boardHeight), "Head%+v", test.Point)
|
|
// Test with point as body
|
|
s = &Snake{Body: []*Point{&Point{0, 0}, &Point{0, 0}, &test.Point}}
|
|
require.Equal(t, test.Expected, r.snakeIsOutOfBounds(s, boardWidth, boardHeight), "Body%+v", test.Point)
|
|
}
|
|
}
|
|
|
|
func TestSnakeHasBodyCollidedSelf(t *testing.T) {
|
|
tests := []struct {
|
|
Body []*Point
|
|
Expected bool
|
|
}{
|
|
{[]*Point{{1, 1}}, false},
|
|
// Self stacks should self collide
|
|
// (we rely on snakes moving before we check self-collision on turn one)
|
|
{[]*Point{{2, 2}, {2, 2}}, true},
|
|
{[]*Point{{3, 3}, {3, 3}, {3, 3}}, true},
|
|
{[]*Point{{5, 5}, {5, 5}, {5, 5}, {5, 5}, {5, 5}}, true},
|
|
// Non-collision cases
|
|
{[]*Point{{0, 0}, {1, 0}, {1, 0}}, false},
|
|
{[]*Point{{0, 0}, {1, 0}, {2, 0}}, false},
|
|
{[]*Point{{0, 0}, {1, 0}, {2, 0}, {2, 0}, {2, 0}}, false},
|
|
{[]*Point{{0, 0}, {1, 0}, {2, 0}, {3, 0}, {4, 0}}, false},
|
|
{[]*Point{{0, 0}, {0, 1}, {0, 2}}, false},
|
|
{[]*Point{{0, 0}, {0, 1}, {0, 2}, {0, 2}, {0, 2}}, false},
|
|
{[]*Point{{0, 0}, {0, 1}, {0, 2}, {0, 3}, {0, 4}}, false},
|
|
// Collision cases
|
|
{[]*Point{{0, 0}, {1, 0}, {0, 0}}, true},
|
|
{[]*Point{{0, 0}, {0, 0}, {1, 0}}, true},
|
|
{[]*Point{{0, 0}, {1, 0}, {1, 1}, {0, 1}, {0, 0}}, true},
|
|
{[]*Point{{4, 4}, {3, 4}, {3, 3}, {4, 4}, {4, 4}}, true},
|
|
{[]*Point{{3, 3}, {3, 4}, {3, 3}, {4, 4}, {4, 5}}, true},
|
|
}
|
|
|
|
var s *Snake
|
|
r := StandardRuleset{}
|
|
for _, test := range tests {
|
|
s = &Snake{Body: test.Body}
|
|
require.Equal(t, test.Expected, r.snakeHasBodyCollided(s, s), "Body%q", s.Body)
|
|
}
|
|
}
|
|
|
|
func TestSnakeHasBodyCollidedOther(t *testing.T) {
|
|
tests := []struct {
|
|
SnakeBody []*Point
|
|
OtherBody []*Point
|
|
Expected bool
|
|
}{
|
|
{
|
|
// Just heads
|
|
[]*Point{{0, 0}},
|
|
[]*Point{{1, 1}},
|
|
false,
|
|
},
|
|
{
|
|
// Head-to-heads are not considered in body collisions
|
|
[]*Point{{0, 0}},
|
|
[]*Point{{0, 0}},
|
|
false,
|
|
},
|
|
{
|
|
// Stacked bodies
|
|
[]*Point{{0, 0}},
|
|
[]*Point{{0, 0}, {0, 0}},
|
|
true,
|
|
},
|
|
{
|
|
// Separate stacked bodies
|
|
[]*Point{{0, 0}, {0, 0}, {0, 0}},
|
|
[]*Point{{1, 1}, {1, 1}, {1, 1}},
|
|
false,
|
|
},
|
|
{
|
|
// Stacked bodies, separated heads
|
|
[]*Point{{0, 0}, {1, 0}, {1, 0}},
|
|
[]*Point{{2, 0}, {1, 0}, {1, 0}},
|
|
false,
|
|
},
|
|
{
|
|
// Mid-snake collision
|
|
[]*Point{{1, 1}},
|
|
[]*Point{{0, 1}, {1, 1}, {2, 1}},
|
|
true,
|
|
},
|
|
}
|
|
|
|
var s *Snake
|
|
var o *Snake
|
|
r := StandardRuleset{}
|
|
for _, test := range tests {
|
|
s = &Snake{Body: test.SnakeBody}
|
|
o = &Snake{Body: test.OtherBody}
|
|
require.Equal(t, test.Expected, r.snakeHasBodyCollided(s, o), "Snake%q Other%q", s.Body, o.Body)
|
|
}
|
|
}
|
|
|
|
func TestSnakeHasLostHeadToHead(t *testing.T) {
|
|
tests := []struct {
|
|
SnakeBody []*Point
|
|
OtherBody []*Point
|
|
Expected bool
|
|
ExpectedOpposite bool
|
|
}{
|
|
{
|
|
// Just heads
|
|
[]*Point{{0, 0}},
|
|
[]*Point{{1, 1}},
|
|
false, false,
|
|
},
|
|
{
|
|
// Just heads colliding
|
|
[]*Point{{0, 0}},
|
|
[]*Point{{0, 0}},
|
|
true, true,
|
|
},
|
|
{
|
|
// One snake larger
|
|
[]*Point{{0, 0}, {1, 0}, {2, 0}},
|
|
[]*Point{{0, 0}},
|
|
false, true,
|
|
},
|
|
{
|
|
// Other snake equal
|
|
[]*Point{{0, 0}, {1, 0}, {2, 0}},
|
|
[]*Point{{0, 0}, {0, 1}, {0, 2}},
|
|
true, true,
|
|
},
|
|
{
|
|
// Other snake longer
|
|
[]*Point{{0, 0}, {1, 0}, {2, 0}},
|
|
[]*Point{{0, 0}, {0, 1}, {0, 2}, {0, 3}},
|
|
true, false,
|
|
},
|
|
{
|
|
// Body collision
|
|
[]*Point{{0, 1}, {1, 1}, {2, 1}},
|
|
[]*Point{{0, 0}, {0, 1}, {0, 2}, {0, 3}},
|
|
false, false,
|
|
},
|
|
{
|
|
// Separate stacked bodies, head collision
|
|
[]*Point{{3, 10}, {2, 10}, {2, 10}},
|
|
[]*Point{{3, 10}, {4, 10}, {4, 10}},
|
|
true, true,
|
|
},
|
|
{
|
|
// Separate stacked bodies, head collision
|
|
[]*Point{{10, 3}, {10, 2}, {10, 1}, {10, 0}},
|
|
[]*Point{{10, 3}, {10, 4}, {10, 5}},
|
|
false, true,
|
|
},
|
|
}
|
|
|
|
var s *Snake
|
|
var o *Snake
|
|
r := StandardRuleset{}
|
|
for _, test := range tests {
|
|
s = &Snake{Body: test.SnakeBody}
|
|
o = &Snake{Body: test.OtherBody}
|
|
require.Equal(t, test.Expected, r.snakeHasLostHeadToHead(s, o), "Snake%q Other%q", s.Body, o.Body)
|
|
require.Equal(t, test.ExpectedOpposite, r.snakeHasLostHeadToHead(o, s), "Snake%q Other%q", s.Body, o.Body)
|
|
}
|
|
|
|
}
|
|
|
|
func TestFeedSnakes(t *testing.T) {
|
|
r := StandardRuleset{}
|
|
gs := &GameState{
|
|
Snakes: []*Snake{
|
|
{Body: []*Point{
|
|
{2, 1}, {1, 1}, {1, 2}, {2, 2},
|
|
}},
|
|
},
|
|
Food: []*Point{
|
|
{2, 1},
|
|
},
|
|
}
|
|
|
|
err := r.feedSnakes(gs)
|
|
require.NoError(t, err)
|
|
require.Equal(t, 0, len(gs.Food))
|
|
|
|
}
|
|
|
|
// func TestCheckForSnakesEating(t *testing.T) {
|
|
// snake := &pb.Snake{
|
|
// Body: []*pb.Point{
|
|
// {X: 2, Y: 1},
|
|
// {X: 1, Y: 1},
|
|
// {X: 1, Y: 2},
|
|
// {X: 2, Y: 2},
|
|
// },
|
|
// }
|
|
// checkForSnakesEating(&pb.GameFrame{
|
|
// Food: []*pb.Point{
|
|
// {X: 2, Y: 1},
|
|
// },
|
|
// Snakes: []*pb.Snake{snake},
|
|
// })
|
|
// require.Len(t, snake.Body, 4)
|
|
// require.Equal(t, snake.Body[2], snake.Body[3])
|
|
// }
|
|
|
|
// func TestCheckForSnakesNotEating(t *testing.T) {
|
|
// snake := &pb.Snake{
|
|
// Body: []*pb.Point{
|
|
// {X: 2, Y: 1},
|
|
// {X: 1, Y: 1},
|
|
// {X: 1, Y: 2},
|
|
// {X: 2, Y: 2},
|
|
// },
|
|
// }
|
|
// checkForSnakesEating(&pb.GameFrame{
|
|
// Food: []*pb.Point{},
|
|
// Snakes: []*pb.Snake{snake},
|
|
// })
|
|
// require.Len(t, snake.Body, 3)
|
|
// require.NotEqual(t, snake.Body[2], snake.Body[1])
|
|
// }
|
|
// func TestGameFrameSnakeEats(t *testing.T) {
|
|
// snake := &pb.Snake{
|
|
// Health: 67,
|
|
// Body: []*pb.Point{
|
|
// {X: 1, Y: 1},
|
|
// {X: 1, Y: 2},
|
|
// {X: 1, Y: 3},
|
|
// },
|
|
// }
|
|
|
|
// lastFrame.Snakes = []*pb.Snake{snake}
|
|
|
|
// gt, err := GameTick(commonGame, lastFrame)
|
|
// require.NoError(t, err)
|
|
// require.Len(t, gt.Snakes, 1)
|
|
// snake = gt.Snakes[0]
|
|
// require.Equal(t, int32(100), snake.Health)
|
|
// require.Len(t, snake.Body, 4)
|
|
// }
|
|
|
|
// func TestUpdateFood(t *testing.T) {
|
|
// updated, err := updateFood(&pb.Game{Width: 20, Height: 20}, &pb.GameFrame{
|
|
// Food: []*pb.Point{
|
|
// {X: 1, Y: 1},
|
|
// {X: 1, Y: 2},
|
|
// },
|
|
// Snakes: []*pb.Snake{
|
|
// {
|
|
// Body: []*pb.Point{
|
|
// {X: 1, Y: 2},
|
|
// {X: 2, Y: 2},
|
|
// {X: 3, Y: 2},
|
|
// },
|
|
// },
|
|
// },
|
|
// }, []*pb.Point{
|
|
// {X: 1, Y: 2},
|
|
// })
|
|
// require.NoError(t, err)
|
|
// require.Len(t, updated, 2)
|
|
// require.True(t, updated[0].Equal(&pb.Point{X: 1, Y: 1}))
|
|
// require.False(t, updated[1].Equal(&pb.Point{X: 1, Y: 2}))
|
|
// require.False(t, updated[1].Equal(&pb.Point{X: 2, Y: 2}))
|
|
// require.False(t, updated[1].Equal(&pb.Point{X: 3, Y: 2}))
|
|
// require.False(t, updated[1].Equal(&pb.Point{X: 1, Y: 1}))
|
|
// }
|
|
|
|
// func TestUpdateFoodWithFullBoard(t *testing.T) {
|
|
// updated, err := updateFood(&pb.Game{Width: 2, Height: 2}, &pb.GameFrame{
|
|
// Food: []*pb.Point{
|
|
// {X: 0, Y: 0},
|
|
// },
|
|
// Snakes: []*pb.Snake{
|
|
// {
|
|
// Body: []*pb.Point{
|
|
// {X: 0, Y: 0},
|
|
// {X: 0, Y: 1},
|
|
// {X: 1, Y: 1},
|
|
// {X: 1, Y: 0},
|
|
// },
|
|
// },
|
|
// },
|
|
// }, []*pb.Point{
|
|
// {X: 0, Y: 0},
|
|
// })
|
|
// require.NoError(t, err)
|
|
// require.Len(t, updated, 0)
|
|
// }
|
|
|
|
// func TestGetUnoccupiedPointEven(t *testing.T) {
|
|
|
|
// unoccupiedPoint := getUnoccupiedPointEven(2, 2,
|
|
// []*pb.Point{},
|
|
// []*pb.Snake{})
|
|
// require.True(t, (unoccupiedPoint.X+unoccupiedPoint.Y)%2 == 0, "Point coordinates should sum to an even number %o ", unoccupiedPoint)
|
|
// }
|
|
|
|
// func TestGetUnoccupiedPointOdd(t *testing.T) {
|
|
// unoccupiedPoint := getUnoccupiedPointOdd(2, 2,
|
|
// []*pb.Point{{X: 0, Y: 1}},
|
|
// []*pb.Snake{})
|
|
// require.True(t, (unoccupiedPoint.X+unoccupiedPoint.Y)%2 == 1, "Point coordinates should sum to an odd number %o ", unoccupiedPoint)
|
|
// }
|
|
|
|
// func TestGetUnoccupiedPointWithFullBoard(t *testing.T) {
|
|
// unoccupiedPoint := getUnoccupiedPoint(2, 2,
|
|
// []*pb.Point{{X: 0, Y: 0}},
|
|
// []*pb.Snake{
|
|
// {
|
|
// Body: []*pb.Point{
|
|
// {X: 0, Y: 1},
|
|
// {X: 1, Y: 1},
|
|
// {X: 1, Y: 0},
|
|
// },
|
|
// },
|
|
// })
|
|
// require.True(t, unoccupiedPoint.Equal(nil))
|
|
// }
|
|
|
|
// func TestGetUnoccupiedPointsWithEmptySpots(t *testing.T) {
|
|
// unoccupiedPoints := getUnoccupiedPoints(2, 2,
|
|
// []*pb.Point{{X: 0, Y: 0}},
|
|
// []*pb.Snake{
|
|
// {
|
|
// Body: []*pb.Point{
|
|
// {X: 0, Y: 1},
|
|
// },
|
|
// },
|
|
// })
|
|
|
|
// require.Len(t, unoccupiedPoints, 2)
|
|
// require.True(t, unoccupiedPoints[0].Equal(&pb.Point{X: 1, Y: 0}))
|
|
// require.True(t, unoccupiedPoints[1].Equal(&pb.Point{X: 1, Y: 1}))
|
|
// }
|
|
|
|
// func TestGetUniqOccupiedPoints(t *testing.T) {
|
|
// unoccupiedPoints := getUniqOccupiedPoints(
|
|
// []*pb.Point{
|
|
// {X: 0, Y: 0},
|
|
// },
|
|
// []*pb.Snake{
|
|
// {
|
|
// Body: []*pb.Point{
|
|
// {X: 0, Y: 1},
|
|
// {X: 1, Y: 1},
|
|
// {X: 1, Y: 1},
|
|
// {X: 1, Y: 0},
|
|
// },
|
|
// },
|
|
// })
|
|
|
|
// require.Len(t, unoccupiedPoints, 4)
|
|
// }
|
|
|
|
// func TestGameTickUpdatesTurnCounter(t *testing.T) {
|
|
// gt, err := GameTick(commonGame, &pb.GameFrame{Turn: 5})
|
|
// require.NoError(t, err)
|
|
// require.Equal(t, int32(6), gt.Turn)
|
|
// }
|
|
|
|
// func TestGameTickUpdatesSnake(t *testing.T) {
|
|
// snake := &pb.Snake{
|
|
// Health: 67,
|
|
// Body: []*pb.Point{
|
|
// {X: 1, Y: 1},
|
|
// {X: 1, Y: 2},
|
|
// {X: 1, Y: 3},
|
|
// },
|
|
// }
|
|
// game := &pb.Game{
|
|
// Width: 20,
|
|
// Height: 20,
|
|
// }
|
|
// gt, err := GameTick(game, &pb.GameFrame{
|
|
// Turn: 5,
|
|
// Snakes: []*pb.Snake{
|
|
// snake,
|
|
// },
|
|
// })
|
|
// require.NoError(t, err)
|
|
// require.Len(t, gt.Snakes, 1)
|
|
// snake = gt.Snakes[0]
|
|
// require.Equal(t, int32(66), snake.Health)
|
|
// require.Len(t, snake.Body, 3)
|
|
// require.Equal(t, &pb.Point{X: 1, Y: 0}, snake.Body[0])
|
|
// require.Equal(t, &pb.Point{X: 1, Y: 1}, snake.Body[1])
|
|
// require.Equal(t, &pb.Point{X: 1, Y: 2}, snake.Body[2])
|
|
// }
|
|
|
|
// var commonGame = &pb.Game{
|
|
// Width: 20,
|
|
// Height: 20,
|
|
// }
|
|
// var lastFrame = &pb.GameFrame{
|
|
// Turn: 5,
|
|
// Snakes: []*pb.Snake{},
|
|
// Food: []*pb.Point{
|
|
// {X: 1, Y: 0},
|
|
// },
|
|
// }
|
|
|
|
// func TestGameTickDeadSnakeDoNotUpdate(t *testing.T) {
|
|
// snake := &pb.Snake{
|
|
// Health: 87,
|
|
// Body: []*pb.Point{
|
|
// {X: 1, Y: 1},
|
|
// {X: 1, Y: 2},
|
|
// {X: 1, Y: 3},
|
|
// },
|
|
// Death: &pb.Death{
|
|
// Turn: 4,
|
|
// Cause: DeathCauseSnakeCollision,
|
|
// },
|
|
// }
|
|
|
|
// lastFrame.Snakes = []*pb.Snake{snake}
|
|
|
|
// gt, err := GameTick(commonGame, lastFrame)
|
|
// require.NoError(t, err)
|
|
// require.Len(t, gt.Snakes, 1)
|
|
// snake = gt.Snakes[0]
|
|
// require.Equal(t, int32(87), snake.Health)
|
|
// require.Len(t, snake.Body, 3)
|
|
// require.Equal(t, &pb.Point{X: 1, Y: 1}, snake.Body[0])
|
|
// require.Equal(t, &pb.Point{X: 1, Y: 2}, snake.Body[1])
|
|
// require.Equal(t, &pb.Point{X: 1, Y: 3}, snake.Body[2])
|
|
// }
|
|
|
|
// func TestGameTickUpdatesDeath(t *testing.T) {
|
|
// snake := &pb.Snake{
|
|
// Health: 0,
|
|
// Body: []*pb.Point{
|
|
// {X: 3, Y: 1},
|
|
// {X: 3, Y: 2},
|
|
// {X: 3, Y: 3},
|
|
// },
|
|
// }
|
|
|
|
// lastFrame.Snakes = []*pb.Snake{snake}
|
|
|
|
// gt, err := GameTick(commonGame, lastFrame)
|
|
// require.NoError(t, err)
|
|
// require.NotNil(t, gt.Snakes[0].Death)
|
|
// }
|
|
|
|
// func TestUpdateSnakes(t *testing.T) {
|
|
// snake := &pb.Snake{
|
|
// Body: []*pb.Point{
|
|
// {X: 1, Y: 1},
|
|
// },
|
|
// }
|
|
// moves := []*SnakeUpdate{
|
|
// {
|
|
// Snake: snake,
|
|
// Err: errors.New("some error"),
|
|
// },
|
|
// }
|
|
// updateSnakes(&pb.Game{}, &pb.GameFrame{
|
|
// Snakes: []*pb.Snake{snake},
|
|
// }, moves)
|
|
// require.Equal(t, &pb.Point{X: 1, Y: 0}, snake.Head(), "snake did not move up")
|
|
|
|
// moves = []*SnakeUpdate{
|
|
// {
|
|
// Snake: snake,
|
|
// Move: "left",
|
|
// },
|
|
// }
|
|
// updateSnakes(&pb.Game{}, &pb.GameFrame{
|
|
// Snakes: []*pb.Snake{snake},
|
|
// }, moves)
|
|
// require.Equal(t, &pb.Point{X: 0, Y: 0}, snake.Head(), "snake did not move left")
|
|
// }
|
|
|
|
// func TestCanFollowTail(t *testing.T) {
|
|
// url := setupSnakeServer(t, MoveResponse{
|
|
// Move: "down",
|
|
// }, StartResponse{})
|
|
// snake := &pb.Snake{
|
|
// Body: []*pb.Point{
|
|
// {X: 2, Y: 1},
|
|
// {X: 1, Y: 1},
|
|
// {X: 1, Y: 2},
|
|
// {X: 2, Y: 2},
|
|
// },
|
|
// URL: url,
|
|
// Health: 100,
|
|
// }
|
|
// next, err := GameTick(&pb.Game{
|
|
// Width: 20,
|
|
// Height: 20,
|
|
// }, &pb.GameFrame{
|
|
// Snakes: []*pb.Snake{snake},
|
|
// })
|
|
// require.NoError(t, err)
|
|
// require.NotNil(t, next)
|
|
// require.Nil(t, next.Snakes[0].Death)
|
|
// }
|
|
|
|
// func TestNextFoodSpawn(t *testing.T) {
|
|
// rand.Seed(1) // random order is 65, 85, 29
|
|
// snakes := []*pb.Snake{
|
|
// {URL: setupSnakeServer(t, MoveResponse{}, StartResponse{})},
|
|
// {URL: setupSnakeServer(t, MoveResponse{}, StartResponse{})},
|
|
// {URL: setupSnakeServer(t, MoveResponse{}, StartResponse{})},
|
|
// {URL: setupSnakeServer(t, MoveResponse{}, StartResponse{})},
|
|
// }
|
|
// next, err := GameTick(&pb.Game{
|
|
// Width: 20,
|
|
// Height: 20,
|
|
// TurnsSinceLastFoodSpawn: 5,
|
|
// MaxTurnsToNextFoodSpawn: 5,
|
|
// }, &pb.GameFrame{
|
|
// Snakes: snakes,
|
|
// })
|
|
// require.NoError(t, err)
|
|
// require.Len(t, next.Food, 2)
|
|
// }
|