Rip

a_star_search_test.py

@@ -0,0 +1,135 @@
+game = {
+  "game": {
+    "id": "totally-unique-game-id",
+    "ruleset": {
+      "name": "standard",
+      "version": "v1.1.15",
+      "settings": {
+        "foodSpawnChance": 15,
+        "minimumFood": 1,
+        "hazardDamagePerTurn": 14
+      }
+    },
+    "map": "standard",
+    "source": "league",
+    "timeout": 500
+  },
+  "turn": 14,
+  "board": {
+    "height": 11,
+    "width": 11,
+    "food": [
+      {"x": 2, "y": 0},
+      {"x": 1, "y": 9},
+      {"x": 4, "y": 6}
+    ],
+    "hazards": [
+      {"x": 3, "y": 2}
+    ],
+    "snakes": [
+      {
+        "id": "snake-508e96ac-94ad-11ea-bb37",
+        "name": "My Snake",
+        "health": 54,
+        "body": [
+          {"x": 5, "y": 4},
+          {"x": 5, "y": 5},
+          {"x": 5, "y": 6},
+          {"x": 5, "y": 7},
+          {"x": 5, "y": 8},
+          {"x": 5, "y": 9},
+          {"x": 5, "y": 10},
+          # {"x": 5, "y": 7},
+          # {"x": 5, "y": 8},
+          # {"x": 4, "y": 9}
+        ],
+        "latency": "111",
+        "head": {"x": 0, "y": 0},
+        "length": 3,
+        "shout": "why are we shouting??",
+        "customizations":{
+          "color":"#FF0000",
+          "head":"pixel",
+          "tail":"pixel"
+        }
+      },
+      # {
+      #   "id": "snake-b67f4906-94ae-11ea-bb37",
+      #   "name": "Another Snake",
+      #   "health": 16,
+      #   "body": [
+      #     {"x": 5, "y": 4},
+      #     {"x": 5, "y": 3},
+      #     {"x": 6, "y": 3},
+      #     {"x": 6, "y": 2}
+      #   ],
+      #   "latency": "222",
+      #   "head": {"x": 5, "y": 4},
+      #   "length": 4,
+      #   "shout": "I'm not really sure...",
+      #   "customizations":{
+      #     "color":"#26CF04",
+      #     "head":"silly",
+      #     "tail":"curled"
+      #   }
+      # }
+    ]
+  },
+  "you": {
+    "id": "snake-508e96ac-94ad-11ea-bb37",
+    "name": "My Snake",
+    "health": 54,
+    "body": [
+      {"x": 1, "y": 0},
+      {"x": 1, "y": 1},
+      {"x": 1, "y": 2},
+      {"x": 1, "y": 3},
+      {"x": 1, "y": 4},
+      {"x": 2, "y": 4},
+      {"x": 3, "y": 4},
+      {"x": 4, "y": 4},
+      {"x": 4, "y": 3},
+      {"x": 4, "y": 2},
+      {"x": 4, "y": 1},
+      {"x": 5, "y": 1},
+      {"x": 5, "y": 0},
+      {"x": 6, "y": 0},
+    ],
+    "latency": "111",
+    "head": {"x": 1, "y": 0},
+    "length": 3,
+    "shout": "why are we shouting??",
+    "customizations": {
+      "color":"#FF0000",
+      "head":"pixel",
+      "tail":"pixel"
+    }
+  }
+}
+
+
+from helper_battlesnake import *
+
+my_head = {"x": 1, "y": 0}
+safe_moves = obvious_moves(game, my_head)
+for safe in safe_moves:
+    f = flood_fill(game, look_ahead(my_head, safe))
+    print(safe, f)
+print("=" * 50)
+
+food = game['board']['food']
+food_dist = []
+food_moves = []
+# Big idea: loop through all food and find the shortest path using A* search
+for food_loc in food:
+    best_path, best_dist = a_star_search(game, my_head.copy(), food_loc)
+    print(f"Food: {food_loc}")
+    print(f"Shortest dist: {best_dist}")
+    if best_path is not None:
+        food_dist.append(best_dist)
+        lesgo = snake_compass(my_head, best_path[-2])
+        food_moves.append(lesgo)
+
+    f = flood_fill(game, look_ahead(my_head, lesgo))
+    print(f"Direction {lesgo} at {f}")
+    print(best_dist * 11 * 11 / f ** 2.25)

main.py

@@ -5,91 +5,48 @@
 #  |    |   \ / __ \|  |  |  | |  |_\  ___/ \___ \|   |  \/ __ \|    <\  ___/
 #  |________/(______/__|  |__| |____/\_____>______>___|__(______/__|__\\_____>
 #
-# This file can be a nice home for your Battlesnake logic and helper functions.
-#
-# To get you started we've included code to prevent your Battlesnake from moving backwards.
-# For more info see docs.battlesnake.com
 
-import random
 import typing
+from snake_engine import Battlesnake
 
 
-# info is called when you create your Battlesnake on play.battlesnake.com
-# and controls your Battlesnake's appearance
-# TIP: If you open your Battlesnake URL in a browser you should see this data
 def info() -> typing.Dict:
+    """
+    info is called when you create your Battlesnake on play.battlesnake.com
+    and controls your Battlesnake's appearance
+    TIP: If you open your Battlesnake URL in a browser you should see this data
+    """
     print("INFO")
 
     return {
         "apiversion": "1",
-        "author": "",  # TODO: Your Battlesnake Username
-        "color": "#888888",  # TODO: Choose color
-        "head": "default",  # TODO: Choose head
-        "tail": "default",  # TODO: Choose tail
+        "author": "G",
+        "color": "#3333ff",
+        "head": "ski",
+        "tail": "mystic-moon",
     }
 
 
-# start is called when your Battlesnake begins a game
 def start(game_state: typing.Dict):
+    """start is called when your Battlesnake begins a game"""
     print("GAME START")
 
 
-# end is called when your Battlesnake finishes a game
 def end(game_state: typing.Dict):
+    """end is called when your Battlesnake finishes a game"""
     print("GAME OVER\n")
 
 
-# move is called on every turn and returns your next move
-# Valid moves are "up", "down", "left", or "right"
-# See https://docs.battlesnake.com/api/example-move for available data
 def move(game_state: typing.Dict) -> typing.Dict:
-
-    is_move_safe = {"up": True, "down": True, "left": True, "right": True}
-
-    # We've included code to prevent your Battlesnake from moving backwards
-    my_head = game_state["you"]["body"][0]  # Coordinates of your head
-    my_neck = game_state["you"]["body"][1]  # Coordinates of your "neck"
-
-    if my_neck["x"] < my_head["x"]:  # Neck is left of head, don't move left
-        is_move_safe["left"] = False
-
-    elif my_neck["x"] > my_head["x"]:  # Neck is right of head, don't move right
-        is_move_safe["right"] = False
-
-    elif my_neck["y"] < my_head["y"]:  # Neck is below head, don't move down
-        is_move_safe["down"] = False
-
-    elif my_neck["y"] > my_head["y"]:  # Neck is above head, don't move up
-        is_move_safe["up"] = False
-
-    # TODO: Step 1 - Prevent your Battlesnake from moving out of bounds
-    # board_width = game_state['board']['width']
-    # board_height = game_state['board']['height']
-
-    # TODO: Step 2 - Prevent your Battlesnake from colliding with itself
-    # my_body = game_state['you']['body']
-
-    # TODO: Step 3 - Prevent your Battlesnake from colliding with other Battlesnakes
-    # opponents = game_state['board']['snakes']
-
-    # Are there any safe moves left?
-    safe_moves = []
-    for move, isSafe in is_move_safe.items():
-        if isSafe:
-            safe_moves.append(move)
-
-    if len(safe_moves) == 0:
-        print(f"MOVE {game_state['turn']}: No safe moves detected! Moving down")
-        return {"move": "down"}
-
-    # Choose a random move from the safe ones
-    next_move = random.choice(safe_moves)
-
-    # TODO: Step 4 - Move towards food instead of random, to regain health and survive longer
-    # food = game_state['board']['food']
-
-    print(f"MOVE {game_state['turn']}: {next_move}")
-    return {"move": next_move}
+    """
+    move is called on every turn and returns your next move
+    Valid moves are "up", "down", "left", or "right"
+    See https://docs.battlesnake.com/api/example-move for available data
+    """
+    game = Battlesnake(game_state)
+    optimal_move = game.optimal_move()
+    print(f"MOVE {game_state['turn']}: {optimal_move}")
+    return {"move": optimal_move}
 
 
 # Start server when `python main.py` is run

networkx_tree.py

@@ -0,0 +1,125 @@
+import networkx as nx
+import random
+
+
+def hierarchy_pos(G, root=None, width=25., vert_gap=0.025, vert_loc=0, leaf_vs_root_factor=1):
+    '''
+    If the graph is a tree this will return the positions to plot this in a
+    hierarchical layout.
+
+    Based on Joel's answer at https://stackoverflow.com/a/29597209/2966723,
+    but with some modifications.
+
+    We include this because it may be useful for plotting transmission trees,
+    and there is currently no networkx equivalent (though it may be coming soon).
+
+    There are two basic approaches we think of to allocate the horizontal
+    location of a node.
+
+    - Top down: we allocate horizontal space to a node.  Then its ``k``
+      descendants split up that horizontal space equally.  This tends to result
+      in overlapping nodes when some have many descendants.
+    - Bottom up: we allocate horizontal space to each leaf node.  A node at a
+      higher level gets the entire space allocated to its descendant leaves.
+      Based on this, leaf nodes at higher levels get the same space as leaf
+      nodes very deep in the tree.
+
+    We use both of these approaches simultaneously with ``leaf_vs_root_factor``
+    determining how much of the horizontal space is based on the bottom up
+    or top down approaches.  ``0`` gives pure bottom up, while 1 gives pure top
+    down.
+
+
+    :Arguments:
+
+    **G** the graph (must be a tree)
+
+    **root** the root node of the tree
+    - if the tree is directed and this is not given, the root will be found and used
+    - if the tree is directed and this is given, then the positions will be
+      just for the descendants of this node.
+    - if the tree is undirected and not given, then a random choice will be used.
+
+    **width** horizontal space allocated for this branch - avoids overlap with other branches
+
+    **vert_gap** gap between levels of hierarchy
+
+    **vert_loc** vertical location of root
+
+    **leaf_vs_root_factor**
+
+    xcenter: horizontal location of root
+    '''
+    if not nx.is_tree(G):
+        raise TypeError('cannot use hierarchy_pos on a graph that is not a tree')
+
+    if root is None:
+        if isinstance(G, nx.DiGraph):
+            root = next(iter(nx.topological_sort(G)))  # allows back compatibility with nx version 1.11
+        else:
+            root = random.choice(list(G.nodes))
+
+    def _hierarchy_pos(G, root, leftmost, width, leafdx=2, vert_gap=0.2, vert_loc=0,
+                       xcenter=0.5, rootpos=None,
+                       leafpos=None, parent=None):
+        '''
+        see hierarchy_pos docstring for most arguments
+
+        pos: a dict saying where all nodes go if they have been assigned
+        parent: parent of this branch. - only affects it if non-directed
+
+        '''
+
+        if rootpos is None:
+            rootpos = {root: (xcenter, vert_loc)}
+        else:
+            rootpos[root] = (xcenter, vert_loc)
+        if leafpos is None:
+            leafpos = {}
+        children = list(G.neighbors(root))
+        leaf_count = 0
+        if not isinstance(G, nx.DiGraph) and parent is not None:
+            children.remove(parent)
+        if len(children) != 0:
+            node_size = width / 50
+
+            rootdx = width / len(children)
+            nextx = xcenter - width / 2 - rootdx / 2
+            for child in children:
+                nextx += rootdx
+                rootpos, leafpos, newleaves = _hierarchy_pos(G, child, leftmost + leaf_count * leafdx,
+                                                             width=rootdx, leafdx=leafdx,
+                                                             vert_gap=vert_gap, vert_loc=vert_loc - vert_gap,
+                                                             xcenter=nextx, rootpos=rootpos, leafpos=leafpos,
+                                                             parent=root)
+                leaf_count += newleaves
+
+            leftmostchild = min((x for x, y in [leafpos[child] for child in children]))
+            rightmostchild = max((x for x, y in [leafpos[child] for child in children]))
+            leafpos[root] = ((leftmostchild + rightmostchild) / 2, vert_loc)
+        else:
+            leaf_count = 1
+            leafpos[root] = (leftmost, vert_loc)
+        #        pos[root] = (leftmost + (leaf_count-1)*dx/2., vert_loc)
+        #        print(leaf_count)
+        return rootpos, leafpos, leaf_count
+
+    xcenter = width / 2.
+    if isinstance(G, nx.DiGraph):
+        leafcount = len([node for node in nx.descendants(G, root) if G.out_degree(node) == 0])
+    elif isinstance(G, nx.Graph):
+        leafcount = len([node for node in nx.node_connected_component(G, root) if G.degree(node) == 1 and node != root])
+    rootpos, leafpos, leaf_count = _hierarchy_pos(G, root, 0, width,
+                                                  leafdx=width * 1. / leafcount,
+                                                  vert_gap=vert_gap,
+                                                  vert_loc=vert_loc,
+                                                  xcenter=xcenter)
+    pos = {}
+    for node in rootpos:
+        pos[node] = (
+        leaf_vs_root_factor * leafpos[node][0] + (1 - leaf_vs_root_factor) * rootpos[node][0], leafpos[node][1])
+    #    pos = {node:(leaf_vs_root_factor*x1+(1-leaf_vs_root_factor)*x2, y1) for ((x1,y1), (x2,y2)) in (leafpos[node], rootpos[node]) for node in rootpos}
+    xmax = max(x for x, y in pos.values())
+    for node in pos:
+        pos[node] = (pos[node][0] * width / xmax, pos[node][1])
+    return pos

requirements.txt

@@ -1 +1,6 @@
 Flask==2.3.2
+
+numpy~=1.26.0
+pandas~=2.1.1
+matplotlib~=3.8.0
+networkx~=3.1