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
98 lines
2.3 KiB
Go
98 lines
2.3 KiB
Go
package rules
|
|
|
|
import (
|
|
"errors"
|
|
"math/rand"
|
|
)
|
|
|
|
var royaleRulesetStages = []string{
|
|
StageMovementStandard,
|
|
StageStarvationStandard,
|
|
StageHazardDamageStandard,
|
|
StageFeedSnakesStandard,
|
|
StageSpawnFoodStandard,
|
|
StageEliminationStandard,
|
|
StageSpawnHazardsShrinkMap,
|
|
StageGameOverStandard,
|
|
}
|
|
|
|
type RoyaleRuleset struct {
|
|
StandardRuleset
|
|
|
|
Seed int64
|
|
|
|
ShrinkEveryNTurns int32
|
|
}
|
|
|
|
func (r *RoyaleRuleset) Name() string { return GameTypeRoyale }
|
|
|
|
func (r RoyaleRuleset) Execute(bs *BoardState, s Settings, sm []SnakeMove) (bool, *BoardState, error) {
|
|
return NewPipeline(royaleRulesetStages...).Execute(bs, s, sm)
|
|
}
|
|
|
|
func (r *RoyaleRuleset) CreateNextBoardState(prevState *BoardState, moves []SnakeMove) (*BoardState, error) {
|
|
if r.StandardRuleset.HazardDamagePerTurn < 1 {
|
|
return nil, errors.New("royale damage per turn must be greater than zero")
|
|
}
|
|
_, nextState, err := r.Execute(prevState, r.Settings(), moves)
|
|
return nextState, err
|
|
}
|
|
|
|
func PopulateHazardsRoyale(b *BoardState, settings Settings, moves []SnakeMove) (bool, error) {
|
|
if IsInitialization(b, settings, moves) {
|
|
return false, nil
|
|
}
|
|
b.Hazards = []Point{}
|
|
|
|
// Royale uses the current turn to generate hazards, not the previous turn that's in the board state
|
|
turn := b.Turn + 1
|
|
|
|
if settings.RoyaleSettings.ShrinkEveryNTurns < 1 {
|
|
return false, errors.New("royale game can't shrink more frequently than every turn")
|
|
}
|
|
|
|
if turn < settings.RoyaleSettings.ShrinkEveryNTurns {
|
|
return false, nil
|
|
}
|
|
|
|
randGenerator := rand.New(rand.NewSource(settings.RoyaleSettings.seed))
|
|
|
|
numShrinks := turn / settings.RoyaleSettings.ShrinkEveryNTurns
|
|
minX, maxX := int32(0), b.Width-1
|
|
minY, maxY := int32(0), b.Height-1
|
|
for i := int32(0); i < numShrinks; i++ {
|
|
switch randGenerator.Intn(4) {
|
|
case 0:
|
|
minX += 1
|
|
case 1:
|
|
maxX -= 1
|
|
case 2:
|
|
minY += 1
|
|
case 3:
|
|
maxY -= 1
|
|
}
|
|
}
|
|
|
|
for x := int32(0); x < b.Width; x++ {
|
|
for y := int32(0); y < b.Height; y++ {
|
|
if x < minX || x > maxX || y < minY || y > maxY {
|
|
b.Hazards = append(b.Hazards, Point{x, y})
|
|
}
|
|
}
|
|
}
|
|
|
|
return false, nil
|
|
}
|
|
|
|
func (r *RoyaleRuleset) IsGameOver(b *BoardState) (bool, error) {
|
|
return GameOverStandard(b, r.Settings(), nil)
|
|
}
|
|
|
|
func (r RoyaleRuleset) Settings() Settings {
|
|
s := r.StandardRuleset.Settings()
|
|
s.RoyaleSettings = RoyaleSettings{
|
|
seed: r.Seed,
|
|
ShrinkEveryNTurns: r.ShrinkEveryNTurns,
|
|
}
|
|
return s
|
|
}
|