Avoid colliding with stronger snakes

Author: bethanyj28

internal/battle/simple/simple.go

@@ -43,14 +43,20 @@ func (s *Snake) Move(state internal.GameState) (internal.Action, error) {
 	// Avoid hazards if possible
 	avoidHazards := util.AvoidHazards(state.Board, state.You.Head)
 	avoidHazardsPriorityMap := map[string]int{}
-
 	for _, dir := range avoidHazards {
 		avoidHazardsPriorityMap[dir] = 2
 	}
 
+	// avoid collisions with stronk snakes
+	avoidCollisions := util.AvoidCollisions(state.You, state.Board.Snakes)
+	avoidCollisionsPriorityMap := map[string]int{}
+	for _, dir := range avoidCollisions {
+		avoidCollisionsPriorityMap[dir] = 3
+	}
+
 	avoidSelfPriorityMap := util.MoveAwayFromSelf(state.You)
 
-	return internal.Action{Move: findOptimal(possibleDirections, foodPriorityMap, avoidSelfPriorityMap, avoidHazardsPriorityMap)}, nil
+	return internal.Action{Move: findOptimal(possibleDirections, foodPriorityMap, avoidSelfPriorityMap, avoidHazardsPriorityMap, avoidCollisionsPriorityMap)}, nil
 }
 
 // Info returns the style info for a simple snake

internal/battle/util/util.go

@@ -1,6 +1,7 @@
 package util
 
 import (
+	"fmt"
 	"math"
 
 	"github.com/bethanyj28/battlesnek/internal"
@@ -105,6 +106,26 @@ func MoveAwayFromSelf(self internal.Battlesnake) map[string]int {
 	return distMap
 }
 
+// AvoidCollisions returns moves that avoid collisions with stronger snakes
+func AvoidCollisions(self internal.Battlesnake, others []internal.Battlesnake) []string {
+	otherPosCoords := []internal.Coord{}
+	for _, snake := range others {
+		if snake.ID == self.ID {
+			continue
+		}
+
+		if snake.Length < self.Length {
+			continue
+		}
+
+		otherPosCoords = append(otherPosCoords, potentialPositionsSlice(snake.Head)...)
+	}
+
+	fmt.Println(otherPosCoords)
+
+	return decideDir(potentialPositions(self.Head), convertCoordsToGrid(otherPosCoords))
+}
+
 func averagePositions(coords []internal.Coord) internal.Coord {
 	sumX := 0
 	sumY := 0
@@ -142,6 +163,15 @@ func convertCoordsToGrid(coords []internal.Coord) matrix {
 	return grid
 }
 
+func potentialPositionsSlice(head internal.Coord) []internal.Coord {
+	positions := []internal.Coord{}
+	for _, pos := range potentialPositions(head) {
+		positions = append(positions, pos)
+	}
+
+	return positions
+}
+
 func decideDir(potential choices, avoid matrix) []string {
 	options := []string{}
 

internal/battle/util/util_test.go

@@ -213,3 +213,118 @@ func TestFindFood(t *testing.T) {
 		})
 	}
 }
+
+// 30 31 32 33 34
+// 20 21 22 23 24
+// 10 11 12 13 14
+// 00 01 02 03 04
+
+func TestAvoidCollisions(t *testing.T) {
+	type testcase struct {
+		name        string
+		inputSelf   internal.Battlesnake
+		inputOthers []internal.Battlesnake
+		expected    []string
+	}
+
+	testcases := []testcase{
+		{
+			name: "other snake longer",
+			inputSelf: internal.Battlesnake{
+				ID:   "me",
+				Head: internal.Coord{X: 0, Y: 1},
+				Body: []internal.Coord{
+					{X: 0, Y: 1},
+					{X: 0, Y: 2},
+					{X: 0, Y: 3},
+				},
+				Length: 3,
+			},
+			inputOthers: []internal.Battlesnake{
+				{
+					ID:   "other1",
+					Head: internal.Coord{X: 1, Y: 0},
+					Body: []internal.Coord{
+						{X: 1, Y: 0},
+						{X: 2, Y: 0},
+						{X: 3, Y: 0},
+						{X: 4, Y: 0},
+						{X: 5, Y: 0},
+					},
+					Length: 5,
+				},
+			},
+			expected: []string{"left", "up"},
+		},
+		{
+			name: "other snake shorter",
+			inputSelf: internal.Battlesnake{
+				ID:   "me",
+				Head: internal.Coord{X: 0, Y: 1},
+				Body: []internal.Coord{
+					{X: 0, Y: 0},
+					{X: 0, Y: 1},
+					{X: 0, Y: 2},
+				},
+				Length: 3,
+			},
+			inputOthers: []internal.Battlesnake{
+				{
+					ID:   "other1",
+					Head: internal.Coord{X: 1, Y: 0},
+					Body: []internal.Coord{
+						{X: 1, Y: 0},
+						{X: 2, Y: 0},
+					},
+					Length: 2,
+				},
+			},
+			expected: []string{"down", "left", "right", "up"},
+		},
+		{
+			name: "multiple snakes",
+			inputSelf: internal.Battlesnake{
+				ID:   "me",
+				Head: internal.Coord{X: 3, Y: 1},
+				Body: []internal.Coord{
+					{X: 3, Y: 3},
+					{X: 3, Y: 2},
+					{X: 3, Y: 1},
+				},
+				Length: 3,
+			},
+			inputOthers: []internal.Battlesnake{
+				{
+					ID:   "other1",
+					Head: internal.Coord{X: 2, Y: 0},
+					Body: []internal.Coord{
+						{X: 2, Y: 0},
+						{X: 1, Y: 0},
+						{X: 0, Y: 0},
+					},
+					Length: 3,
+				},
+				{
+					ID:   "other2",
+					Head: internal.Coord{X: 5, Y: 1},
+					Body: []internal.Coord{
+						{X: 5, Y: 1},
+						{X: 6, Y: 1},
+						{X: 7, Y: 1},
+					},
+					Length: 3,
+				},
+			},
+			expected: []string{"up"},
+		},
+	}
+
+	for _, tc := range testcases {
+		t.Run(tc.name, func(t *testing.T) {
+			is := is.New(t)
+			actual := AvoidCollisions(tc.inputSelf, tc.inputOthers)
+			sort.Strings(actual)
+			is.Equal(actual, tc.expected)
+		})
+	}
+}