257 lines
8.1 KiB
Go
257 lines
8.1 KiB
Go
package rules
|
|
|
|
import (
|
|
"strconv"
|
|
)
|
|
|
|
type Ruleset interface {
|
|
Name() string
|
|
ModifyInitialBoardState(initialState *BoardState) (*BoardState, error)
|
|
CreateNextBoardState(prevState *BoardState, moves []SnakeMove) (*BoardState, error)
|
|
IsGameOver(state *BoardState) (bool, error)
|
|
// Settings provides the game settings that are relevant to the ruleset.
|
|
Settings() Settings
|
|
}
|
|
|
|
type SnakeMove struct {
|
|
ID string
|
|
Move string
|
|
}
|
|
|
|
// Settings contains all settings relevant to a game.
|
|
// It is used by game logic to take a previous game state and produce a next game state.
|
|
type Settings struct {
|
|
FoodSpawnChance int `json:"foodSpawnChance"`
|
|
MinimumFood int `json:"minimumFood"`
|
|
HazardDamagePerTurn int `json:"hazardDamagePerTurn"`
|
|
HazardMap string `json:"hazardMap"`
|
|
HazardMapAuthor string `json:"hazardMapAuthor"`
|
|
RoyaleSettings RoyaleSettings `json:"royale"`
|
|
SquadSettings SquadSettings `json:"squad"` // Deprecated, provided with default fields for API compatibility
|
|
|
|
rand Rand
|
|
seed int64
|
|
}
|
|
|
|
// Get a random number generator initialized based on the seed and current turn.
|
|
func (settings Settings) GetRand(turn int) Rand {
|
|
// Allow overriding the random generator for testing
|
|
if settings.rand != nil {
|
|
return settings.rand
|
|
}
|
|
|
|
if settings.seed != 0 {
|
|
return NewSeedRand(settings.seed + int64(turn))
|
|
}
|
|
|
|
// Default to global random number generator if neither seed or rand are set.
|
|
return GlobalRand
|
|
}
|
|
|
|
func (settings Settings) WithRand(rand Rand) Settings {
|
|
settings.rand = rand
|
|
return settings
|
|
}
|
|
|
|
func (settings Settings) Seed() int64 {
|
|
return settings.seed
|
|
}
|
|
|
|
func (settings Settings) WithSeed(seed int64) Settings {
|
|
settings.seed = seed
|
|
return settings
|
|
}
|
|
|
|
// RoyaleSettings contains settings that are specific to the "royale" game mode
|
|
type RoyaleSettings struct {
|
|
ShrinkEveryNTurns int `json:"shrinkEveryNTurns"`
|
|
}
|
|
|
|
// SquadSettings contains settings that are specific to the "squad" game mode
|
|
type SquadSettings struct {
|
|
AllowBodyCollisions bool `json:"allowBodyCollisions"`
|
|
SharedElimination bool `json:"sharedElimination"`
|
|
SharedHealth bool `json:"sharedHealth"`
|
|
SharedLength bool `json:"sharedLength"`
|
|
}
|
|
|
|
type rulesetBuilder struct {
|
|
params map[string]string // game customisation parameters
|
|
seed int64 // used for random events in games
|
|
rand Rand // used for random number generation
|
|
solo bool // if true, only 1 alive snake is required to keep the game from ending
|
|
}
|
|
|
|
// NewRulesetBuilder returns an instance of a builder for the Ruleset types.
|
|
func NewRulesetBuilder() *rulesetBuilder {
|
|
return &rulesetBuilder{
|
|
params: map[string]string{},
|
|
}
|
|
}
|
|
|
|
// WithParams accepts a map of game parameters for customizing games.
|
|
//
|
|
// Parameters are copied. If called multiple times, parameters are merged such that:
|
|
// - existing keys in both maps get overwritten by the new ones
|
|
// - existing keys not present in the new map will be retained
|
|
// - non-existing keys only in the new map will be added
|
|
//
|
|
// Unrecognised parameters will be ignored and default values will be used.
|
|
// Invalid parameters (i.e. a non-numerical value where one is expected), will be ignored
|
|
// and default values will be used.
|
|
func (rb *rulesetBuilder) WithParams(params map[string]string) *rulesetBuilder {
|
|
for k, v := range params {
|
|
rb.params[k] = v
|
|
}
|
|
return rb
|
|
}
|
|
|
|
// WithSeed sets the seed used for randomisation by certain game modes.
|
|
func (rb *rulesetBuilder) WithSeed(seed int64) *rulesetBuilder {
|
|
rb.seed = seed
|
|
return rb
|
|
}
|
|
|
|
// WithRandom overrides the random number generator with a specific instance
|
|
// instead of a Rand initialized from the seed.
|
|
func (rb *rulesetBuilder) WithRand(rand Rand) *rulesetBuilder {
|
|
rb.rand = rand
|
|
return rb
|
|
}
|
|
|
|
// WithSolo sets whether the ruleset is a solo game.
|
|
func (rb *rulesetBuilder) WithSolo(value bool) *rulesetBuilder {
|
|
rb.solo = value
|
|
return rb
|
|
}
|
|
|
|
// Ruleset constructs a customised ruleset using the parameters passed to the builder.
|
|
func (rb rulesetBuilder) Ruleset() PipelineRuleset {
|
|
name, ok := rb.params[ParamGameType]
|
|
if !ok {
|
|
name = GameTypeStandard
|
|
}
|
|
|
|
var stages []string
|
|
if rb.solo {
|
|
stages = append(stages, StageGameOverSoloSnake)
|
|
} else {
|
|
stages = append(stages, StageGameOverStandard)
|
|
}
|
|
|
|
switch name {
|
|
case GameTypeStandard:
|
|
stages = append(stages, standardRulesetStages[1:]...)
|
|
case GameTypeConstrictor:
|
|
stages = append(stages, constrictorRulesetStages[1:]...)
|
|
case GameTypeWrappedConstrictor:
|
|
stages = append(stages, wrappedConstrictorRulesetStages[1:]...)
|
|
case GameTypeRoyale:
|
|
stages = append(stages, royaleRulesetStages[1:]...)
|
|
case GameTypeSolo:
|
|
stages = soloRulesetStages
|
|
case GameTypeWrapped:
|
|
stages = append(stages, wrappedRulesetStages[1:]...)
|
|
default:
|
|
stages = append(stages, standardRulesetStages[1:]...)
|
|
}
|
|
return rb.PipelineRuleset(name, NewPipeline(stages...))
|
|
}
|
|
|
|
// PipelineRuleset provides an implementation of the Ruleset using a pipeline with a name.
|
|
// It is intended to facilitate transitioning away from legacy Ruleset implementations to Pipeline
|
|
// implementations.
|
|
func (rb rulesetBuilder) PipelineRuleset(name string, p Pipeline) PipelineRuleset {
|
|
return &pipelineRuleset{
|
|
name: name,
|
|
pipeline: p,
|
|
settings: Settings{
|
|
FoodSpawnChance: paramsInt(rb.params, ParamFoodSpawnChance, 0),
|
|
MinimumFood: paramsInt(rb.params, ParamMinimumFood, 0),
|
|
HazardDamagePerTurn: paramsInt(rb.params, ParamHazardDamagePerTurn, 0),
|
|
HazardMap: rb.params[ParamHazardMap],
|
|
HazardMapAuthor: rb.params[ParamHazardMapAuthor],
|
|
RoyaleSettings: RoyaleSettings{
|
|
ShrinkEveryNTurns: paramsInt(rb.params, ParamShrinkEveryNTurns, 0),
|
|
},
|
|
rand: rb.rand,
|
|
seed: rb.seed,
|
|
},
|
|
}
|
|
}
|
|
|
|
// paramsBool returns the boolean value for the specified parameter.
|
|
// If the parameter doesn't exist, the default value will be returned.
|
|
// If the parameter does exist, but is not "true", false will be returned.
|
|
func paramsBool(params map[string]string, paramName string, defaultValue bool) bool {
|
|
if val, ok := params[paramName]; ok {
|
|
return val == "true"
|
|
}
|
|
return defaultValue
|
|
}
|
|
|
|
// paramsInt returns the int value for the specified parameter.
|
|
// If the parameter doesn't exist, the default value will be returned.
|
|
// If the parameter does exist, but is not a valid int, the default value will be returned.
|
|
func paramsInt(params map[string]string, paramName string, defaultValue int) int {
|
|
if val, ok := params[paramName]; ok {
|
|
i, err := strconv.Atoi(val)
|
|
if err == nil {
|
|
return i
|
|
}
|
|
}
|
|
return defaultValue
|
|
}
|
|
|
|
// PipelineRuleset groups the Pipeline and Ruleset methods.
|
|
// It is intended to facilitate a transition from Ruleset legacy code to Pipeline code.
|
|
type PipelineRuleset interface {
|
|
Ruleset
|
|
Pipeline
|
|
}
|
|
|
|
type pipelineRuleset struct {
|
|
pipeline Pipeline
|
|
name string
|
|
settings Settings
|
|
}
|
|
|
|
// impl Ruleset
|
|
func (r pipelineRuleset) Settings() Settings {
|
|
return r.settings
|
|
}
|
|
|
|
// impl Ruleset
|
|
func (r pipelineRuleset) Name() string { return r.name }
|
|
|
|
// impl Ruleset
|
|
// IMPORTANT: this implementation of IsGameOver deviates from the previous Ruleset implementations
|
|
// in that it checks if the *NEXT* state results in game over, not the previous state.
|
|
// This is due to the design of pipelines / stage functions not having a distinction between
|
|
// checking for game over and producing a next state.
|
|
func (r *pipelineRuleset) IsGameOver(b *BoardState) (bool, error) {
|
|
gameover, _, err := r.Execute(b, r.Settings(), nil) // checks if next state is game over
|
|
return gameover, err
|
|
}
|
|
|
|
// impl Ruleset
|
|
func (r pipelineRuleset) ModifyInitialBoardState(initialState *BoardState) (*BoardState, error) {
|
|
_, nextState, err := r.Execute(initialState, r.Settings(), nil)
|
|
return nextState, err
|
|
}
|
|
|
|
// impl Pipeline
|
|
func (r pipelineRuleset) Execute(bs *BoardState, s Settings, sm []SnakeMove) (bool, *BoardState, error) {
|
|
return r.pipeline.Execute(bs, s, sm)
|
|
}
|
|
|
|
// impl Ruleset
|
|
func (r pipelineRuleset) CreateNextBoardState(bs *BoardState, sm []SnakeMove) (*BoardState, error) {
|
|
_, nextState, err := r.Execute(bs, r.Settings(), sm)
|
|
return nextState, err
|
|
}
|
|
|
|
// impl Pipeline
|
|
func (r pipelineRuleset) Err() error {
|
|
return r.pipeline.Err()
|
|
}
|