Battlesnake/Byte-snake-engine
Battlesnake/Byte-snake-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rivers and Bridges map refactor (#103)

Browse source 
* Separated out rivers and bridges into its own file with three map variants

* fixing tags

* removed extra 4 starting positions from the medium map since it only supports 8 players

* update GetUnoccupiedPoints to consider hazards with a flag

* use new utility method to fine unoccupied points and enforce map sizes

* changed up casting to make IsAllowable() more usable
This commit is contained in:
Chris Hoefgen 2022-08-19 10:09:04 -07:00 • committed by GitHub
parent 7d769b01b6
commit f82cfe5309
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
10 changed files with 484 additions and 347 deletions
Download patch file Download diff file Expand all files Collapse all files

18
board.go
View file

@ -432,7 +432,7 @@ func PlaceFoodFixed(rand Rand, b *BoardState) error {
// Finally, always place 1 food in center of board for dramatic purposes
isCenterOccupied := true
unoccupiedPoints := GetUnoccupiedPoints(b, true)
unoccupiedPoints := GetUnoccupiedPoints(b, true, false)
for _, point := range unoccupiedPoints {
if point == centerCoord {
isCenterOccupied = false
@ -450,7 +450,7 @@ 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 int) error {
for i := 0; i < n; i++ {
unoccupiedPoints := GetUnoccupiedPoints(b, false)
unoccupiedPoints := GetUnoccupiedPoints(b, false, false)
if len(unoccupiedPoints) > 0 {
newFood := unoccupiedPoints[rand.Intn(len(unoccupiedPoints))]
b.Food = append(b.Food, newFood)
@ -468,7 +468,7 @@ func absInt(n int) int {
func GetEvenUnoccupiedPoints(b *BoardState) []Point {
// Start by getting unoccupied points
unoccupiedPoints := GetUnoccupiedPoints(b, true)
unoccupiedPoints := GetUnoccupiedPoints(b, true, false)
// Create a new array to hold points that are even
evenUnoccupiedPoints := []Point{}
@ -494,7 +494,7 @@ func removeCenterCoord(b *BoardState, points []Point) []Point {
return noCenterPoints
}
func GetUnoccupiedPoints(b *BoardState, includePossibleMoves bool) []Point {
func GetUnoccupiedPoints(b *BoardState, includePossibleMoves bool, includeHazards bool) []Point {
pointIsOccupied := map[int]map[int]bool{}
for _, p := range b.Food {
if _, xExists := pointIsOccupied[p.X]; !xExists {
@ -502,6 +502,7 @@ func GetUnoccupiedPoints(b *BoardState, includePossibleMoves bool) []Point {
}
pointIsOccupied[p.X][p.Y] = true
}
for _, snake := range b.Snakes {
if snake.EliminatedCause != NotEliminated {
continue
@ -529,6 +530,15 @@ func GetUnoccupiedPoints(b *BoardState, includePossibleMoves bool) []Point {
}
}
if includeHazards {
for _, p := range b.Hazards {
if _, xExists := pointIsOccupied[p.X]; !xExists {
pointIsOccupied[p.X] = map[int]bool{}
}
pointIsOccupied[p.X][p.Y] = true
}
}
unoccupiedPoints := []Point{}
for x := 0; x < b.Width; x++ {
for y := 0; y < b.Height; y++ {

33
board_test.go
View file

@ -254,7 +254,7 @@ 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, len(GetUnoccupiedPoints(test.BoardState, true)))
require.Equal(t, test.BoardState.Width*test.BoardState.Height, len(GetUnoccupiedPoints(test.BoardState, true, false)))
err := PlaceSnakesAutomatically(MaxRand, test.BoardState, test.SnakeIDs)
require.Equal(t, test.Err, err, "Snakes: %d", len(test.BoardState.Snakes))
if err == nil {
@ -769,10 +769,39 @@ func TestGetUnoccupiedPoints(t *testing.T) {
},
[]Point{{2, 1}},
},
{
&BoardState{
Height: 1,
Width: 1,
Hazards: []Point{{0, 0}},
},
[]Point{},
},
{
&BoardState{
Height: 2,
Width: 2,
Hazards: []Point{{1, 1}},
},
[]Point{{0, 0}, {0, 1}, {1, 0}},
},
{
&BoardState{
Height: 2,
Width: 3,
Food: []Point{{1, 1}, {2, 0}},
Snakes: []Snake{
{Body: []Point{{0, 0}, {1, 0}, {1, 1}}},
{Body: []Point{{0, 1}}},
},
Hazards: []Point{{0, 0}, {1, 0}},
},
[]Point{{2, 1}},
},
}
for _, test := range tests {
unoccupiedPoints := GetUnoccupiedPoints(test.Board, true)
unoccupiedPoints := GetUnoccupiedPoints(test.Board, true, true)
require.Equal(t, len(test.Expected), len(unoccupiedPoints))
for i, e := range test.Expected {
require.Equal(t, e, unoccupiedPoints[i])

14
maps/game_map.go
View file

@ -44,6 +44,20 @@ func (d sizes) IsUnlimited() bool {
return len(d) == 1 && d[0].Width == 0
}
func (d sizes) IsAllowable(Width int, Height int) bool {
if d.IsUnlimited() {
return true
}
for _, size := range d {
if size.Width == uint(Width) && size.Height == uint(Height) {
return true
}
}
return false
}
// AnySize creates sizes for a board that has no fixed sizes (supports unlimited sizes).
func AnySize() sizes {
return sizes{Dimensions{Width: 0, Height: 0}}

312
maps/hazards.go
View file

@ -12,7 +12,6 @@ func init() {
globalRegistry.RegisterMap("hz_inner_wall", InnerBorderHazardsMap{})
globalRegistry.RegisterMap("hz_rings", ConcentricRingsHazardsMap{})
globalRegistry.RegisterMap("hz_columns", ColumnsHazardsMap{})
globalRegistry.RegisterMap("hz_rivers_bridges", RiverAndBridgesHazardsMap{})
globalRegistry.RegisterMap("hz_spiral", SpiralHazardsMap{})
globalRegistry.RegisterMap("hz_scatter", ScatterFillMap{})
globalRegistry.RegisterMap("hz_grow_box", DirectionalExpandingBoxMap{})
@ -558,314 +557,3 @@ func (m ExpandingScatterMap) UpdateBoard(lastBoardState *rules.BoardState, setti
return nil
}
type RiverAndBridgesHazardsMap struct{}
func (m RiverAndBridgesHazardsMap) ID() string {
return "hz_rivers_bridges"
}
func (m RiverAndBridgesHazardsMap) Meta() Metadata {
return Metadata{
Name: "hz_rivers_bridges",
Description: `Creates fixed maps that have a lake of hazard in the middle with rivers going in the cardinal directions.
Each river has one or two 1-square "bridges" over them`,
Author: "Battlesnake",
Version: 1,
MinPlayers: 1,
MaxPlayers: 12,
BoardSizes: FixedSizes(Dimensions{11, 11}, Dimensions{19, 19}, Dimensions{25, 25}),
Tags: []string{TAG_HAZARD_PLACEMENT, TAG_SNAKE_PLACEMENT},
}
}
func (m RiverAndBridgesHazardsMap) SetupBoard(lastBoardState *rules.BoardState, settings rules.Settings, editor Editor) error {
width := lastBoardState.Width
height := lastBoardState.Height
hazards, ok := riversAndBridgesHazards[rules.Point{X: width, Y: height}]
if !ok {
return rules.RulesetError("board size is not supported by this map")
}
startPositions, ok := riversAndBridgesStartPositions[rules.Point{X: width, Y: height}]
if !ok {
return rules.RulesetError("board size is not supported by this map")
}
numSnakes := len(lastBoardState.Snakes)
if numSnakes == 0 {
return rules.RulesetError("too few snakes - at least one snake must be present")
}
rand := settings.GetRand(0)
snakeIDs := make([]string, 0, len(lastBoardState.Snakes))
for _, snake := range lastBoardState.Snakes {
snakeIDs = append(snakeIDs, snake.ID)
}
tempBoardState := rules.NewBoardState(width, height)
tempBoardState.Snakes = make([]rules.Snake, len(snakeIDs))
for i := 0; i < len(snakeIDs); i++ {
tempBoardState.Snakes[i] = rules.Snake{
ID: snakeIDs[i],
Health: rules.SnakeMaxHealth,
}
}
err := rules.PlaceSnakesInQuadrants(rand, tempBoardState, startPositions)
if err != nil {
return err
}
err = rules.PlaceFoodFixed(rand, tempBoardState)
if err != nil {
return err
}
// Copy food from temp board state
for _, f := range tempBoardState.Food {
// skip the center food
if f.X == lastBoardState.Width/2 && f.Y == lastBoardState.Height/2 {
continue
}
editor.AddFood(f)
}
// Copy snakes from temp board state
for _, snake := range tempBoardState.Snakes {
editor.PlaceSnake(snake.ID, snake.Body, snake.Health)
}
for _, p := range hazards {
editor.AddHazard(p)
}
return nil
}
func (m RiverAndBridgesHazardsMap) UpdateBoard(lastBoardState *rules.BoardState, settings rules.Settings, editor Editor) error {
rand := settings.GetRand(lastBoardState.Turn)
foodNeeded := checkFoodNeedingPlacement(rand, settings, lastBoardState)
if foodNeeded > 0 {
pts := m.getUnoccupiedPoints(lastBoardState)
placeFoodRandomlyAtPositions(rand, lastBoardState, editor, foodNeeded, pts)
}
return nil
}
func (m RiverAndBridgesHazardsMap) getUnoccupiedPoints(lastBoardState *rules.BoardState) []rules.Point {
unoccupiedPoints := rules.GetUnoccupiedPoints(lastBoardState, false)
var totallyUnoccupiedPoints []rules.Point
// we want to avoid placing food on hazards in this map
for _, p := range unoccupiedPoints {
isHazard := false
for _, h := range lastBoardState.Hazards {
if p == h {
isHazard = true
break
}
}
if !isHazard {
totallyUnoccupiedPoints = append(totallyUnoccupiedPoints, p)
}
}
return totallyUnoccupiedPoints
}
var riversAndBridgesStartPositions = map[rules.Point][][]rules.Point{
{X: 11, Y: 11}: {
{
{X: 1, Y: 1},
{X: 3, Y: 3},
{X: 1, Y: 3},
},
{
{X: 9, Y: 9},
{X: 7, Y: 7},
{X: 9, Y: 7},
},
{
{X: 1, Y: 9},
{X: 3, Y: 7},
{X: 3, Y: 9},
},
{
{X: 9, Y: 3},
{X: 9, Y: 1},
{X: 7, Y: 3},
},
},
{X: 19, Y: 19}: {
{
{X: 1, Y: 1},
{X: 5, Y: 1},
{X: 1, Y: 5},
{X: 5, Y: 5},
},
{
{X: 17, Y: 1},
{X: 17, Y: 5},
{X: 13, Y: 5},
{X: 13, Y: 1},
},
{
{X: 1, Y: 17},
{X: 5, Y: 17},
{X: 1, Y: 13},
{X: 5, Y: 13},
},
{
{X: 17, Y: 17},
{X: 17, Y: 13},
{X: 13, Y: 17},
{X: 13, Y: 13},
},
},
{X: 25, Y: 25}: {
{
{X: 1, Y: 1},
{X: 9, Y: 9},
{X: 9, Y: 1},
{X: 1, Y: 9},
},
{
{X: 23, Y: 23},
{X: 15, Y: 15},
{X: 23, Y: 15},
{X: 15, Y: 23},
},
{
{X: 15, Y: 1},
{X: 15, Y: 9},
{X: 23, Y: 9},
{X: 23, Y: 1},
},
{
{X: 9, Y: 23},
{X: 1, Y: 23},
{X: 9, Y: 15},
{X: 1, Y: 15},
},
},
}
var riversAndBridgesHazards = map[rules.Point][]rules.Point{
{X: 11, Y: 11}: {
{X: 5, Y: 10},
{X: 5, Y: 9},
{X: 5, Y: 7},
{X: 5, Y: 6},
{X: 5, Y: 5},
{X: 5, Y: 4},
{X: 5, Y: 3},
{X: 5, Y: 0},
{X: 5, Y: 1},
{X: 6, Y: 5},
{X: 7, Y: 5},
{X: 9, Y: 5},
{X: 10, Y: 5},
{X: 4, Y: 5},
{X: 3, Y: 5},
{X: 1, Y: 5},
{X: 0, Y: 5},
},
{X: 19, Y: 19}: {
{X: 9, Y: 0},
{X: 9, Y: 1},
{X: 9, Y: 2},
{X: 9, Y: 5},
{X: 9, Y: 6},
{X: 9, Y: 7},
{X: 9, Y: 9},
{X: 9, Y: 8},
{X: 9, Y: 10},
{X: 9, Y: 12},
{X: 9, Y: 11},
{X: 9, Y: 13},
{X: 9, Y: 14},
{X: 9, Y: 16},
{X: 9, Y: 17},
{X: 9, Y: 18},
{X: 0, Y: 9},
{X: 2, Y: 9},
{X: 1, Y: 9},
{X: 3, Y: 9},
{X: 5, Y: 9},
{X: 6, Y: 9},
{X: 7, Y: 9},
{X: 8, Y: 9},
{X: 10, Y: 9},
{X: 13, Y: 9},
{X: 12, Y: 9},
{X: 11, Y: 9},
{X: 15, Y: 9},
{X: 16, Y: 9},
{X: 17, Y: 9},
{X: 18, Y: 9},
{X: 9, Y: 4},
{X: 8, Y: 10},
{X: 8, Y: 8},
{X: 10, Y: 8},
{X: 10, Y: 10},
},
{X: 25, Y: 25}: {
{X: 12, Y: 24},
{X: 12, Y: 21},
{X: 12, Y: 20},
{X: 12, Y: 19},
{X: 12, Y: 18},
{X: 12, Y: 15},
{X: 12, Y: 14},
{X: 12, Y: 13},
{X: 12, Y: 12},
{X: 12, Y: 11},
{X: 12, Y: 10},
{X: 12, Y: 9},
{X: 12, Y: 5},
{X: 12, Y: 4},
{X: 12, Y: 3},
{X: 12, Y: 0},
{X: 0, Y: 12},
{X: 3, Y: 12},
{X: 4, Y: 12},
{X: 5, Y: 12},
{X: 6, Y: 12},
{X: 9, Y: 12},
{X: 10, Y: 12},
{X: 11, Y: 12},
{X: 13, Y: 12},
{X: 14, Y: 12},
{X: 15, Y: 12},
{X: 18, Y: 12},
{X: 20, Y: 12},
{X: 19, Y: 12},
{X: 21, Y: 12},
{X: 24, Y: 12},
{X: 11, Y: 14},
{X: 10, Y: 13},
{X: 11, Y: 13},
{X: 10, Y: 11},
{X: 11, Y: 11},
{X: 11, Y: 10},
{X: 13, Y: 10},
{X: 14, Y: 11},
{X: 13, Y: 11},
{X: 13, Y: 13},
{X: 14, Y: 13},
{X: 13, Y: 14},
{X: 12, Y: 6},
{X: 12, Y: 2},
{X: 2, Y: 12},
{X: 22, Y: 12},
{X: 12, Y: 22},
{X: 16, Y: 12},
{X: 12, Y: 8},
{X: 8, Y: 12},
{X: 12, Y: 16},
},
}

23
maps/hazards_test.go
View file

@ -89,29 +89,6 @@ func TestColumnsHazardsMap(t *testing.T) {
require.NotContains(t, state.Hazards, rules.Point{X: 1, Y: 0})
}
func TestRiversAndBridgetsHazardsMap(t *testing.T) {
// check error handling
m := maps.RiverAndBridgesHazardsMap{}
settings := rules.Settings{}
// check error for unsupported board sizes
state := rules.NewBoardState(9, 9)
editor := maps.NewBoardStateEditor(state)
err := m.SetupBoard(state, settings, editor)
require.Error(t, err)
// check all the supported sizes
for _, size := range []int{11, 19, 25} {
state = rules.NewBoardState(size, size)
state.Snakes = append(state.Snakes, rules.Snake{ID: "1", Body: []rules.Point{}})
editor = maps.NewBoardStateEditor(state)
require.Empty(t, state.Hazards)
err = m.SetupBoard(state, settings, editor)
require.NoError(t, err)
require.NotEmpty(t, state.Hazards)
}
}
func TestSpiralHazardsMap(t *testing.T) {
// check error handling
m := maps.SpiralHazardsMap{}

4
maps/registry_test.go
View file

@ -60,8 +60,8 @@ func TestRegisteredMaps(t *testing.T) {
}
// Check that at least one map size can be setup without error
for width := 0; width < maxBoardWidth; width++ {
for height := 0; height < maxBoardHeight; height++ {
for width := 0; width <= maxBoardWidth; width++ {
for height := 0; height <= maxBoardHeight; height++ {
initialBoardState := rules.NewBoardState(width, height)
initialBoardState.Snakes = append(initialBoardState.Snakes, rules.Snake{ID: "1", Body: []rules.Point{}})
if meta.MaxPlayers > 1 {

376
maps/rivers_and_bridges.go Normal file
View file

@ -0,0 +1,376 @@
package maps
import (
"github.com/BattlesnakeOfficial/rules"
)
func init() {
globalRegistry.RegisterMap("hz_rivers_bridges", RiverAndBridgesMediumHazardsMap{})
globalRegistry.RegisterMap("hz_rivers_bridges_lg", RiverAndBridgesLargeHazardsMap{})
globalRegistry.RegisterMap("hz_rivers_bridges_xl", RiverAndBridgesExtraLargeHazardsMap{})
}
func setupRiverAndBridgesBoard(startingPositions [][]rules.Point, hazards []rules.Point, lastBoardState *rules.BoardState, settings rules.Settings, editor Editor) error {
width := lastBoardState.Width
height := lastBoardState.Height
numSnakes := len(lastBoardState.Snakes)
if numSnakes == 0 {
return rules.RulesetError("too few snakes - at least one snake must be present")
}
rand := settings.GetRand(0)
snakeIDs := make([]string, 0, len(lastBoardState.Snakes))
for _, snake := range lastBoardState.Snakes {
snakeIDs = append(snakeIDs, snake.ID)
}
tempBoardState := rules.NewBoardState(width, height)
tempBoardState.Snakes = make([]rules.Snake, len(snakeIDs))
for i := 0; i < len(snakeIDs); i++ {
tempBoardState.Snakes[i] = rules.Snake{
ID: snakeIDs[i],
Health: rules.SnakeMaxHealth,
}
}
err := rules.PlaceSnakesInQuadrants(rand, tempBoardState, startingPositions)
if err != nil {
return err
}
err = rules.PlaceFoodFixed(rand, tempBoardState)
if err != nil {
return err
}
// Copy food from temp board state
for _, f := range tempBoardState.Food {
// skip the center food
if f.X == lastBoardState.Width/2 && f.Y == lastBoardState.Height/2 {
continue
}
editor.AddFood(f)
}
// Copy snakes from temp board state
for _, snake := range tempBoardState.Snakes {
editor.PlaceSnake(snake.ID, snake.Body, snake.Health)
}
for _, p := range hazards {
editor.AddHazard(p)
}
return nil
}
func placeRiverAndBridgesFood(lastBoardState *rules.BoardState, settings rules.Settings, editor Editor) error {
rand := settings.GetRand(lastBoardState.Turn)
foodNeeded := checkFoodNeedingPlacement(rand, settings, lastBoardState)
if foodNeeded > 0 {
pts := rules.GetUnoccupiedPoints(lastBoardState, false, true)
placeFoodRandomlyAtPositions(rand, lastBoardState, editor, foodNeeded, pts)
}
return nil
}
type RiverAndBridgesMediumHazardsMap struct{}
func (m RiverAndBridgesMediumHazardsMap) ID() string {
return "hz_rivers_bridges"
}
func (m RiverAndBridgesMediumHazardsMap) Meta() Metadata {
return Metadata{
Name: "hz_rivers_bridges",
Description: `Creates fixed maps that have a lake of hazard in the middle with rivers going in the cardinal directions.
Each river has one or two 1-square "bridges" over them`,
Author: "Battlesnake",
Version: 1,
MinPlayers: 1,
MaxPlayers: 8,
BoardSizes: FixedSizes(Dimensions{11, 11}),
Tags: []string{TAG_FOOD_PLACEMENT, TAG_HAZARD_PLACEMENT, TAG_SNAKE_PLACEMENT},
}
}
func (m RiverAndBridgesMediumHazardsMap) SetupBoard(lastBoardState *rules.BoardState, settings rules.Settings, editor Editor) error {
if !m.Meta().BoardSizes.IsAllowable(lastBoardState.Width, lastBoardState.Height) {
return rules.RulesetError("This map can only be played on a 11x11 board")
}
err := setupRiverAndBridgesBoard(riversAndBridgesMediumStartPositions, riversAndBridgesMediumHazards, lastBoardState, settings, editor)
if err != nil {
return err
}
return nil
}
func (m RiverAndBridgesMediumHazardsMap) UpdateBoard(lastBoardState *rules.BoardState, settings rules.Settings, editor Editor) error {
return placeRiverAndBridgesFood(lastBoardState, settings, editor)
}
var riversAndBridgesMediumStartPositions = [][]rules.Point{
{
{X: 1, Y: 1},
{X: 3, Y: 3},
},
{
{X: 9, Y: 9},
{X: 7, Y: 7},
},
{
{X: 1, Y: 9},
{X: 3, Y: 9},
},
{
{X: 9, Y: 1},
{X: 7, Y: 3},
},
}
var riversAndBridgesMediumHazards = []rules.Point{
{X: 5, Y: 10},
{X: 5, Y: 9},
{X: 5, Y: 7},
{X: 5, Y: 6},
{X: 5, Y: 5},
{X: 5, Y: 4},
{X: 5, Y: 3},
{X: 5, Y: 0},
{X: 5, Y: 1},
{X: 6, Y: 5},
{X: 7, Y: 5},
{X: 9, Y: 5},
{X: 10, Y: 5},
{X: 4, Y: 5},
{X: 3, Y: 5},
{X: 1, Y: 5},
{X: 0, Y: 5},
}
type RiverAndBridgesLargeHazardsMap struct{}
func (m RiverAndBridgesLargeHazardsMap) ID() string {
return "hz_rivers_bridges_lg"
}
func (m RiverAndBridgesLargeHazardsMap) Meta() Metadata {
return Metadata{
Name: "hz_rivers_bridges_lg",
Description: `Creates fixed maps that have a lake of hazard in the middle with rivers going in the cardinal directions.
Each river has one or two 1-square "bridges" over them`,
Author: "Battlesnake",
Version: 1,
MinPlayers: 1,
MaxPlayers: 12,
BoardSizes: FixedSizes(Dimensions{19, 19}),
Tags: []string{TAG_FOOD_PLACEMENT, TAG_HAZARD_PLACEMENT, TAG_SNAKE_PLACEMENT},
}
}
func (m RiverAndBridgesLargeHazardsMap) SetupBoard(lastBoardState *rules.BoardState, settings rules.Settings, editor Editor) error {
if !m.Meta().BoardSizes.IsAllowable(lastBoardState.Width, lastBoardState.Height) {
return rules.RulesetError("This map can only be played on a 19x19 board")
}
err := setupRiverAndBridgesBoard(riversAndBridgesLargeStartPositions, riversAndBridgesLargeHazards, lastBoardState, settings, editor)
if err != nil {
return err
}
return nil
}
func (m RiverAndBridgesLargeHazardsMap) UpdateBoard(lastBoardState *rules.BoardState, settings rules.Settings, editor Editor) error {
return placeRiverAndBridgesFood(lastBoardState, settings, editor)
}
var riversAndBridgesLargeStartPositions = [][]rules.Point{
{
{X: 1, Y: 1},
{X: 5, Y: 1},
{X: 1, Y: 5},
{X: 5, Y: 5},
},
{
{X: 17, Y: 1},
{X: 17, Y: 5},
{X: 13, Y: 5},
{X: 13, Y: 1},
},
{
{X: 1, Y: 17},
{X: 5, Y: 17},
{X: 1, Y: 13},
{X: 5, Y: 13},
},
{
{X: 17, Y: 17},
{X: 17, Y: 13},
{X: 13, Y: 17},
{X: 13, Y: 13},
},
}
var riversAndBridgesLargeHazards = []rules.Point{
{X: 9, Y: 0},
{X: 9, Y: 1},
{X: 9, Y: 2},
{X: 9, Y: 5},
{X: 9, Y: 6},
{X: 9, Y: 7},
{X: 9, Y: 9},
{X: 9, Y: 8},
{X: 9, Y: 10},
{X: 9, Y: 12},
{X: 9, Y: 11},
{X: 9, Y: 13},
{X: 9, Y: 14},
{X: 9, Y: 16},
{X: 9, Y: 17},
{X: 9, Y: 18},
{X: 0, Y: 9},
{X: 2, Y: 9},
{X: 1, Y: 9},
{X: 3, Y: 9},
{X: 5, Y: 9},
{X: 6, Y: 9},
{X: 7, Y: 9},
{X: 8, Y: 9},
{X: 10, Y: 9},
{X: 13, Y: 9},
{X: 12, Y: 9},
{X: 11, Y: 9},
{X: 15, Y: 9},
{X: 16, Y: 9},
{X: 17, Y: 9},
{X: 18, Y: 9},
{X: 9, Y: 4},
{X: 8, Y: 10},
{X: 8, Y: 8},
{X: 10, Y: 8},
{X: 10, Y: 10},
}
type RiverAndBridgesExtraLargeHazardsMap struct{}
func (m RiverAndBridgesExtraLargeHazardsMap) ID() string {
return "hz_rivers_bridges_xl"
}
func (m RiverAndBridgesExtraLargeHazardsMap) Meta() Metadata {
return Metadata{
Name: "hz_rivers_bridges_xl",
Description: `Creates fixed maps that have a lake of hazard in the middle with rivers going in the cardinal directions.
Each river has one or two 1-square "bridges" over them`,
Author: "Battlesnake",
Version: 1,
MinPlayers: 1,
MaxPlayers: 12,
BoardSizes: FixedSizes(Dimensions{25, 25}),
Tags: []string{TAG_FOOD_PLACEMENT, TAG_HAZARD_PLACEMENT, TAG_SNAKE_PLACEMENT},
}
}
func (m RiverAndBridgesExtraLargeHazardsMap) SetupBoard(lastBoardState *rules.BoardState, settings rules.Settings, editor Editor) error {
if !m.Meta().BoardSizes.IsAllowable(lastBoardState.Width, lastBoardState.Height) {
return rules.RulesetError("This map can only be played on a 25x25 board")
}
err := setupRiverAndBridgesBoard(riversAndBridgesExtraLargeStartPositions, riversAndBridgesExtraLargeHazards, lastBoardState, settings, editor)
if err != nil {
return err
}
return nil
}
func (m RiverAndBridgesExtraLargeHazardsMap) UpdateBoard(lastBoardState *rules.BoardState, settings rules.Settings, editor Editor) error {
return placeRiverAndBridgesFood(lastBoardState, settings, editor)
}
var riversAndBridgesExtraLargeStartPositions = [][]rules.Point{
{
{X: 1, Y: 1},
{X: 9, Y: 9},
{X: 9, Y: 1},
{X: 1, Y: 9},
},
{
{X: 23, Y: 23},
{X: 15, Y: 15},
{X: 23, Y: 15},
{X: 15, Y: 23},
},
{
{X: 15, Y: 1},
{X: 15, Y: 9},
{X: 23, Y: 9},
{X: 23, Y: 1},
},
{
{X: 9, Y: 23},
{X: 1, Y: 23},
{X: 9, Y: 15},
{X: 1, Y: 15},
},
}
var riversAndBridgesExtraLargeHazards = []rules.Point{
{X: 12, Y: 24},
{X: 12, Y: 21},
{X: 12, Y: 20},
{X: 12, Y: 19},
{X: 12, Y: 18},
{X: 12, Y: 15},
{X: 12, Y: 14},
{X: 12, Y: 13},
{X: 12, Y: 12},
{X: 12, Y: 11},
{X: 12, Y: 10},
{X: 12, Y: 9},
{X: 12, Y: 5},
{X: 12, Y: 4},
{X: 12, Y: 3},
{X: 12, Y: 0},
{X: 0, Y: 12},
{X: 3, Y: 12},
{X: 4, Y: 12},
{X: 5, Y: 12},
{X: 6, Y: 12},
{X: 9, Y: 12},
{X: 10, Y: 12},
{X: 11, Y: 12},
{X: 13, Y: 12},
{X: 14, Y: 12},
{X: 15, Y: 12},
{X: 18, Y: 12},
{X: 20, Y: 12},
{X: 19, Y: 12},
{X: 21, Y: 12},
{X: 24, Y: 12},
{X: 11, Y: 14},
{X: 10, Y: 13},
{X: 11, Y: 13},
{X: 10, Y: 11},
{X: 11, Y: 11},
{X: 11, Y: 10},
{X: 13, Y: 10},
{X: 14, Y: 11},
{X: 13, Y: 11},
{X: 13, Y: 13},
{X: 14, Y: 13},
{X: 13, Y: 14},
{X: 12, Y: 6},
{X: 12, Y: 2},
{X: 2, Y: 12},
{X: 22, Y: 12},
{X: 12, Y: 22},
{X: 16, Y: 12},
{X: 12, Y: 8},
{X: 8, Y: 12},
{X: 12, Y: 16},
}

7
maps/hazards_internal_test.go → maps/rivers_and_bridges_internal_test.go
View file

@ -5,17 +5,18 @@ import (
"testing"
"github.com/BattlesnakeOfficial/rules"
"github.com/stretchr/testify/require"
)
func TestRiversAndBridgesSnakePlacement(t *testing.T) {
m := RiverAndBridgesHazardsMap{}
m := RiverAndBridgesMediumHazardsMap{}
settings := rules.Settings{}
// check all the supported sizes
for _, size := range []int{11, 19, 25} {
for _, size := range []int{11} {
initialState := rules.NewBoardState(size, size)
startPositions := riversAndBridgesStartPositions[rules.Point{X: size, Y: size}]
startPositions := riversAndBridgesMediumStartPositions
maxSnakes := len(startPositions)
for i := 0; i < maxSnakes; i++ {
initialState.Snakes = append(initialState.Snakes, rules.Snake{ID: fmt.Sprint(i), Body: []rules.Point{}})

42
maps/rivers_and_bridges_test.go Normal file
View file

@ -0,0 +1,42 @@
package maps_test
import (
"testing"
"github.com/BattlesnakeOfficial/rules"
"github.com/BattlesnakeOfficial/rules/maps"
"github.com/stretchr/testify/require"
)
func TestRiversAndBridgetsHazardsMap(t *testing.T) {
// check error handling
m := maps.RiverAndBridgesMediumHazardsMap{}
settings := rules.Settings{}
// check error for unsupported board sizes
state := rules.NewBoardState(9, 9)
editor := maps.NewBoardStateEditor(state)
err := m.SetupBoard(state, settings, editor)
require.Error(t, err)
tests := []struct {
Map maps.GameMap
Width uint
Height uint
}{
{maps.RiverAndBridgesMediumHazardsMap{}, 11, 11},
{maps.RiverAndBridgesLargeHazardsMap{}, 19, 19},
{maps.RiverAndBridgesExtraLargeHazardsMap{}, 25, 25},
}
// check all the supported sizes
for _, test := range tests {
state = rules.NewBoardState(int(test.Width), int(test.Height))
state.Snakes = append(state.Snakes, rules.Snake{ID: "1", Body: []rules.Point{}})
editor = maps.NewBoardStateEditor(state)
require.Empty(t, state.Hazards)
err = test.Map.SetupBoard(state, settings, editor)
require.NoError(t, err)
require.NotEmpty(t, state.Hazards)
}
}

2
maps/standard.go
View file

@ -84,7 +84,7 @@ func checkFoodNeedingPlacement(rand rules.Rand, settings rules.Settings, state *
}
func placeFoodRandomly(rand rules.Rand, b *rules.BoardState, editor Editor, n int) {
unoccupiedPoints := rules.GetUnoccupiedPoints(b, false)
unoccupiedPoints := rules.GetUnoccupiedPoints(b, false, false)
placeFoodRandomlyAtPositions(rand, b, editor, n, unoccupiedPoints)
}