Battlesnake/Byte-snake-engine
Battlesnake/Byte-snake-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
Byte-snake-engine/standard_test.go
Torben d378759d58
DEV-1096 - add a new "pipeline" concept (#67) 
* add a new "pipeline" concept

- added new Pipeline type which is a series of stages
- added a global registry to facilitate plugin architecture
- 100% test coverage

* Refactor rulesets to provide and use Pipeline

* fix copypasta comments

* fix lint for unused method

* include game over stages in ruleset pipelines

* clean up unused private standard methods

* remove unused private methods in squad ruleset

* remove unused private methods in royale ruleset

* refactor: pipeline clone + return next board state

* YAGNI: remove unused Append

* refactor: improve stage names

* add no-op behavior to stages for initial state

* refactor: no-op decision within stage functions

* remove misleading comment that isn't true

* dont bother checking for init in gameover stages

* remove redundant test

* refactor: provide a combined ruleset/pipeline type

* fix: movement no-op for GameOver check

IsGameOver needs to run pipeline, move snakes needs to no-op for that

* add test coverage

* refactor: improve stage names and use constants

* add Error method

Support error checking before calling Execute()

* update naming to be American style

* panic when overwriting stages in global registry

* rename "Error" method and improve docs

* use testify lib for panic assertion

* remove redundant food stage

* use ruleset-specific logic for game over checks

* re-work Pipeline errors

* rework errors again

* add defensive check for zero length snake

* use old logic which checks current state, not next

* add warning about how PipelineRuleset checks for game over
2022-04-19 15:52:57 -07:00

1630 lines
39 KiB
Go
Raw Blame History

package rules
import (
"math"
"math/rand"
"testing"
"github.com/stretchr/testify/require"
)
func TestStandardRulesetInterface(t *testing.T) {
var _ Ruleset = (*StandardRuleset)(nil)
}
func TestSanity(t *testing.T) {
r := StandardRuleset{}
state, err := CreateDefaultBoardState(0, 0, []string{})
require.NoError(t, err)
require.NotNil(t, state)
state, err = r.ModifyInitialBoardState(state)
require.NoError(t, err)
require.NotNil(t, state)
require.Equal(t, int32(0), state.Width)
require.Equal(t, int32(0), state.Height)
require.Len(t, state.Food, 0)
require.Len(t, state.Snakes, 0)
next, err := r.CreateNextBoardState(
&BoardState{},
[]SnakeMove{},
)
require.NoError(t, err)
require.NotNil(t, next)
require.Equal(t, int32(0), state.Width)
require.Equal(t, int32(0), state.Height)
require.Len(t, state.Snakes, 0)
}
func TestStandardName(t *testing.T) {
r := StandardRuleset{}
require.Equal(t, "standard", r.Name())
}
// Checks that the error for a snake missing a move is returned
var standardCaseErrNoMoveFound = gameTestCase{
"Standard Case Error No Move Found",
&BoardState{
Width: 10,
Height: 10,
Snakes: []Snake{
{
ID: "one",
Body: []Point{{1, 1}, {1, 2}},
Health: 100,
},
{
ID: "two",
Body: []Point{{3, 4}, {3, 3}},
Health: 100,
},
},
Food: []Point{{0, 0}, {1, 0}},
Hazards: []Point{},
},
[]SnakeMove{
{ID: "one", Move: MoveUp},
},
ErrorNoMoveFound,
nil,
}
// Checks that the error for a snake with no points is returned
var standardCaseErrZeroLengthSnake = gameTestCase{
"Standard Case Error Zero Length Snake",
&BoardState{
Width: 10,
Height: 10,
Snakes: []Snake{
{
ID: "one",
Body: []Point{{1, 1}, {1, 2}},
Health: 100,
},
{
ID: "two",
Body: []Point{},
Health: 100,
},
},
Food: []Point{{0, 0}, {1, 0}},
Hazards: []Point{},
},
[]SnakeMove{
{ID: "one", Move: MoveUp},
{ID: "two", Move: MoveDown},
},
ErrorZeroLengthSnake,
nil,
}
// Checks a basic state where a snake moves, eats and grows
var standardCaseMoveEatAndGrow = gameTestCase{
"Standard Case Move Eat and Grow",
&BoardState{
Width: 10,
Height: 10,
Snakes: []Snake{
{
ID: "one",
Body: []Point{{1, 1}, {1, 2}},
Health: 100,
},
{
ID: "two",
Body: []Point{{3, 4}, {3, 3}},
Health: 100,
},
{
ID: "three",
Body: []Point{},
Health: 100,
EliminatedCause: EliminatedByOutOfBounds,
},
},
Food: []Point{{0, 0}, {1, 0}},
Hazards: []Point{},
},
[]SnakeMove{
{ID: "one", Move: MoveDown},
{ID: "two", Move: MoveUp},
{ID: "three", Move: MoveLeft}, // Should be ignored
},
nil,
&BoardState{
Width: 10,
Height: 10,
Snakes: []Snake{
{
ID: "one",
Body: []Point{{1, 0}, {1, 1}, {1, 1}},
Health: 100,
},
{
ID: "two",
Body: []Point{{3, 5}, {3, 4}},
Health: 99,
},
{
ID: "three",
Body: []Point{},
Health: 100,
EliminatedCause: EliminatedByOutOfBounds,
},
},
Food: []Point{{0, 0}},
Hazards: []Point{},
},
}
// Checks a basic state where two snakes of equal sizes collide, and both should
// be eliminated as a result.
var standardMoveAndCollideMAD = gameTestCase{
"Standard Case Move and Collide",
&BoardState{
Width: 10,
Height: 10,
Snakes: []Snake{
{
ID: "one",
Body: []Point{{1, 1}, {2, 1}},
Health: 99,
},
{
ID: "two",
Body: []Point{{1, 2}, {2, 2}},
Health: 99,
},
},
Food: []Point{},
Hazards: []Point{},
},
[]SnakeMove{
{ID: "one", Move: MoveUp},
{ID: "two", Move: MoveDown},
},
nil,
&BoardState{
Width: 10,
Height: 10,
Snakes: []Snake{
{
ID: "one",
Body: []Point{{1, 2}, {1, 1}},
Health: 98,
EliminatedCause: EliminatedByCollision,
EliminatedBy: "two",
},
{
ID: "two",
Body: []Point{{1, 1}, {1, 2}},
Health: 98,
EliminatedCause: EliminatedByCollision,
EliminatedBy: "one",
},
},
Food: []Point{},
Hazards: []Point{},
},
}
func TestStandardCreateNextBoardState(t *testing.T) {
cases := []gameTestCase{
standardCaseErrNoMoveFound,
standardCaseErrZeroLengthSnake,
standardCaseMoveEatAndGrow,
standardMoveAndCollideMAD,
}
r := StandardRuleset{}
rb := NewRulesetBuilder().WithParams(map[string]string{
ParamGameType: GameTypeStandard,
})
for _, gc := range cases {
gc.requireValidNextState(t, &r)
// also test a RulesBuilder constructed instance
gc.requireValidNextState(t, rb.Ruleset())
// also test a pipeline with the same settings
gc.requireValidNextState(t, NewRulesetBuilder().PipelineRuleset(GameTypeStandard, NewPipeline(standardRulesetStages...)))
}
}
func TestEatingOnLastMove(t *testing.T) {
// We want to specifically ensure that snakes eating food on their last turn
// survive. It used to be that this wasn't the case, and snakes were eliminated
// if they moved onto food with their final move. This behaviour wasn't "wrong" or incorrect,
// it just was less fun to watch. So let's ensure we're always giving snakes every possible
// changes to reach food before eliminating them.
tests := []struct {
prevState *BoardState
moves []SnakeMove
expectedError error
expectedState *BoardState
}{
{
&BoardState{
Width: 10,
Height: 10,
Snakes: []Snake{
{
ID: "one",
Body: []Point{{0, 2}, {0, 1}, {0, 0}},
Health: 1,
},
{
ID: "two",
Body: []Point{{3, 2}, {3, 3}, {3, 4}},
Health: 1,
},
},
Food: []Point{{0, 3}, {9, 9}},
},
[]SnakeMove{
{ID: "one", Move: MoveUp},
{ID: "two", Move: MoveDown},
},
nil,
&BoardState{
Width: 10,
Height: 10,
Snakes: []Snake{
{
ID: "one",
Body: []Point{{0, 3}, {0, 2}, {0, 1}, {0, 1}},
Health: 100,
},
{
ID: "two",
Body: []Point{{3, 1}, {3, 2}, {3, 3}},
Health: 0,
EliminatedCause: EliminatedByOutOfHealth,
},
},
Food: []Point{{9, 9}},
},
},
}
rand.Seed(0) // Seed with a value that will reliably not spawn food
r := StandardRuleset{}
for _, test := range tests {
nextState, err := r.CreateNextBoardState(test.prevState, test.moves)
require.Equal(t, err, test.expectedError)
if test.expectedState != nil {
require.Equal(t, test.expectedState.Width, nextState.Width)
require.Equal(t, test.expectedState.Height, nextState.Height)
require.Equal(t, test.expectedState.Food, nextState.Food)
require.Equal(t, test.expectedState.Snakes, nextState.Snakes)
}
}
}
func TestHeadToHeadOnFood(t *testing.T) {
// We want to specifically ensure that snakes that collide head-to-head
// on top of food successfully remove the food - that's the core behaviour this test
// is enforcing. There's a known side effect of this though, in that both snakes will
// have eaten prior to being evaluated on the head-to-head (+1 length, full health).
// We're okay with that since it does not impact the result of the head-to-head,
// however that behaviour could change in the future and this test could be updated.
tests := []struct {
prevState *BoardState
moves []SnakeMove
expectedError error
expectedState *BoardState
}{
{
&BoardState{
Width: 10,
Height: 10,
Snakes: []Snake{
{
ID: "one",
Body: []Point{{0, 2}, {0, 1}, {0, 0}},
Health: 10,
},
{
ID: "two",
Body: []Point{{0, 4}, {0, 5}, {0, 6}},
Health: 10,
},
},
Food: []Point{{0, 3}, {9, 9}},
},
[]SnakeMove{
{ID: "one", Move: MoveUp},
{ID: "two", Move: MoveDown},
},
nil,
&BoardState{
Width: 10,
Height: 10,
Snakes: []Snake{
{
ID: "one",
Body: []Point{{0, 3}, {0, 2}, {0, 1}, {0, 1}},
Health: 100,
EliminatedCause: EliminatedByHeadToHeadCollision,
EliminatedBy: "two",
},
{
ID: "two",
Body: []Point{{0, 3}, {0, 4}, {0, 5}, {0, 5}},
Health: 100,
EliminatedCause: EliminatedByHeadToHeadCollision,
EliminatedBy: "one",
},
},
Food: []Point{{9, 9}},
},
},
{
&BoardState{
Width: 10,
Height: 10,
Snakes: []Snake{
{
ID: "one",
Body: []Point{{0, 2}, {0, 1}, {0, 0}},
Health: 10,
},
{
ID: "two",
Body: []Point{{0, 4}, {0, 5}, {0, 6}, {0, 7}},
Health: 10,
},
},
Food: []Point{{0, 3}, {9, 9}},
},
[]SnakeMove{
{ID: "one", Move: MoveUp},
{ID: "two", Move: MoveDown},
},
nil,
&BoardState{
Width: 10,
Height: 10,
Snakes: []Snake{
{
ID: "one",
Body: []Point{{0, 3}, {0, 2}, {0, 1}, {0, 1}},
Health: 100,
EliminatedCause: EliminatedByHeadToHeadCollision,
EliminatedBy: "two",
},
{
ID: "two",
Body: []Point{{0, 3}, {0, 4}, {0, 5}, {0, 6}, {0, 6}},
Health: 100,
},
},
Food: []Point{{9, 9}},
},
},
}
rand.Seed(0) // Seed with a value that will reliably not spawn food
r := StandardRuleset{}
for _, test := range tests {
nextState, err := r.CreateNextBoardState(test.prevState, test.moves)
require.Equal(t, test.expectedError, err)
if test.expectedState != nil {
require.Equal(t, test.expectedState.Width, nextState.Width)
require.Equal(t, test.expectedState.Height, nextState.Height)
require.Equal(t, test.expectedState.Food, nextState.Food)
require.Equal(t, test.expectedState.Snakes, nextState.Snakes)
}
}
}
func TestRegressionIssue19(t *testing.T) {
// Eliminated snakes passed to CreateNextBoardState should not impact next game state
tests := []struct {
prevState *BoardState
moves []SnakeMove
expectedError error
expectedState *BoardState
}{
{
&BoardState{
Width: 10,
Height: 10,
Snakes: []Snake{
{
ID: "one",
Body: []Point{{0, 2}, {0, 1}, {0, 0}},
Health: 100,
},
{
ID: "two",
Body: []Point{{0, 5}, {0, 6}, {0, 7}},
Health: 100,
},
{
ID: "eliminated",
Body: []Point{{0, 0}, {0, 1}, {0, 2}, {0, 3}, {0, 4}, {0, 5}, {0, 6}},
Health: 0,
EliminatedCause: EliminatedByOutOfHealth,
},
},
Food: []Point{{9, 9}},
},
[]SnakeMove{
{ID: "one", Move: MoveUp},
{ID: "two", Move: MoveDown},
},
nil,
&BoardState{
Width: 10,
Height: 10,
Snakes: []Snake{
{
ID: "one",
Body: []Point{{0, 3}, {0, 2}, {0, 1}},
Health: 99,
},
{
ID: "two",
Body: []Point{{0, 4}, {0, 5}, {0, 6}},
Health: 99,
},
{
ID: "eliminated",
Body: []Point{{0, 0}, {0, 1}, {0, 2}, {0, 3}, {0, 4}, {0, 5}, {0, 6}},
Health: 0,
EliminatedCause: EliminatedByOutOfHealth,
},
},
Food: []Point{{9, 9}},
},
},
}
rand.Seed(0) // Seed with a value that will reliably not spawn food
r := StandardRuleset{}
for _, test := range tests {
nextState, err := r.CreateNextBoardState(test.prevState, test.moves)
require.Equal(t, err, test.expectedError)
if test.expectedState != nil {
require.Equal(t, test.expectedState.Width, nextState.Width)
require.Equal(t, test.expectedState.Height, nextState.Height)
require.Equal(t, test.expectedState.Food, nextState.Food)
require.Equal(t, test.expectedState.Snakes, nextState.Snakes)
}
}
}
func TestMoveSnakes(t *testing.T) {
b := &BoardState{
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,
},
{
ID: "three",
Body: []Point{{0, 0}},
Health: 1,
EliminatedCause: EliminatedByOutOfBounds,
},
},
}
tests := []struct {
MoveOne string
ExpectedOne []Point
MoveTwo string
ExpectedTwo []Point
MoveThree string
ExpectedThree []Point
}{
{
MoveDown, []Point{{10, 109}, {10, 110}},
MoveUp, []Point{{23, 221}, {23, 220}, {22, 220}, {21, 220}},
MoveDown, []Point{{0, 0}},
},
{
MoveRight, []Point{{11, 109}, {10, 109}},
MoveLeft, []Point{{22, 221}, {23, 221}, {23, 220}, {22, 220}},
MoveDown, []Point{{0, 0}},
},
{
MoveRight, []Point{{12, 109}, {11, 109}},
MoveLeft, []Point{{21, 221}, {22, 221}, {23, 221}, {23, 220}},
MoveDown, []Point{{0, 0}},
},
{
MoveRight, []Point{{13, 109}, {12, 109}},
MoveLeft, []Point{{20, 221}, {21, 221}, {22, 221}, {23, 221}},
MoveDown, []Point{{0, 0}},
},
{
MoveDown, []Point{{13, 108}, {13, 109}},
MoveUp, []Point{{20, 222}, {20, 221}, {21, 221}, {22, 221}},
MoveDown, []Point{{0, 0}},
},
}
r := StandardRuleset{}
for _, test := range tests {
moves := []SnakeMove{
{ID: "one", Move: test.MoveOne},
{ID: "two", Move: test.MoveTwo},
{ID: "three", Move: test.MoveThree},
}
_, err := MoveSnakesStandard(b, r.Settings(), moves)
require.NoError(t, err)
require.Len(t, b.Snakes, 3)
require.Equal(t, int32(111111), b.Snakes[0].Health)
require.Equal(t, int32(222222), b.Snakes[1].Health)
require.Equal(t, int32(1), b.Snakes[2].Health)
require.Len(t, b.Snakes[0].Body, 2)
require.Len(t, b.Snakes[1].Body, 4)
require.Len(t, b.Snakes[2].Body, 1)
require.Equal(t, len(b.Snakes[0].Body), len(test.ExpectedOne))
for i, e := range test.ExpectedOne {
require.Equal(t, e, b.Snakes[0].Body[i])
}
require.Equal(t, len(b.Snakes[1].Body), len(test.ExpectedTwo))
for i, e := range test.ExpectedTwo {
require.Equal(t, e, b.Snakes[1].Body[i])
}
require.Equal(t, len(b.Snakes[2].Body), len(test.ExpectedThree))
for i, e := range test.ExpectedThree {
require.Equal(t, e, b.Snakes[2].Body[i])
}
}
}
func TestMoveSnakesWrongID(t *testing.T) {
b := &BoardState{
Snakes: []Snake{
{
ID: "one",
Body: []Point{{1, 1}},
},
},
}
moves := []SnakeMove{
{
ID: "not found",
Move: MoveUp,
},
}
r := StandardRuleset{}
_, err := MoveSnakesStandard(b, r.Settings(), moves)
require.Equal(t, ErrorNoMoveFound, err)
}
func TestMoveSnakesNotEnoughMoves(t *testing.T) {
b := &BoardState{
Snakes: []Snake{
{
ID: "one",
Body: []Point{{1, 1}},
},
{
ID: "two",
Body: []Point{{2, 2}},
},
},
}
moves := []SnakeMove{
{
ID: "two",
Move: MoveUp,
},
}
r := StandardRuleset{}
_, err := MoveSnakesStandard(b, r.Settings(), moves)
require.Equal(t, ErrorNoMoveFound, err)
}
func TestMoveSnakesExtraMovesIgnored(t *testing.T) {
b := &BoardState{
Snakes: []Snake{
{
ID: "one",
Body: []Point{{1, 1}},
},
},
}
moves := []SnakeMove{
{
ID: "one",
Move: MoveDown,
},
{
ID: "two",
Move: MoveLeft,
},
}
r := StandardRuleset{}
_, err := MoveSnakesStandard(b, r.Settings(), moves)
require.NoError(t, err)
require.Equal(t, []Point{{1, 0}}, b.Snakes[0].Body)
}
func TestMoveSnakesDefault(t *testing.T) {
tests := []struct {
Body []Point
Move string
Expected []Point
}{
{
Body: []Point{{0, 0}},
Move: "invalid",
Expected: []Point{{0, 1}},
},
{
Body: []Point{{5, 5}, {5, 5}},
Move: "",
Expected: []Point{{5, 6}, {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 {
b := &BoardState{
Snakes: []Snake{
{ID: "one", Body: test.Body},
},
}
moves := []SnakeMove{{ID: "one", Move: test.Move}}
_, err := MoveSnakesStandard(b, r.Settings(), moves)
require.NoError(t, err)
require.Len(t, b.Snakes, 1)
require.Equal(t, len(test.Body), len(b.Snakes[0].Body))
require.Equal(t, len(test.Expected), len(b.Snakes[0].Body))
for i, e := range test.Expected {
require.Equal(t, e, b.Snakes[0].Body[i])
}
}
}
func TestGetDefaultMove(t *testing.T) {
tests := []struct {
SnakeBody []Point
ExpectedMove string
}{
// Default is always up
{
SnakeBody: []Point{},
ExpectedMove: MoveUp,
},
{
SnakeBody: []Point{{0, 0}},
ExpectedMove: MoveUp,
},
{
SnakeBody: []Point{{-1, -1}},
ExpectedMove: MoveUp,
},
// Stacked (fallback to default)
{
SnakeBody: []Point{{2, 2}, {2, 2}},
ExpectedMove: MoveUp,
},
// Neck next to head
{
SnakeBody: []Point{{2, 2}, {2, 1}},
ExpectedMove: MoveUp,
},
{
SnakeBody: []Point{{2, 2}, {2, 3}},
ExpectedMove: MoveDown,
},
{
SnakeBody: []Point{{2, 2}, {1, 2}},
ExpectedMove: MoveRight,
},
{
SnakeBody: []Point{{2, 2}, {3, 2}},
ExpectedMove: MoveLeft,
},
// Board wrap cases
{
SnakeBody: []Point{{0, 0}, {0, 2}},
ExpectedMove: MoveUp,
},
{
SnakeBody: []Point{{0, 0}, {2, 0}},
ExpectedMove: MoveRight,
},
{
SnakeBody: []Point{{0, 2}, {0, 0}},
ExpectedMove: MoveDown,
},
{
SnakeBody: []Point{{2, 0}, {0, 0}},
ExpectedMove: MoveLeft,
},
}
for _, test := range tests {
actualMove := getDefaultMove(test.SnakeBody)
require.Equal(t, test.ExpectedMove, actualMove)
}
}
func TestReduceSnakeHealth(t *testing.T) {
b := &BoardState{
Snakes: []Snake{
{
Body: []Point{{0, 0}, {0, 1}},
Health: 99,
},
{
Body: []Point{{5, 8}, {6, 8}, {7, 8}},
Health: 2,
},
{
Body: []Point{{0, 0}, {0, 1}},
Health: 50,
EliminatedCause: EliminatedByCollision,
},
},
}
r := StandardRuleset{}
_, err := ReduceSnakeHealthStandard(b, r.Settings(), mockSnakeMoves())
require.NoError(t, err)
require.Equal(t, b.Snakes[0].Health, int32(98))
require.Equal(t, b.Snakes[1].Health, int32(1))
require.Equal(t, b.Snakes[2].Health, int32(50))
_, err = ReduceSnakeHealthStandard(b, r.Settings(), mockSnakeMoves())
require.NoError(t, err)
require.Equal(t, b.Snakes[0].Health, int32(97))
require.Equal(t, b.Snakes[1].Health, int32(0))
require.Equal(t, b.Snakes[2].Health, int32(50))
_, err = ReduceSnakeHealthStandard(b, r.Settings(), mockSnakeMoves())
require.NoError(t, err)
require.Equal(t, b.Snakes[0].Health, int32(96))
require.Equal(t, b.Snakes[1].Health, int32(-1))
require.Equal(t, b.Snakes[2].Health, int32(50))
_, err = ReduceSnakeHealthStandard(b, r.Settings(), mockSnakeMoves())
require.NoError(t, err)
require.Equal(t, b.Snakes[0].Health, int32(95))
require.Equal(t, b.Snakes[1].Health, int32(-2))
require.Equal(t, b.Snakes[2].Health, int32(50))
}
func TestSnakeIsOutOfHealth(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},
}
for _, test := range tests {
s := &Snake{Health: test.Health}
require.Equal(t, test.Expected, snakeIsOutOfHealth(s), "Health: %+v", test.Health)
}
}
func TestSnakeIsOutOfBounds(t *testing.T) {
boardWidth := int32(10)
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},
}
for _, test := range tests {
// Test with point as head
s := Snake{Body: []Point{test.Point}}
require.Equal(t, test.Expected, snakeIsOutOfBounds(&s, boardWidth, boardHeight), "Head%+v", test.Point)
// Test with point as body
s = Snake{Body: []Point{{0, 0}, {0, 0}, test.Point}}
require.Equal(t, test.Expected, 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},
}
for _, test := range tests {
s := Snake{Body: test.Body}
require.Equal(t, test.Expected, 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,
},
}
for _, test := range tests {
s := &Snake{Body: test.SnakeBody}
o := &Snake{Body: test.OtherBody}
require.Equal(t, test.Expected, 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,
},
}
for _, test := range tests {
s := Snake{Body: test.SnakeBody}
o := Snake{Body: test.OtherBody}
require.Equal(t, test.Expected, snakeHasLostHeadToHead(&s, &o), "Snake%q Other%q", s.Body, o.Body)
require.Equal(t, test.ExpectedOpposite, snakeHasLostHeadToHead(&o, &s), "Snake%q Other%q", s.Body, o.Body)
}
}
func TestMaybeEliminateSnakes(t *testing.T) {
tests := []struct {
Name string
Snakes []Snake
ExpectedEliminatedCauses []string
ExpectedEliminatedBy []string
Err error
}{
{
"Empty",
[]Snake{},
[]string{},
[]string{},
nil,
},
{
"Zero Snake",
[]Snake{
{},
},
[]string{NotEliminated},
[]string{""},
ErrorZeroLengthSnake,
},
{
"Single Starvation",
[]Snake{
{ID: "1", Body: []Point{{1, 1}}},
},
[]string{EliminatedByOutOfHealth},
[]string{""},
nil,
},
{
"Not Eliminated",
[]Snake{
{ID: "1", Health: 1, Body: []Point{{1, 1}}},
},
[]string{NotEliminated},
[]string{""},
nil,
},
{
"Out of Bounds",
[]Snake{
{ID: "1", Health: 1, Body: []Point{{-1, 1}}},
},
[]string{EliminatedByOutOfBounds},
[]string{""},
nil,
},
{
"Self Collision",
[]Snake{
{ID: "1", Health: 1, Body: []Point{{0, 0}, {0, 1}, {0, 0}}},
},
[]string{EliminatedBySelfCollision},
[]string{"1"},
nil,
},
{
"Multiple Separate Deaths",
[]Snake{
{ID: "1", Health: 1, Body: []Point{{0, 0}, {0, 1}, {0, 0}}},
{ID: "2", Health: 1, Body: []Point{{-1, 1}}},
},
[]string{
EliminatedBySelfCollision,
EliminatedByOutOfBounds},
[]string{"1", ""},
nil,
},
{
"Other Collision",
[]Snake{
{ID: "1", Health: 1, Body: []Point{{0, 2}, {0, 3}, {0, 4}}},
{ID: "2", Health: 1, Body: []Point{{0, 0}, {0, 1}, {0, 2}}},
},
[]string{
EliminatedByCollision,
NotEliminated},
[]string{"2", ""},
nil,
},
{
"All Eliminated Head 2 Head",
[]Snake{
{ID: "1", Health: 1, Body: []Point{{1, 1}}},
{ID: "2", Health: 1, Body: []Point{{1, 1}}},
{ID: "3", Health: 1, Body: []Point{{1, 1}}},
},
[]string{
EliminatedByHeadToHeadCollision,
EliminatedByHeadToHeadCollision,
EliminatedByHeadToHeadCollision,
},
[]string{"2", "1", "1"},
nil,
},
{
"One Snake wins Head 2 Head",
[]Snake{
{ID: "1", Health: 1, Body: []Point{{1, 1}, {0, 1}}},
{ID: "2", Health: 1, Body: []Point{{1, 1}, {1, 2}, {1, 3}}},
{ID: "3", Health: 1, Body: []Point{{1, 1}}},
},
[]string{
EliminatedByHeadToHeadCollision,
NotEliminated,
EliminatedByHeadToHeadCollision,
},
[]string{"2", "", "2"},
nil,
},
{
"All Snakes Body Eliminated",
[]Snake{
{ID: "1", Health: 1, Body: []Point{{4, 4}, {3, 3}}},
{ID: "2", Health: 1, Body: []Point{{3, 3}, {2, 2}}},
{ID: "3", Health: 1, Body: []Point{{2, 2}, {1, 1}}},
{ID: "4", Health: 1, Body: []Point{{1, 1}, {4, 4}}},
{ID: "5", Health: 1, Body: []Point{{4, 4}}}, // Body collision takes priority
},
[]string{
EliminatedByCollision,
EliminatedByCollision,
EliminatedByCollision,
EliminatedByCollision,
EliminatedByCollision,
},
[]string{"4", "1", "2", "3", "4"},
nil,
},
{
"All Snakes Eliminated Head 2 Head",
[]Snake{
{ID: "1", Health: 1, Body: []Point{{4, 4}, {4, 5}}},
{ID: "2", Health: 1, Body: []Point{{4, 4}, {4, 3}}},
{ID: "3", Health: 1, Body: []Point{{4, 4}, {5, 4}}},
{ID: "4", Health: 1, Body: []Point{{4, 4}, {3, 4}}},
},
[]string{
EliminatedByHeadToHeadCollision,
EliminatedByHeadToHeadCollision,
EliminatedByHeadToHeadCollision,
EliminatedByHeadToHeadCollision,
},
[]string{"2", "1", "1", "1"},
nil,
},
{
"4 Snakes Head 2 Head",
[]Snake{
{ID: "1", Health: 1, Body: []Point{{4, 4}, {4, 5}}},
{ID: "2", Health: 1, Body: []Point{{4, 4}, {4, 3}}},
{ID: "3", Health: 1, Body: []Point{{4, 4}, {5, 4}, {6, 4}}},
{ID: "4", Health: 1, Body: []Point{{4, 4}, {3, 4}}},
},
[]string{
EliminatedByHeadToHeadCollision,
EliminatedByHeadToHeadCollision,
NotEliminated,
EliminatedByHeadToHeadCollision,
},
[]string{"3", "3", "", "3"},
nil,
},
}
r := StandardRuleset{}
for _, test := range tests {
t.Run(test.Name, func(t *testing.T) {
b := &BoardState{
Width: 10,
Height: 10,
Snakes: test.Snakes,
}
_, err := EliminateSnakesStandard(b, r.Settings(), mockSnakeMoves())
require.Equal(t, test.Err, err)
for i, snake := range b.Snakes {
require.Equal(t, test.ExpectedEliminatedCauses[i], snake.EliminatedCause)
require.Equal(t, test.ExpectedEliminatedBy[i], snake.EliminatedBy)
}
})
}
}
func TestMaybeEliminateSnakesPriority(t *testing.T) {
tests := []struct {
Snakes []Snake
ExpectedEliminatedCauses []string
ExpectedEliminatedBy []string
}{
{
[]Snake{
{ID: "1", Health: 0, Body: []Point{{-1, 0}, {0, 0}, {1, 0}}},
{ID: "2", Health: 1, Body: []Point{{-1, 0}, {0, 0}, {1, 0}}},
{ID: "3", Health: 1, Body: []Point{{1, 0}, {0, 0}, {1, 0}}},
{ID: "4", Health: 1, Body: []Point{{1, 0}, {1, 1}, {1, 2}}},
{ID: "5", Health: 1, Body: []Point{{2, 2}, {2, 1}, {2, 0}}},
{ID: "6", Health: 1, Body: []Point{{2, 2}, {2, 3}, {2, 4}, {2, 5}}},
},
[]string{
EliminatedByOutOfHealth,
EliminatedByOutOfBounds,
EliminatedBySelfCollision,
EliminatedByCollision,
EliminatedByHeadToHeadCollision,
NotEliminated,
},
[]string{"", "", "3", "3", "6", ""},
},
}
r := StandardRuleset{}
for _, test := range tests {
b := &BoardState{Width: 10, Height: 10, Snakes: test.Snakes}
_, err := EliminateSnakesStandard(b, r.Settings(), mockSnakeMoves())
require.NoError(t, err)
for i, snake := range b.Snakes {
require.Equal(t, test.ExpectedEliminatedCauses[i], snake.EliminatedCause, snake.ID)
require.Equal(t, test.ExpectedEliminatedBy[i], snake.EliminatedBy, snake.ID)
}
}
}
func TestMaybeDamageHazards(t *testing.T) {
tests := []struct {
Snakes []Snake
Hazards []Point
Food []Point
ExpectedEliminatedCauses []string
ExpectedEliminatedByIDs []string
}{
{},
{
Snakes: []Snake{{Body: []Point{{0, 0}}}},
Hazards: []Point{},
ExpectedEliminatedCauses: []string{NotEliminated},
ExpectedEliminatedByIDs: []string{""},
},
{
Snakes: []Snake{{Body: []Point{{0, 0}}}},
Hazards: []Point{{0, 0}},
ExpectedEliminatedCauses: []string{EliminatedByOutOfHealth},
ExpectedEliminatedByIDs: []string{""},
},
{
Snakes: []Snake{{Body: []Point{{0, 0}}}},
Hazards: []Point{{0, 0}},
Food: []Point{{0, 0}},
ExpectedEliminatedCauses: []string{NotEliminated},
ExpectedEliminatedByIDs: []string{""},
},
{
Snakes: []Snake{{Body: []Point{{0, 0}, {1, 0}, {2, 0}}}},
Hazards: []Point{{1, 0}, {2, 0}},
ExpectedEliminatedCauses: []string{NotEliminated},
ExpectedEliminatedByIDs: []string{""},
},
{
Snakes: []Snake{
{Body: []Point{{0, 0}, {1, 0}, {2, 0}}},
{Body: []Point{{3, 3}, {3, 4}, {3, 5}, {3, 6}}},
},
Hazards: []Point{{1, 0}, {2, 0}, {3, 4}, {3, 5}, {3, 6}},
ExpectedEliminatedCauses: []string{NotEliminated, NotEliminated},
ExpectedEliminatedByIDs: []string{"", ""},
},
{
Snakes: []Snake{
{Body: []Point{{0, 0}, {1, 0}, {2, 0}}},
{Body: []Point{{3, 3}, {3, 4}, {3, 5}, {3, 6}}},
},
Hazards: []Point{{3, 3}},
ExpectedEliminatedCauses: []string{NotEliminated, EliminatedByOutOfHealth},
ExpectedEliminatedByIDs: []string{"", ""},
},
}
for _, test := range tests {
b := &BoardState{Snakes: test.Snakes, Hazards: test.Hazards, Food: test.Food}
r := StandardRuleset{HazardDamagePerTurn: 100}
_, err := DamageHazardsStandard(b, r.Settings(), mockSnakeMoves())
require.NoError(t, err)
for i, snake := range b.Snakes {
require.Equal(t, test.ExpectedEliminatedCauses[i], snake.EliminatedCause)
}
}
}
func TestHazardDamagePerTurn(t *testing.T) {
tests := []struct {
Health int32
HazardDamagePerTurn int32
Food bool
ExpectedHealth int32
ExpectedEliminationCause string
Error error
}{
{100, 1, false, 99, NotEliminated, nil},
{100, 1, true, 100, NotEliminated, nil},
{100, 99, false, 1, NotEliminated, nil},
{100, 99, true, 100, NotEliminated, nil},
{100, 100, false, 0, EliminatedByOutOfHealth, nil},
{100, 101, false, 0, EliminatedByOutOfHealth, nil},
{100, 999, false, 0, EliminatedByOutOfHealth, nil},
{100, 100, true, 100, NotEliminated, nil},
{2, 1, false, 1, NotEliminated, nil},
{1, 1, false, 0, EliminatedByOutOfHealth, nil},
{1, 999, false, 0, EliminatedByOutOfHealth, nil},
{0, 1, false, 0, EliminatedByOutOfHealth, nil},
{0, 999, false, 0, EliminatedByOutOfHealth, nil},
}
for _, test := range tests {
b := &BoardState{Snakes: []Snake{{Health: test.Health, Body: []Point{{0, 0}}}}, Hazards: []Point{{0, 0}}}
if test.Food {
b.Food = []Point{{0, 0}}
}
r := StandardRuleset{HazardDamagePerTurn: test.HazardDamagePerTurn}
_, err := DamageHazardsStandard(b, r.Settings(), mockSnakeMoves())
require.Equal(t, test.Error, err)
require.Equal(t, test.ExpectedHealth, b.Snakes[0].Health)
require.Equal(t, test.ExpectedEliminationCause, b.Snakes[0].EliminatedCause)
}
}
func TestMaybeFeedSnakes(t *testing.T) {
tests := []struct {
Name string
Snakes []Snake
Food []Point
ExpectedSnakes []Snake
ExpectedFood []Point
}{
{
Name: "snake not on food",
Snakes: []Snake{
{Health: 5, Body: []Point{{0, 0}, {0, 1}, {0, 2}}},
},
Food: []Point{{3, 3}},
ExpectedSnakes: []Snake{
{Health: 5, Body: []Point{{0, 0}, {0, 1}, {0, 2}}},
},
ExpectedFood: []Point{{3, 3}},
},
{
Name: "snake on food",
Snakes: []Snake{
{Health: SnakeMaxHealth - 1, Body: []Point{{2, 1}, {1, 1}, {1, 2}, {2, 2}}},
},
Food: []Point{{2, 1}},
ExpectedSnakes: []Snake{
{Health: SnakeMaxHealth, Body: []Point{{2, 1}, {1, 1}, {1, 2}, {2, 2}, {2, 2}}},
},
ExpectedFood: []Point{},
},
{
Name: "food under body",
Snakes: []Snake{
{Body: []Point{{0, 0}, {0, 1}, {0, 2}}},
},
Food: []Point{{0, 1}},
ExpectedSnakes: []Snake{
{Body: []Point{{0, 0}, {0, 1}, {0, 2}}},
},
ExpectedFood: []Point{{0, 1}},
},
{
Name: "snake on food but already eliminated",
Snakes: []Snake{
{Body: []Point{{0, 0}, {0, 1}, {0, 2}}, EliminatedCause: "EliminatedByOutOfBounds"},
},
Food: []Point{{0, 0}},
ExpectedSnakes: []Snake{
{Body: []Point{{0, 0}, {0, 1}, {0, 2}}},
},
ExpectedFood: []Point{{0, 0}},
},
{
Name: "multiple snakes on same food",
Snakes: []Snake{
{Health: SnakeMaxHealth, Body: []Point{{0, 0}, {0, 1}, {0, 2}}},
{Health: SnakeMaxHealth - 9, Body: []Point{{0, 0}, {1, 0}, {2, 0}}},
},
Food: []Point{{0, 0}, {4, 4}},
ExpectedSnakes: []Snake{
{Health: SnakeMaxHealth, Body: []Point{{0, 0}, {0, 1}, {0, 2}, {0, 2}}},
{Health: SnakeMaxHealth, Body: []Point{{0, 0}, {1, 0}, {2, 0}, {2, 0}}},
},
ExpectedFood: []Point{{4, 4}},
},
}
r := StandardRuleset{}
for _, test := range tests {
b := &BoardState{
Snakes: test.Snakes,
Food: test.Food,
}
_, err := FeedSnakesStandard(b, r.Settings(), nil)
require.NoError(t, err, test.Name)
require.Equal(t, len(test.ExpectedSnakes), len(b.Snakes), test.Name)
for i := 0; i < len(b.Snakes); i++ {
require.Equal(t, test.ExpectedSnakes[i].Health, b.Snakes[i].Health, test.Name)
require.Equal(t, test.ExpectedSnakes[i].Body, b.Snakes[i].Body, test.Name)
}
require.Equal(t, test.ExpectedFood, b.Food, test.Name)
}
}
func TestMaybeSpawnFoodMinimum(t *testing.T) {
tests := []struct {
MinimumFood int32
Food []Point
ExpectedFood int
}{
// Use pre-tested seeds and results
{0, []Point{}, 0},
{1, []Point{}, 1},
{9, []Point{}, 9},
{7, []Point{{4, 5}, {4, 4}, {4, 1}}, 7},
}
for _, test := range tests {
r := StandardRuleset{MinimumFood: test.MinimumFood}
b := &BoardState{
Height: 11,
Width: 11,
Snakes: []Snake{
{Body: []Point{{1, 0}, {1, 1}}},
{Body: []Point{{0, 1}, {0, 2}, {0, 3}}},
},
Food: test.Food,
}
_, err := SpawnFoodStandard(b, r.Settings(), mockSnakeMoves())
require.NoError(t, err)
require.Equal(t, test.ExpectedFood, len(b.Food))
}
}
func TestMaybeSpawnFoodZeroChance(t *testing.T) {
r := StandardRuleset{FoodSpawnChance: 0}
b := &BoardState{
Height: 11,
Width: 11,
Snakes: []Snake{
{Body: []Point{{1, 0}, {1, 1}}},
{Body: []Point{{0, 1}, {0, 2}, {0, 3}}},
},
Food: []Point{},
}
for i := 0; i < 1000; i++ {
_, err := SpawnFoodStandard(b, r.Settings(), nil)
require.NoError(t, err)
require.Equal(t, len(b.Food), 0)
}
}
func TestMaybeSpawnFoodHundredChance(t *testing.T) {
r := StandardRuleset{FoodSpawnChance: 100}
b := &BoardState{
Height: 11,
Width: 11,
Snakes: []Snake{
{Body: []Point{{1, 0}, {1, 1}}},
{Body: []Point{{0, 1}, {0, 2}, {0, 3}}},
},
Food: []Point{},
}
for i := 1; i <= 22; i++ {
_, err := SpawnFoodStandard(b, r.Settings(), mockSnakeMoves())
require.NoError(t, err)
require.Equal(t, i, len(b.Food))
}
}
func TestMaybeSpawnFoodHalfChance(t *testing.T) {
tests := []struct {
Seed int64
Food []Point
ExpectedFood int32
}{
// Use pre-tested seeds and results
{123, []Point{}, 1},
{12345, []Point{}, 0},
{456, []Point{{4, 4}}, 1},
{789, []Point{{4, 4}}, 2},
{511, []Point{{4, 4}}, 1},
{165, []Point{{4, 4}}, 2},
}
r := StandardRuleset{FoodSpawnChance: 50}
for _, test := range tests {
b := &BoardState{
Height: 4,
Width: 5,
Snakes: []Snake{
{Body: []Point{{1, 0}, {1, 1}}},
{Body: []Point{{0, 1}, {0, 2}, {0, 3}}},
},
Food: test.Food,
}
rand.Seed(test.Seed)
_, err := SpawnFoodStandard(b, r.Settings(), mockSnakeMoves())
require.NoError(t, err)
require.Equal(t, test.ExpectedFood, int32(len(b.Food)), "Seed %d", test.Seed)
}
}
func TestIsGameOver(t *testing.T) {
tests := []struct {
Snakes []Snake
Expected bool
}{
{[]Snake{}, true},
{[]Snake{{}}, true},
{[]Snake{{}, {}}, false},
{[]Snake{{}, {}, {}, {}, {}}, false},
{
[]Snake{
{EliminatedCause: EliminatedByCollision},
{EliminatedCause: NotEliminated},
},
true,
},
{
[]Snake{
{EliminatedCause: NotEliminated},
{EliminatedCause: EliminatedByCollision},
{EliminatedCause: NotEliminated},
{EliminatedCause: NotEliminated},
},
false,
},
{
[]Snake{
{EliminatedCause: EliminatedByOutOfBounds},
{EliminatedCause: EliminatedByOutOfBounds},
{EliminatedCause: EliminatedByOutOfBounds},
{EliminatedCause: EliminatedByOutOfBounds},
},
true,
},
{
[]Snake{
{EliminatedCause: EliminatedByOutOfBounds},
{EliminatedCause: EliminatedByOutOfBounds},
{EliminatedCause: EliminatedByOutOfBounds},
{EliminatedCause: NotEliminated},
},
true,
},
{
[]Snake{
{EliminatedCause: EliminatedByOutOfBounds},
{EliminatedCause: EliminatedByOutOfBounds},
{EliminatedCause: NotEliminated},
{EliminatedCause: NotEliminated},
},
false,
},
}
r := StandardRuleset{}
for _, test := range tests {
b := &BoardState{
Height: 11,
Width: 11,
Snakes: test.Snakes,
Food: []Point{},
}
actual, err := r.IsGameOver(b)
require.NoError(t, err)
require.Equal(t, test.Expected, actual)
}
}
Reference in a new issue View git blame Copy permalink