d378759d58
* 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
118 lines
2.5 KiB
Go
118 lines
2.5 KiB
Go
package rules
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestSoloRulesetInterface(t *testing.T) {
|
|
var _ Ruleset = (*SoloRuleset)(nil)
|
|
}
|
|
|
|
func TestSoloName(t *testing.T) {
|
|
r := SoloRuleset{}
|
|
require.Equal(t, "solo", r.Name())
|
|
}
|
|
|
|
func TestSoloCreateNextBoardStateSanity(t *testing.T) {
|
|
boardState := &BoardState{}
|
|
r := SoloRuleset{}
|
|
_, err := r.CreateNextBoardState(boardState, []SnakeMove{})
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
func TestSoloIsGameOver(t *testing.T) {
|
|
tests := []struct {
|
|
Snakes []Snake
|
|
Expected bool
|
|
}{
|
|
{[]Snake{}, true},
|
|
{[]Snake{{}}, false},
|
|
{[]Snake{{}, {}, {}}, false},
|
|
{[]Snake{{EliminatedCause: EliminatedByOutOfBounds}}, true},
|
|
{
|
|
[]Snake{
|
|
{EliminatedCause: EliminatedByOutOfBounds},
|
|
{EliminatedCause: EliminatedByOutOfBounds},
|
|
{EliminatedCause: EliminatedByOutOfBounds},
|
|
},
|
|
true,
|
|
},
|
|
}
|
|
|
|
r := SoloRuleset{}
|
|
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)
|
|
}
|
|
}
|
|
|
|
// Checks that a single snake doesn't end the game
|
|
// also that:
|
|
// - snake moves okay
|
|
// - food gets consumed
|
|
// - snake grows and gets health from food
|
|
var soloCaseNotOver = gameTestCase{
|
|
"Solo Case Game Not Over",
|
|
&BoardState{
|
|
Width: 10,
|
|
Height: 10,
|
|
Snakes: []Snake{
|
|
{
|
|
ID: "one",
|
|
Body: []Point{{1, 1}, {1, 2}},
|
|
Health: 100,
|
|
},
|
|
},
|
|
Food: []Point{{0, 0}, {1, 0}},
|
|
Hazards: []Point{},
|
|
},
|
|
[]SnakeMove{
|
|
{ID: "one", Move: MoveDown},
|
|
},
|
|
nil,
|
|
&BoardState{
|
|
Width: 10,
|
|
Height: 10,
|
|
Snakes: []Snake{
|
|
{
|
|
ID: "one",
|
|
Body: []Point{{1, 0}, {1, 1}, {1, 1}},
|
|
Health: 100,
|
|
},
|
|
},
|
|
Food: []Point{{0, 0}},
|
|
Hazards: []Point{},
|
|
},
|
|
}
|
|
|
|
func TestSoloCreateNextBoardState(t *testing.T) {
|
|
cases := []gameTestCase{
|
|
// inherits these test cases from standard
|
|
standardCaseErrNoMoveFound,
|
|
standardCaseErrZeroLengthSnake,
|
|
standardCaseMoveEatAndGrow,
|
|
standardMoveAndCollideMAD,
|
|
soloCaseNotOver,
|
|
}
|
|
r := SoloRuleset{}
|
|
rb := NewRulesetBuilder().WithParams(map[string]string{
|
|
ParamGameType: GameTypeSolo,
|
|
})
|
|
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(GameTypeSolo, NewPipeline(soloRulesetStages...)))
|
|
}
|
|
}
|