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

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)
}