change all "int32" types to "int" (#75)
This commit is contained in:
Torben
GitHub
parent
2d8342018e
commit
3bd1e47bb4
19 changed files with 176 additions and 176 deletions
44
board.go
44
board.go
|
|
@ -3,17 +3,17 @@ package rules
|
|||
import "fmt"
|
||||
|
||||
type BoardState struct {
|
||||
Turn int32
|
||||
Height int32
|
||||
Width int32
|
||||
Turn int
|
||||
Height int
|
||||
Width int
|
||||
Food []Point
|
||||
Snakes []Snake
|
||||
Hazards []Point
|
||||
}
|
||||
|
||||
type Point struct {
|
||||
X int32
|
||||
Y int32
|
||||
X int
|
||||
Y int
|
||||
}
|
||||
|
||||
// Makes it easier to copy sample points out of Go logs and test failures.
|
||||
|
|
@ -24,14 +24,14 @@ func (p Point) GoString() string {
|
|||
type Snake struct {
|
||||
ID string
|
||||
Body []Point
|
||||
Health int32
|
||||
Health int
|
||||
EliminatedCause string
|
||||
EliminatedOnTurn int32
|
||||
EliminatedOnTurn int
|
||||
EliminatedBy string
|
||||
}
|
||||
|
||||
// NewBoardState returns an empty but fully initialized BoardState
|
||||
func NewBoardState(width, height int32) *BoardState {
|
||||
func NewBoardState(width, height int) *BoardState {
|
||||
return &BoardState{
|
||||
Turn: 0,
|
||||
Height: height,
|
||||
|
|
@ -66,7 +66,7 @@ func (prevState *BoardState) Clone() *BoardState {
|
|||
// "default" board state with snakes and food.
|
||||
// In a real game, the engine may generate the board without calling this
|
||||
// function, or customize the results based on game-specific settings.
|
||||
func CreateDefaultBoardState(rand Rand, width int32, height int32, snakeIDs []string) (*BoardState, error) {
|
||||
func CreateDefaultBoardState(rand Rand, width int, height int, snakeIDs []string) (*BoardState, error) {
|
||||
initialBoardState := NewBoardState(width, height)
|
||||
|
||||
err := PlaceSnakesAutomatically(rand, initialBoardState, snakeIDs)
|
||||
|
|
@ -101,7 +101,7 @@ func PlaceSnakesFixed(rand Rand, b *BoardState, snakeIDs []string) error {
|
|||
}
|
||||
|
||||
// Create start 8 points
|
||||
mn, md, mx := int32(1), (b.Width-1)/2, b.Width-2
|
||||
mn, md, mx := 1, (b.Width-1)/2, b.Width-2
|
||||
cornerPoints := []Point{
|
||||
{mn, mn},
|
||||
{mn, mx},
|
||||
|
|
@ -207,7 +207,7 @@ func PlaceFoodAutomatically(rand Rand, b *BoardState) error {
|
|||
if isKnownBoardSize(b) {
|
||||
return PlaceFoodFixed(rand, b)
|
||||
}
|
||||
return PlaceFoodRandomly(rand, b, int32(len(b.Snakes)))
|
||||
return PlaceFoodRandomly(rand, b, len(b.Snakes))
|
||||
}
|
||||
|
||||
func PlaceFoodFixed(rand Rand, b *BoardState) error {
|
||||
|
|
@ -289,8 +289,8 @@ func PlaceFoodFixed(rand Rand, b *BoardState) error {
|
|||
}
|
||||
|
||||
// PlaceFoodRandomly adds up to n new food to the board in random unoccupied squares
|
||||
func PlaceFoodRandomly(rand Rand, b *BoardState, n int32) error {
|
||||
for i := int32(0); i < n; i++ {
|
||||
func PlaceFoodRandomly(rand Rand, b *BoardState, n int) error {
|
||||
for i := 0; i < n; i++ {
|
||||
unoccupiedPoints := GetUnoccupiedPoints(b, false)
|
||||
if len(unoccupiedPoints) > 0 {
|
||||
newFood := unoccupiedPoints[rand.Intn(len(unoccupiedPoints))]
|
||||
|
|
@ -300,7 +300,7 @@ func PlaceFoodRandomly(rand Rand, b *BoardState, n int32) error {
|
|||
return nil
|
||||
}
|
||||
|
||||
func absInt32(n int32) int32 {
|
||||
func absInt(n int) int {
|
||||
if n < 0 {
|
||||
return -n
|
||||
}
|
||||
|
|
@ -323,10 +323,10 @@ func GetEvenUnoccupiedPoints(b *BoardState) []Point {
|
|||
}
|
||||
|
||||
func GetUnoccupiedPoints(b *BoardState, includePossibleMoves bool) []Point {
|
||||
pointIsOccupied := map[int32]map[int32]bool{}
|
||||
pointIsOccupied := map[int]map[int]bool{}
|
||||
for _, p := range b.Food {
|
||||
if _, xExists := pointIsOccupied[p.X]; !xExists {
|
||||
pointIsOccupied[p.X] = map[int32]bool{}
|
||||
pointIsOccupied[p.X] = map[int]bool{}
|
||||
}
|
||||
pointIsOccupied[p.X][p.Y] = true
|
||||
}
|
||||
|
|
@ -336,7 +336,7 @@ func GetUnoccupiedPoints(b *BoardState, includePossibleMoves bool) []Point {
|
|||
}
|
||||
for i, p := range snake.Body {
|
||||
if _, xExists := pointIsOccupied[p.X]; !xExists {
|
||||
pointIsOccupied[p.X] = map[int32]bool{}
|
||||
pointIsOccupied[p.X] = map[int]bool{}
|
||||
}
|
||||
pointIsOccupied[p.X][p.Y] = true
|
||||
|
||||
|
|
@ -349,7 +349,7 @@ func GetUnoccupiedPoints(b *BoardState, includePossibleMoves bool) []Point {
|
|||
}
|
||||
for _, nextP := range nextMovePoints {
|
||||
if _, xExists := pointIsOccupied[nextP.X]; !xExists {
|
||||
pointIsOccupied[nextP.X] = map[int32]bool{}
|
||||
pointIsOccupied[nextP.X] = map[int]bool{}
|
||||
}
|
||||
pointIsOccupied[nextP.X][nextP.Y] = true
|
||||
}
|
||||
|
|
@ -358,8 +358,8 @@ func GetUnoccupiedPoints(b *BoardState, includePossibleMoves bool) []Point {
|
|||
}
|
||||
|
||||
unoccupiedPoints := []Point{}
|
||||
for x := int32(0); x < b.Width; x++ {
|
||||
for y := int32(0); y < b.Height; y++ {
|
||||
for x := 0; x < b.Width; x++ {
|
||||
for y := 0; y < b.Height; y++ {
|
||||
if _, xExists := pointIsOccupied[x]; xExists {
|
||||
if isOccupied, yExists := pointIsOccupied[x][y]; yExists {
|
||||
if isOccupied {
|
||||
|
|
@ -373,8 +373,8 @@ func GetUnoccupiedPoints(b *BoardState, includePossibleMoves bool) []Point {
|
|||
return unoccupiedPoints
|
||||
}
|
||||
|
||||
func getDistanceBetweenPoints(a, b Point) int32 {
|
||||
return absInt32(a.X-b.X) + absInt32(a.Y-b.Y)
|
||||
func getDistanceBetweenPoints(a, b Point) int {
|
||||
return absInt(a.X-b.X) + absInt(a.Y-b.Y)
|
||||
}
|
||||
|
||||
func isKnownBoardSize(b *BoardState) bool {
|
||||
|
|
|
|||
|
|
@ -19,8 +19,8 @@ func sortPoints(p []Point) {
|
|||
|
||||
func TestCreateDefaultBoardState(t *testing.T) {
|
||||
tests := []struct {
|
||||
Height int32
|
||||
Width int32
|
||||
Height int
|
||||
Width int
|
||||
IDs []string
|
||||
ExpectedNumFood int
|
||||
Err error
|
||||
|
|
@ -196,15 +196,15 @@ func TestPlaceSnakesDefault(t *testing.T) {
|
|||
|
||||
for _, test := range tests {
|
||||
t.Run(fmt.Sprint(test.BoardState.Width, test.BoardState.Height, len(test.SnakeIDs)), func(t *testing.T) {
|
||||
require.Equal(t, test.BoardState.Width*test.BoardState.Height, int32(len(GetUnoccupiedPoints(test.BoardState, true))))
|
||||
require.Equal(t, test.BoardState.Width*test.BoardState.Height, len(GetUnoccupiedPoints(test.BoardState, true)))
|
||||
err := PlaceSnakesAutomatically(MaxRand, test.BoardState, test.SnakeIDs)
|
||||
require.Equal(t, test.Err, err, "Snakes: %d", len(test.BoardState.Snakes))
|
||||
if err == nil {
|
||||
for i := 0; i < len(test.BoardState.Snakes); i++ {
|
||||
require.Len(t, test.BoardState.Snakes[i].Body, 3)
|
||||
for _, point := range test.BoardState.Snakes[i].Body {
|
||||
require.GreaterOrEqual(t, point.X, int32(0))
|
||||
require.GreaterOrEqual(t, point.Y, int32(0))
|
||||
require.GreaterOrEqual(t, point.X, 0)
|
||||
require.GreaterOrEqual(t, point.Y, 0)
|
||||
require.Less(t, point.X, test.BoardState.Width)
|
||||
require.Less(t, point.Y, test.BoardState.Height)
|
||||
}
|
||||
|
|
@ -400,8 +400,8 @@ func TestPlaceFood(t *testing.T) {
|
|||
require.NoError(t, err)
|
||||
require.Equal(t, test.ExpectedFood, len(test.BoardState.Food))
|
||||
for _, point := range test.BoardState.Food {
|
||||
require.GreaterOrEqual(t, point.X, int32(0))
|
||||
require.GreaterOrEqual(t, point.Y, int32(0))
|
||||
require.GreaterOrEqual(t, point.X, 0)
|
||||
require.GreaterOrEqual(t, point.Y, 0)
|
||||
require.Less(t, point.X, test.BoardState.Width)
|
||||
require.Less(t, point.Y, test.BoardState.Height)
|
||||
}
|
||||
|
|
@ -590,7 +590,7 @@ func TestGetDistanceBetweenPoints(t *testing.T) {
|
|||
tests := []struct {
|
||||
A Point
|
||||
B Point
|
||||
Expected int32
|
||||
Expected int
|
||||
}{
|
||||
{Point{0, 0}, Point{0, 0}, 0},
|
||||
{Point{0, 0}, Point{1, 0}, 1},
|
||||
|
|
@ -611,8 +611,8 @@ func TestGetDistanceBetweenPoints(t *testing.T) {
|
|||
|
||||
func TestIsKnownBoardSize(t *testing.T) {
|
||||
tests := []struct {
|
||||
Width int32
|
||||
Height int32
|
||||
Width int
|
||||
Height int
|
||||
Expected bool
|
||||
}{
|
||||
{1, 1, false},
|
||||
|
|
|
|||
|
|
@ -32,25 +32,25 @@ Usage:
|
|||
battlesnake play [flags]
|
||||
|
||||
Flags:
|
||||
-W, --width int32 Width of Board (default 11)
|
||||
-H, --height int32 Height of Board (default 11)
|
||||
-W, --width int Width of Board (default 11)
|
||||
-H, --height int Height of Board (default 11)
|
||||
-n, --name stringArray Name of Snake
|
||||
-u, --url stringArray URL of Snake
|
||||
-S, --squad stringArray Squad of Snake
|
||||
-t, --timeout int32 Request Timeout (default 500)
|
||||
-t, --timeout int Request Timeout (default 500)
|
||||
-s, --sequential Use Sequential Processing
|
||||
-g, --gametype string Type of Game Rules (default "standard")
|
||||
-v, --viewmap View the Map Each Turn
|
||||
-c, --color Use color to draw the map
|
||||
-r, --seed int Random Seed (default 1649588785026867900)
|
||||
-d, --delay int32 Turn Delay in Milliseconds
|
||||
-D, --duration int32 Minimum Turn Duration in Milliseconds
|
||||
-d, --delay int Turn Delay in Milliseconds
|
||||
-D, --duration int Minimum Turn Duration in Milliseconds
|
||||
--debug-requests Log body of all requests sent
|
||||
-o, --output string File path to output game state to. Existing files will be overwritten
|
||||
--foodSpawnChance int32 Percentage chance of spawning a new food every round (default 15)
|
||||
--minimumFood int32 Minimum food to keep on the board every turn (default 1)
|
||||
--hazardDamagePerTurn int32 Health damage a snake will take when ending its turn in a hazard (default 14)
|
||||
--shrinkEveryNTurns int32 In Royale mode, the number of turns between generating new hazards (default 25)
|
||||
--foodSpawnChance int Percentage chance of spawning a new food every round (default 15)
|
||||
--minimumFood int Minimum food to keep on the board every turn (default 1)
|
||||
--hazardDamagePerTurn int Health damage a snake will take when ending its turn in a hazard (default 14)
|
||||
--shrinkEveryNTurns int In Royale mode, the number of turns between generating new hazards (default 25)
|
||||
-h, --help help for play
|
||||
|
||||
Global Flags:
|
||||
|
|
|
|||
|
|
@ -35,28 +35,28 @@ type SnakeState struct {
|
|||
}
|
||||
|
||||
var GameId string
|
||||
var Turn int32
|
||||
var Turn int
|
||||
var HttpClient http.Client
|
||||
var Width int32
|
||||
var Height int32
|
||||
var Width int
|
||||
var Height int
|
||||
var Names []string
|
||||
var URLs []string
|
||||
var Squads []string
|
||||
var Timeout int32
|
||||
var TurnDuration int32
|
||||
var Timeout int
|
||||
var TurnDuration int
|
||||
var Sequential bool
|
||||
var GameType string
|
||||
var ViewMap bool
|
||||
var UseColor bool
|
||||
var Seed int64
|
||||
var TurnDelay int32
|
||||
var TurnDelay int
|
||||
var DebugRequests bool
|
||||
var Output string
|
||||
|
||||
var FoodSpawnChance int32
|
||||
var MinimumFood int32
|
||||
var HazardDamagePerTurn int32
|
||||
var ShrinkEveryNTurns int32
|
||||
var FoodSpawnChance int
|
||||
var MinimumFood int
|
||||
var HazardDamagePerTurn int
|
||||
var ShrinkEveryNTurns int
|
||||
|
||||
var defaultConfig = map[string]string{
|
||||
// default to standard ruleset
|
||||
|
|
@ -79,26 +79,26 @@ var playCmd = &cobra.Command{
|
|||
func init() {
|
||||
rootCmd.AddCommand(playCmd)
|
||||
|
||||
playCmd.Flags().Int32VarP(&Width, "width", "W", 11, "Width of Board")
|
||||
playCmd.Flags().Int32VarP(&Height, "height", "H", 11, "Height of Board")
|
||||
playCmd.Flags().IntVarP(&Width, "width", "W", 11, "Width of Board")
|
||||
playCmd.Flags().IntVarP(&Height, "height", "H", 11, "Height of Board")
|
||||
playCmd.Flags().StringArrayVarP(&Names, "name", "n", nil, "Name of Snake")
|
||||
playCmd.Flags().StringArrayVarP(&URLs, "url", "u", nil, "URL of Snake")
|
||||
playCmd.Flags().StringArrayVarP(&Names, "squad", "S", nil, "Squad of Snake")
|
||||
playCmd.Flags().Int32VarP(&Timeout, "timeout", "t", 500, "Request Timeout")
|
||||
playCmd.Flags().IntVarP(&Timeout, "timeout", "t", 500, "Request Timeout")
|
||||
playCmd.Flags().BoolVarP(&Sequential, "sequential", "s", false, "Use Sequential Processing")
|
||||
playCmd.Flags().StringVarP(&GameType, "gametype", "g", "standard", "Type of Game Rules")
|
||||
playCmd.Flags().BoolVarP(&ViewMap, "viewmap", "v", false, "View the Map Each Turn")
|
||||
playCmd.Flags().BoolVarP(&UseColor, "color", "c", false, "Use color to draw the map")
|
||||
playCmd.Flags().Int64VarP(&Seed, "seed", "r", time.Now().UTC().UnixNano(), "Random Seed")
|
||||
playCmd.Flags().Int32VarP(&TurnDelay, "delay", "d", 0, "Turn Delay in Milliseconds")
|
||||
playCmd.Flags().Int32VarP(&TurnDuration, "duration", "D", 0, "Minimum Turn Duration in Milliseconds")
|
||||
playCmd.Flags().IntVarP(&TurnDelay, "delay", "d", 0, "Turn Delay in Milliseconds")
|
||||
playCmd.Flags().IntVarP(&TurnDuration, "duration", "D", 0, "Minimum Turn Duration in Milliseconds")
|
||||
playCmd.Flags().BoolVar(&DebugRequests, "debug-requests", false, "Log body of all requests sent")
|
||||
playCmd.Flags().StringVarP(&Output, "output", "o", "", "File path to output game state to. Existing files will be overwritten")
|
||||
|
||||
playCmd.Flags().Int32Var(&FoodSpawnChance, "foodSpawnChance", 15, "Percentage chance of spawning a new food every round")
|
||||
playCmd.Flags().Int32Var(&MinimumFood, "minimumFood", 1, "Minimum food to keep on the board every turn")
|
||||
playCmd.Flags().Int32Var(&HazardDamagePerTurn, "hazardDamagePerTurn", 14, "Health damage a snake will take when ending its turn in a hazard")
|
||||
playCmd.Flags().Int32Var(&ShrinkEveryNTurns, "shrinkEveryNTurns", 25, "In Royale mode, the number of turns between generating new hazards")
|
||||
playCmd.Flags().IntVar(&FoodSpawnChance, "foodSpawnChance", 15, "Percentage chance of spawning a new food every round")
|
||||
playCmd.Flags().IntVar(&MinimumFood, "minimumFood", 1, "Minimum food to keep on the board every turn")
|
||||
playCmd.Flags().IntVar(&HazardDamagePerTurn, "hazardDamagePerTurn", 14, "Health damage a snake will take when ending its turn in a hazard")
|
||||
playCmd.Flags().IntVar(&ShrinkEveryNTurns, "shrinkEveryNTurns", 25, "In Royale mode, the number of turns between generating new hazards")
|
||||
|
||||
playCmd.Flags().SortFlags = false
|
||||
}
|
||||
|
|
@ -256,7 +256,7 @@ func initializeBoardFromArgs(ruleset rules.Ruleset, snakeStates map[string]Snake
|
|||
return state
|
||||
}
|
||||
|
||||
func createNextBoardState(ruleset rules.Ruleset, state *rules.BoardState, snakeStates map[string]SnakeState, turn int32) *rules.BoardState {
|
||||
func createNextBoardState(ruleset rules.Ruleset, state *rules.BoardState, snakeStates map[string]SnakeState, turn int) *rules.BoardState {
|
||||
var moves []rules.SnakeMove
|
||||
if Sequential {
|
||||
for _, snakeState := range snakeStates {
|
||||
|
|
@ -391,7 +391,7 @@ func convertRulesSnake(snake rules.Snake, snakeState SnakeState) client.Snake {
|
|||
Body: client.CoordFromPointArray(snake.Body),
|
||||
Latency: "0",
|
||||
Head: client.CoordFromPoint(snake.Body[0]),
|
||||
Length: int32(len(snake.Body)),
|
||||
Length: len(snake.Body),
|
||||
Shout: "",
|
||||
Squad: snakeState.Squad,
|
||||
Customizations: client.Customizations{
|
||||
|
|
@ -518,15 +518,15 @@ func parseSnakeColor(color string) (int64, int64, int64) {
|
|||
return 136, 136, 136
|
||||
}
|
||||
|
||||
func printMap(state *rules.BoardState, snakeStates map[string]SnakeState, gameTurn int32) {
|
||||
func printMap(state *rules.BoardState, snakeStates map[string]SnakeState, gameTurn int) {
|
||||
var o bytes.Buffer
|
||||
o.WriteString(fmt.Sprintf("Ruleset: %s, Seed: %d, Turn: %v\n", GameType, Seed, gameTurn))
|
||||
board := make([][]string, state.Width)
|
||||
for i := range board {
|
||||
board[i] = make([]string, state.Height)
|
||||
}
|
||||
for y := int32(0); y < state.Height; y++ {
|
||||
for x := int32(0); x < state.Width; x++ {
|
||||
for y := 0; y < state.Height; y++ {
|
||||
for x := 0; x < state.Width; x++ {
|
||||
if UseColor {
|
||||
board[x][y] = TERM_FG_LIGHTGRAY + "□"
|
||||
} else {
|
||||
|
|
@ -579,7 +579,7 @@ func printMap(state *rules.BoardState, snakeStates map[string]SnakeState, gameTu
|
|||
if UseColor {
|
||||
o.WriteString(TERM_BG_WHITE)
|
||||
}
|
||||
for x := int32(0); x < state.Width; x++ {
|
||||
for x := 0; x < state.Width; x++ {
|
||||
o.WriteString(board[x][y])
|
||||
}
|
||||
if UseColor {
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ import "github.com/BattlesnakeOfficial/rules"
|
|||
// The top-level message sent in /start, /move, and /end requests
|
||||
type SnakeRequest struct {
|
||||
Game Game `json:"game"`
|
||||
Turn int32 `json:"turn"`
|
||||
Turn int `json:"turn"`
|
||||
Board Board `json:"board"`
|
||||
You Snake `json:"you"`
|
||||
}
|
||||
|
|
@ -15,14 +15,14 @@ type Game struct {
|
|||
ID string `json:"id"`
|
||||
Ruleset Ruleset `json:"ruleset"`
|
||||
Map string `json:"map"`
|
||||
Timeout int32 `json:"timeout"`
|
||||
Timeout int `json:"timeout"`
|
||||
Source string `json:"source"`
|
||||
}
|
||||
|
||||
// Board provides information about the game board
|
||||
type Board struct {
|
||||
Height int32 `json:"height"`
|
||||
Width int32 `json:"width"`
|
||||
Height int `json:"height"`
|
||||
Width int `json:"width"`
|
||||
Snakes []Snake `json:"snakes"`
|
||||
Food []Coord `json:"food"`
|
||||
Hazards []Coord `json:"hazards"`
|
||||
|
|
@ -33,10 +33,10 @@ type Snake struct {
|
|||
ID string `json:"id"`
|
||||
Name string `json:"name"`
|
||||
Latency string `json:"latency"`
|
||||
Health int32 `json:"health"`
|
||||
Health int `json:"health"`
|
||||
Body []Coord `json:"body"`
|
||||
Head Coord `json:"head"`
|
||||
Length int32 `json:"length"`
|
||||
Length int `json:"length"`
|
||||
Shout string `json:"shout"`
|
||||
Squad string `json:"squad"`
|
||||
Customizations Customizations `json:"customizations"`
|
||||
|
|
@ -65,8 +65,8 @@ type SquadSettings rules.SquadSettings
|
|||
|
||||
// Coord represents a point on the board
|
||||
type Coord struct {
|
||||
X int32 `json:"x"`
|
||||
Y int32 `json:"y"`
|
||||
X int `json:"x"`
|
||||
Y int `json:"y"`
|
||||
}
|
||||
|
||||
// The expected format of the response body from a /move request
|
||||
|
|
|
|||
|
|
@ -12,8 +12,8 @@ func TestConstrictorRulesetInterface(t *testing.T) {
|
|||
|
||||
func TestConstrictorModifyInitialBoardState(t *testing.T) {
|
||||
tests := []struct {
|
||||
Height int32
|
||||
Width int32
|
||||
Height int
|
||||
Width int
|
||||
IDs []string
|
||||
}{
|
||||
{1, 1, []string{}},
|
||||
|
|
|
|||
|
|
@ -43,7 +43,7 @@ type Editor interface {
|
|||
RemoveHazard(rules.Point)
|
||||
|
||||
// Updates the body and health of a snake.
|
||||
PlaceSnake(id string, body []rules.Point, health int32)
|
||||
PlaceSnake(id string, body []rules.Point, health int)
|
||||
}
|
||||
|
||||
// An Editor backed by a BoardState.
|
||||
|
|
@ -91,7 +91,7 @@ func (editor *BoardStateEditor) RemoveHazard(p rules.Point) {
|
|||
}
|
||||
}
|
||||
|
||||
func (editor *BoardStateEditor) PlaceSnake(id string, body []rules.Point, health int32) {
|
||||
func (editor *BoardStateEditor) PlaceSnake(id string, body []rules.Point, health int) {
|
||||
for index, snake := range editor.Snakes {
|
||||
if snake.ID == id {
|
||||
editor.Snakes[index].Body = body
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@ import "github.com/BattlesnakeOfficial/rules"
|
|||
|
||||
// SetupBoard is a shortcut for looking up a map by ID and initializing a new board state with it.
|
||||
func SetupBoard(mapID string, settings rules.Settings, width, height int, snakeIDs []string) (*rules.BoardState, error) {
|
||||
boardState := rules.NewBoardState(int32(width), int32(height))
|
||||
boardState := rules.NewBoardState(width, height)
|
||||
|
||||
rules.InitializeSnakes(boardState, snakeIDs)
|
||||
|
||||
|
|
|
|||
|
|
@ -47,9 +47,9 @@ func (m RoyaleHazardsMap) UpdateBoard(lastBoardState *rules.BoardState, settings
|
|||
randGenerator := settings.GetRand(0)
|
||||
|
||||
numShrinks := turn / settings.RoyaleSettings.ShrinkEveryNTurns
|
||||
minX, maxX := int32(0), lastBoardState.Width-1
|
||||
minY, maxY := int32(0), lastBoardState.Height-1
|
||||
for i := int32(0); i < numShrinks; i++ {
|
||||
minX, maxX := 0, lastBoardState.Width-1
|
||||
minY, maxY := 0, lastBoardState.Height-1
|
||||
for i := 0; i < numShrinks; i++ {
|
||||
switch randGenerator.Intn(4) {
|
||||
case 0:
|
||||
minX += 1
|
||||
|
|
@ -62,8 +62,8 @@ func (m RoyaleHazardsMap) UpdateBoard(lastBoardState *rules.BoardState, settings
|
|||
}
|
||||
}
|
||||
|
||||
for x := int32(0); x < lastBoardState.Width; x++ {
|
||||
for y := int32(0); y < lastBoardState.Height; y++ {
|
||||
for x := 0; x < lastBoardState.Width; x++ {
|
||||
for y := 0; y < lastBoardState.Height; y++ {
|
||||
if x < minX || x > maxX || y < minY || y > maxY {
|
||||
editor.AddHazard(rules.Point{X: x, Y: y})
|
||||
}
|
||||
|
|
|
|||
12
royale.go
12
royale.go
|
|
@ -21,7 +21,7 @@ type RoyaleRuleset struct {
|
|||
|
||||
Seed int64
|
||||
|
||||
ShrinkEveryNTurns int32
|
||||
ShrinkEveryNTurns int
|
||||
}
|
||||
|
||||
func (r *RoyaleRuleset) Name() string { return GameTypeRoyale }
|
||||
|
|
@ -58,9 +58,9 @@ func PopulateHazardsRoyale(b *BoardState, settings Settings, moves []SnakeMove)
|
|||
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++ {
|
||||
minX, maxX := 0, b.Width-1
|
||||
minY, maxY := 0, b.Height-1
|
||||
for i := 0; i < numShrinks; i++ {
|
||||
switch randGenerator.Intn(4) {
|
||||
case 0:
|
||||
minX += 1
|
||||
|
|
@ -73,8 +73,8 @@ func PopulateHazardsRoyale(b *BoardState, settings Settings, moves []SnakeMove)
|
|||
}
|
||||
}
|
||||
|
||||
for x := int32(0); x < b.Width; x++ {
|
||||
for y := int32(0); y < b.Height; y++ {
|
||||
for x := 0; x < b.Width; x++ {
|
||||
for y := 0; y < b.Height; y++ {
|
||||
if x < minX || x > maxX || y < minY || y > maxY {
|
||||
b.Hazards = append(b.Hazards, Point{x, y})
|
||||
}
|
||||
|
|
|
|||
|
|
@ -38,10 +38,10 @@ func TestRoyaleName(t *testing.T) {
|
|||
func TestRoyaleHazards(t *testing.T) {
|
||||
seed := int64(25543234525)
|
||||
tests := []struct {
|
||||
Width int32
|
||||
Height int32
|
||||
Turn int32
|
||||
ShrinkEveryNTurns int32
|
||||
Width int
|
||||
Height int
|
||||
Turn int
|
||||
ShrinkEveryNTurns int
|
||||
Error error
|
||||
ExpectedHazards []Point
|
||||
}{
|
||||
|
|
@ -128,7 +128,7 @@ func TestRoyalDamageNextTurn(t *testing.T) {
|
|||
r := RoyaleRuleset{StandardRuleset: StandardRuleset{HazardDamagePerTurn: 30}, Seed: seed, ShrinkEveryNTurns: 10}
|
||||
m := []SnakeMove{{ID: "one", Move: "down"}}
|
||||
|
||||
stateAfterTurn := func(prevState *BoardState, turn int32) *BoardState {
|
||||
stateAfterTurn := func(prevState *BoardState, turn int) *BoardState {
|
||||
nextState := prevState.Clone()
|
||||
nextState.Turn = turn - 1
|
||||
_, err := PopulateHazardsRoyale(nextState, r.Settings(), nil)
|
||||
|
|
@ -141,7 +141,7 @@ func TestRoyalDamageNextTurn(t *testing.T) {
|
|||
next, err := r.CreateNextBoardState(prevState, m)
|
||||
require.NoError(t, err)
|
||||
require.Equal(t, NotEliminated, next.Snakes[0].EliminatedCause)
|
||||
require.Equal(t, int32(99), next.Snakes[0].Health)
|
||||
require.Equal(t, 99, next.Snakes[0].Health)
|
||||
require.Equal(t, Point{9, 0}, next.Snakes[0].Body[0])
|
||||
require.Equal(t, 10, len(next.Hazards)) // X = 0
|
||||
|
||||
|
|
@ -149,7 +149,7 @@ func TestRoyalDamageNextTurn(t *testing.T) {
|
|||
next, err = r.CreateNextBoardState(prevState, m)
|
||||
require.NoError(t, err)
|
||||
require.Equal(t, NotEliminated, next.Snakes[0].EliminatedCause)
|
||||
require.Equal(t, int32(99), next.Snakes[0].Health)
|
||||
require.Equal(t, 99, next.Snakes[0].Health)
|
||||
require.Equal(t, Point{9, 0}, next.Snakes[0].Body[0])
|
||||
require.Equal(t, 20, len(next.Hazards)) // X = 9
|
||||
|
||||
|
|
@ -157,7 +157,7 @@ func TestRoyalDamageNextTurn(t *testing.T) {
|
|||
next, err = r.CreateNextBoardState(prevState, m)
|
||||
require.NoError(t, err)
|
||||
require.Equal(t, NotEliminated, next.Snakes[0].EliminatedCause)
|
||||
require.Equal(t, int32(69), next.Snakes[0].Health)
|
||||
require.Equal(t, 69, next.Snakes[0].Health)
|
||||
require.Equal(t, Point{9, 0}, next.Snakes[0].Body[0])
|
||||
require.Equal(t, 20, len(next.Hazards))
|
||||
|
||||
|
|
@ -165,7 +165,7 @@ func TestRoyalDamageNextTurn(t *testing.T) {
|
|||
next, err = r.CreateNextBoardState(prevState, m)
|
||||
require.NoError(t, err)
|
||||
require.Equal(t, EliminatedByOutOfHealth, next.Snakes[0].EliminatedCause)
|
||||
require.Equal(t, int32(0), next.Snakes[0].Health)
|
||||
require.Equal(t, 0, next.Snakes[0].Health)
|
||||
require.Equal(t, Point{9, 0}, next.Snakes[0].Body[0])
|
||||
require.Equal(t, 20, len(next.Hazards))
|
||||
|
||||
|
|
@ -174,7 +174,7 @@ func TestRoyalDamageNextTurn(t *testing.T) {
|
|||
require.NoError(t, err)
|
||||
require.Equal(t, Point{9, 0}, next.Snakes[0].Body[0])
|
||||
require.Equal(t, NotEliminated, next.Snakes[0].EliminatedCause)
|
||||
require.Equal(t, int32(100), next.Snakes[0].Health)
|
||||
require.Equal(t, 100, next.Snakes[0].Health)
|
||||
require.Equal(t, Point{9, 0}, next.Snakes[0].Body[0])
|
||||
require.Equal(t, 20, len(next.Hazards))
|
||||
}
|
||||
|
|
|
|||
32
ruleset.go
32
ruleset.go
|
|
@ -21,9 +21,9 @@ type SnakeMove struct {
|
|||
// 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 int32 `json:"foodSpawnChance"`
|
||||
MinimumFood int32 `json:"minimumFood"`
|
||||
HazardDamagePerTurn int32 `json:"hazardDamagePerTurn"`
|
||||
FoodSpawnChance int `json:"foodSpawnChance"`
|
||||
MinimumFood int `json:"minimumFood"`
|
||||
HazardDamagePerTurn int `json:"hazardDamagePerTurn"`
|
||||
HazardMap string `json:"hazardMap"`
|
||||
HazardMapAuthor string `json:"hazardMapAuthor"`
|
||||
RoyaleSettings RoyaleSettings `json:"royale"`
|
||||
|
|
@ -34,7 +34,7 @@ type Settings struct {
|
|||
}
|
||||
|
||||
// Get a random number generator initialized based on the seed and current turn.
|
||||
func (settings Settings) GetRand(turn int32) Rand {
|
||||
func (settings Settings) GetRand(turn int) Rand {
|
||||
// Allow overriding the random generator for testing
|
||||
if settings.rand != nil {
|
||||
return settings.rand
|
||||
|
|
@ -65,7 +65,7 @@ func (settings Settings) WithSeed(seed int64) Settings {
|
|||
// RoyaleSettings contains settings that are specific to the "royale" game mode
|
||||
type RoyaleSettings struct {
|
||||
seed int64
|
||||
ShrinkEveryNTurns int32 `json:"shrinkEveryNTurns"`
|
||||
ShrinkEveryNTurns int `json:"shrinkEveryNTurns"`
|
||||
}
|
||||
|
||||
// SquadSettings contains settings that are specific to the "squad" game mode
|
||||
|
|
@ -132,9 +132,9 @@ func (rb *rulesetBuilder) AddSnakeToSquad(snakeID, squadName string) *rulesetBui
|
|||
// Ruleset constructs a customised ruleset using the parameters passed to the builder.
|
||||
func (rb rulesetBuilder) Ruleset() PipelineRuleset {
|
||||
standardRuleset := &StandardRuleset{
|
||||
FoodSpawnChance: paramsInt32(rb.params, ParamFoodSpawnChance, 0),
|
||||
MinimumFood: paramsInt32(rb.params, ParamMinimumFood, 0),
|
||||
HazardDamagePerTurn: paramsInt32(rb.params, ParamHazardDamagePerTurn, 0),
|
||||
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],
|
||||
}
|
||||
|
|
@ -153,7 +153,7 @@ func (rb rulesetBuilder) Ruleset() PipelineRuleset {
|
|||
return &RoyaleRuleset{
|
||||
StandardRuleset: *standardRuleset,
|
||||
Seed: rb.seed,
|
||||
ShrinkEveryNTurns: paramsInt32(rb.params, ParamShrinkEveryNTurns, 0),
|
||||
ShrinkEveryNTurns: paramsInt(rb.params, ParamShrinkEveryNTurns, 0),
|
||||
}
|
||||
case GameTypeSolo:
|
||||
return &SoloRuleset{
|
||||
|
|
@ -192,14 +192,14 @@ func (rb rulesetBuilder) PipelineRuleset(name string, p Pipeline) PipelineRulese
|
|||
name: name,
|
||||
pipeline: p,
|
||||
settings: Settings{
|
||||
FoodSpawnChance: paramsInt32(rb.params, ParamFoodSpawnChance, 0),
|
||||
MinimumFood: paramsInt32(rb.params, ParamMinimumFood, 0),
|
||||
HazardDamagePerTurn: paramsInt32(rb.params, ParamHazardDamagePerTurn, 0),
|
||||
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{
|
||||
seed: rb.seed,
|
||||
ShrinkEveryNTurns: paramsInt32(rb.params, ParamShrinkEveryNTurns, 0),
|
||||
ShrinkEveryNTurns: paramsInt(rb.params, ParamShrinkEveryNTurns, 0),
|
||||
},
|
||||
SquadSettings: SquadSettings{
|
||||
squadMap: rb.squadMap(),
|
||||
|
|
@ -224,14 +224,14 @@ func paramsBool(params map[string]string, paramName string, defaultValue bool) b
|
|||
return defaultValue
|
||||
}
|
||||
|
||||
// paramsInt32 returns the int32 value for the specified parameter.
|
||||
// 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 paramsInt32(params map[string]string, paramName string, defaultValue int32) int32 {
|
||||
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 int32(i)
|
||||
return i
|
||||
}
|
||||
}
|
||||
return defaultValue
|
||||
|
|
|
|||
|
|
@ -10,11 +10,11 @@ import (
|
|||
_ "github.com/BattlesnakeOfficial/rules/test"
|
||||
)
|
||||
|
||||
func TestParamInt32(t *testing.T) {
|
||||
require.Equal(t, int32(5), paramsInt32(nil, "test", 5), "nil map")
|
||||
require.Equal(t, int32(10), paramsInt32(map[string]string{}, "foo", 10), "empty map")
|
||||
require.Equal(t, int32(10), paramsInt32(map[string]string{"hullo": "there"}, "hullo", 10), "invalid value")
|
||||
require.Equal(t, int32(20), paramsInt32(map[string]string{"bonjour": "20"}, "bonjour", 20), "valid value")
|
||||
func TestParamInt(t *testing.T) {
|
||||
require.Equal(t, 5, paramsInt(nil, "test", 5), "nil map")
|
||||
require.Equal(t, 10, paramsInt(map[string]string{}, "foo", 10), "empty map")
|
||||
require.Equal(t, 10, paramsInt(map[string]string{"hullo": "there"}, "hullo", 10), "invalid value")
|
||||
require.Equal(t, 20, paramsInt(map[string]string{"bonjour": "20"}, "bonjour", 20), "valid value")
|
||||
}
|
||||
|
||||
func TestParamBool(t *testing.T) {
|
||||
|
|
|
|||
|
|
@ -172,9 +172,9 @@ func TestRulesetBuilder(t *testing.T) {
|
|||
require.NotNil(t, rsb.Ruleset())
|
||||
require.Equal(t, expected.GameType, rsb.Ruleset().Name())
|
||||
// All the standard settings should always be copied over
|
||||
require.Equal(t, int32(10), rsb.Ruleset().Settings().FoodSpawnChance)
|
||||
require.Equal(t, int32(12), rsb.Ruleset().Settings().HazardDamagePerTurn)
|
||||
require.Equal(t, int32(5), rsb.Ruleset().Settings().MinimumFood)
|
||||
require.Equal(t, 10, rsb.Ruleset().Settings().FoodSpawnChance)
|
||||
require.Equal(t, 12, rsb.Ruleset().Settings().HazardDamagePerTurn)
|
||||
require.Equal(t, 5, rsb.Ruleset().Settings().MinimumFood)
|
||||
require.Equal(t, "test", rsb.Ruleset().Settings().HazardMap)
|
||||
require.Equal(t, "tester", rsb.Ruleset().Settings().HazardMapAuthor)
|
||||
})
|
||||
|
|
@ -194,7 +194,7 @@ func TestStageFuncContract(t *testing.T) {
|
|||
|
||||
func TestRulesetBuilderGetRand(t *testing.T) {
|
||||
var seed int64 = 12345
|
||||
var turn int32 = 5
|
||||
var turn int = 5
|
||||
ruleset := rules.NewRulesetBuilder().WithSeed(seed).PipelineRuleset("example", rules.NewPipeline(rules.StageGameOverStandard))
|
||||
|
||||
rand1 := ruleset.Settings().GetRand(turn)
|
||||
|
|
|
|||
|
|
@ -121,8 +121,8 @@ func TestSquadShareSquadHealth(t *testing.T) {
|
|||
testSnakes := []struct {
|
||||
SnakeID string
|
||||
SquadID string
|
||||
Health int32
|
||||
ExpectedHealth int32
|
||||
Health int
|
||||
ExpectedHealth int
|
||||
}{
|
||||
// Red Squad
|
||||
{"R1", "red", 11, 88},
|
||||
|
|
|
|||
12
standard.go
12
standard.go
|
|
@ -6,9 +6,9 @@ import (
|
|||
)
|
||||
|
||||
type StandardRuleset struct {
|
||||
FoodSpawnChance int32 // [0, 100]
|
||||
MinimumFood int32
|
||||
HazardDamagePerTurn int32
|
||||
FoodSpawnChance int // [0, 100]
|
||||
MinimumFood int
|
||||
HazardDamagePerTurn int
|
||||
HazardMap string // optional
|
||||
HazardMapAuthor string // optional
|
||||
}
|
||||
|
|
@ -318,7 +318,7 @@ func snakeIsOutOfHealth(s *Snake) bool {
|
|||
return s.Health <= 0
|
||||
}
|
||||
|
||||
func snakeIsOutOfBounds(s *Snake, boardWidth int32, boardHeight int32) bool {
|
||||
func snakeIsOutOfBounds(s *Snake, boardWidth int, boardHeight int) bool {
|
||||
for _, point := range s.Body {
|
||||
if (point.X < 0) || (point.X >= boardWidth) {
|
||||
return true
|
||||
|
|
@ -391,11 +391,11 @@ func SpawnFoodStandard(b *BoardState, settings Settings, moves []SnakeMove) (boo
|
|||
if IsInitialization(b, settings, moves) {
|
||||
return false, nil
|
||||
}
|
||||
numCurrentFood := int32(len(b.Food))
|
||||
numCurrentFood := int(len(b.Food))
|
||||
if numCurrentFood < settings.MinimumFood {
|
||||
return false, PlaceFoodRandomly(GlobalRand, b, settings.MinimumFood-numCurrentFood)
|
||||
}
|
||||
if settings.FoodSpawnChance > 0 && int32(rand.Intn(100)) < settings.FoodSpawnChance {
|
||||
if settings.FoodSpawnChance > 0 && int(rand.Intn(100)) < settings.FoodSpawnChance {
|
||||
return false, PlaceFoodRandomly(GlobalRand, b, 1)
|
||||
}
|
||||
return false, nil
|
||||
|
|
|
|||
|
|
@ -22,8 +22,8 @@ func TestSanity(t *testing.T) {
|
|||
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.Equal(t, 0, state.Width)
|
||||
require.Equal(t, 0, state.Height)
|
||||
require.Len(t, state.Food, 0)
|
||||
require.Len(t, state.Snakes, 0)
|
||||
|
||||
|
|
@ -33,8 +33,8 @@ func TestSanity(t *testing.T) {
|
|||
)
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, next)
|
||||
require.Equal(t, int32(0), state.Width)
|
||||
require.Equal(t, int32(0), state.Height)
|
||||
require.Equal(t, 0, state.Width)
|
||||
require.Equal(t, 0, state.Height)
|
||||
require.Len(t, state.Snakes, 0)
|
||||
}
|
||||
|
||||
|
|
@ -564,9 +564,9 @@ func TestMoveSnakes(t *testing.T) {
|
|||
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.Equal(t, 111111, b.Snakes[0].Health)
|
||||
require.Equal(t, 222222, b.Snakes[1].Health)
|
||||
require.Equal(t, 1, b.Snakes[2].Health)
|
||||
|
||||
require.Len(t, b.Snakes[0].Body, 2)
|
||||
require.Len(t, b.Snakes[1].Body, 4)
|
||||
|
|
@ -804,35 +804,35 @@ func TestReduceSnakeHealth(t *testing.T) {
|
|||
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))
|
||||
require.Equal(t, b.Snakes[0].Health, 98)
|
||||
require.Equal(t, b.Snakes[1].Health, 1)
|
||||
require.Equal(t, b.Snakes[2].Health, 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))
|
||||
require.Equal(t, b.Snakes[0].Health, 97)
|
||||
require.Equal(t, b.Snakes[1].Health, 0)
|
||||
require.Equal(t, b.Snakes[2].Health, 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))
|
||||
require.Equal(t, b.Snakes[0].Health, 96)
|
||||
require.Equal(t, b.Snakes[1].Health, -1)
|
||||
require.Equal(t, b.Snakes[2].Health, 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))
|
||||
require.Equal(t, b.Snakes[0].Health, 95)
|
||||
require.Equal(t, b.Snakes[1].Health, -2)
|
||||
require.Equal(t, b.Snakes[2].Health, 50)
|
||||
}
|
||||
|
||||
func TestSnakeIsOutOfHealth(t *testing.T) {
|
||||
tests := []struct {
|
||||
Health int32
|
||||
Health int
|
||||
Expected bool
|
||||
}{
|
||||
{Health: math.MinInt32, Expected: true},
|
||||
{Health: math.MinInt, Expected: true},
|
||||
{Health: -10, Expected: true},
|
||||
{Health: -2, Expected: true},
|
||||
{Health: -1, Expected: true},
|
||||
|
|
@ -840,7 +840,7 @@ func TestSnakeIsOutOfHealth(t *testing.T) {
|
|||
{Health: 1, Expected: false},
|
||||
{Health: 2, Expected: false},
|
||||
{Health: 10, Expected: false},
|
||||
{Health: math.MaxInt32, Expected: false},
|
||||
{Health: math.MaxInt, Expected: false},
|
||||
}
|
||||
|
||||
for _, test := range tests {
|
||||
|
|
@ -850,16 +850,16 @@ func TestSnakeIsOutOfHealth(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestSnakeIsOutOfBounds(t *testing.T) {
|
||||
boardWidth := int32(10)
|
||||
boardHeight := int32(100)
|
||||
boardWidth := 10
|
||||
boardHeight := 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: math.MinInt, Y: math.MinInt}, true},
|
||||
{Point{X: math.MinInt, Y: 0}, true},
|
||||
{Point{X: 0, Y: math.MinInt}, true},
|
||||
{Point{X: -1, Y: -1}, true},
|
||||
{Point{X: -1, Y: 0}, true},
|
||||
{Point{X: 0, Y: -1}, true},
|
||||
|
|
@ -876,12 +876,12 @@ func TestSnakeIsOutOfBounds(t *testing.T) {
|
|||
{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: math.MaxInt, 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},
|
||||
{Point{X: 9, Y: math.MaxInt}, true},
|
||||
{Point{X: math.MaxInt, Y: math.MaxInt}, true},
|
||||
}
|
||||
|
||||
for _, test := range tests {
|
||||
|
|
@ -1339,10 +1339,10 @@ func TestMaybeDamageHazards(t *testing.T) {
|
|||
|
||||
func TestHazardDamagePerTurn(t *testing.T) {
|
||||
tests := []struct {
|
||||
Health int32
|
||||
HazardDamagePerTurn int32
|
||||
Health int
|
||||
HazardDamagePerTurn int
|
||||
Food bool
|
||||
ExpectedHealth int32
|
||||
ExpectedHealth int
|
||||
ExpectedEliminationCause string
|
||||
Error error
|
||||
}{
|
||||
|
|
@ -1461,7 +1461,7 @@ func TestMaybeFeedSnakes(t *testing.T) {
|
|||
|
||||
func TestMaybeSpawnFoodMinimum(t *testing.T) {
|
||||
tests := []struct {
|
||||
MinimumFood int32
|
||||
MinimumFood int
|
||||
Food []Point
|
||||
ExpectedFood int
|
||||
}{
|
||||
|
|
@ -1530,7 +1530,7 @@ func TestMaybeSpawnFoodHalfChance(t *testing.T) {
|
|||
tests := []struct {
|
||||
Seed int64
|
||||
Food []Point
|
||||
ExpectedFood int32
|
||||
ExpectedFood int
|
||||
}{
|
||||
// Use pre-tested seeds and results
|
||||
{123, []Point{}, 1},
|
||||
|
|
@ -1556,7 +1556,7 @@ func TestMaybeSpawnFoodHalfChance(t *testing.T) {
|
|||
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)
|
||||
require.Equal(t, test.ExpectedFood, len(b.Food), "Seed %d", test.Seed)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -52,7 +52,7 @@ func (r *WrappedRuleset) IsGameOver(b *BoardState) (bool, error) {
|
|||
return GameOverStandard(b, r.Settings(), nil)
|
||||
}
|
||||
|
||||
func wrap(value, min, max int32) int32 {
|
||||
func wrap(value, min, max int) int {
|
||||
if value < min {
|
||||
return max
|
||||
}
|
||||
|
|
|
|||
|
|
@ -250,16 +250,16 @@ func TestEdgeCrossingEating(t *testing.T) {
|
|||
|
||||
func TestWrap(t *testing.T) {
|
||||
// no wrap
|
||||
assert.Equal(t, int32(0), wrap(0, 0, 0))
|
||||
assert.Equal(t, int32(0), wrap(0, 1, 0))
|
||||
assert.Equal(t, int32(0), wrap(0, 0, 1))
|
||||
assert.Equal(t, int32(1), wrap(1, 0, 1))
|
||||
assert.Equal(t, 0, wrap(0, 0, 0))
|
||||
assert.Equal(t, 0, wrap(0, 1, 0))
|
||||
assert.Equal(t, 0, wrap(0, 0, 1))
|
||||
assert.Equal(t, 1, wrap(1, 0, 1))
|
||||
|
||||
// wrap to min
|
||||
assert.Equal(t, int32(0), wrap(2, 0, 1))
|
||||
assert.Equal(t, 0, wrap(2, 0, 1))
|
||||
|
||||
// wrap to max
|
||||
assert.Equal(t, int32(1), wrap(-1, 0, 1))
|
||||
assert.Equal(t, 1, wrap(-1, 0, 1))
|
||||
}
|
||||
|
||||
// Checks that snakes moving out of bounds get wrapped to the other side.
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue