kaggle-environments 0.2.1__py3-none-any.whl → 1.20.0__py3-none-any.whl

kaggle_environments/envs/halite/test_halite.py

@@ -0,0 +1,190 @@
+from kaggle_environments import make
+
+from .halite import random_agent
+from .helpers import *
+
+
+def test_halite_no_repeated_steps():
+    step_count = 10
+    actual_steps = []
+
+    def step_appender_agent(obs, config):
+        actual_steps.append(obs.step)
+        return {}
+
+    env = make("halite", configuration={"episodeSteps": step_count}, debug=True)
+    env.run([step_appender_agent])
+    assert actual_steps == list(range(step_count - 1))
+
+
+def test_halite_completes():
+    env = make("halite", configuration={"episodeSteps": 100})
+    env.run([random_agent, random_agent])
+    json = env.toJSON()
+    assert json["name"] == "halite"
+    assert json["statuses"] == ["DONE", "DONE"]
+
+
+def test_halite_exception_action_has_error_status():
+    env = make("halite")
+
+    def error_agent(obs, config):
+        raise Exception("An exception occurred!")
+
+    env.run([error_agent, random_agent])
+    json = env.toJSON()
+    assert json["name"] == "halite"
+    assert json["statuses"] == ["ERROR", "DONE"]
+
+
+def test_halite_helpers():
+    env = make("halite", configuration={"size": 3})
+
+    @board_agent
+    def helper_agent(board):
+        for ship in board.current_player.ships:
+            ship.next_action = ShipAction.NORTH
+        for shipyard in board.current_player.shipyards:
+            shipyard.next_action = ShipyardAction.SPAWN
+
+    env.run([helper_agent, helper_agent])
+
+    json = env.toJSON()
+    assert json["name"] == "halite"
+    assert json["statuses"] == ["DONE", "DONE"]
+
+
+def create_board(size=3, starting_halite=0, agent_count=2, random_seed=0):
+    env = make("halite", configuration={"size": size, "startingHalite": starting_halite, "randomSeed": random_seed})
+    return Board(env.reset(agent_count)[0].observation, env.configuration)
+
+
+def test_move_moves_ship():
+    size = 3
+    board = create_board(size, agent_count=1)
+    for ship in board.current_player.ships:
+        ship.next_action = ShipAction.SOUTH
+    next_board = board.next()
+    for ship in board.ships.values():
+        next_position = ship.position.translate(Point(0, -1), size)
+        next_ship = next_board.ships[ship.id]
+        assert next_ship.position == next_position
+
+
+def move_toward(ship, target: Point):
+    (x1, y1) = ship.position
+    (x2, y2) = target
+    if x2 > x1:
+        return ShipAction.EAST
+    elif x2 < x1:
+        return ShipAction.WEST
+    elif y2 > y1:
+        return ShipAction.NORTH
+    elif y2 < y1:
+        return ShipAction.SOUTH
+
+
+def test_equal_ship_collision_destroys_both_ships():
+    size = 3
+    board = create_board(size, agent_count=2)
+    for ship in board.ships.values():
+        ship.next_action = move_toward(ship, Point(1, 1))
+    next_board = board.next()
+    assert len(next_board.ships) == 0
+
+
+def test_unequal_ship_collision_destroys_weaker_ship():
+    board = create_board(agent_count=2)
+    for opponent in board.opponents:
+        for ship in opponent.ships:
+            # Make the opponents' ships have more halite so they'll be destroyed
+            ship._halite = 1000
+    for ship in board.ships.values():
+        ship.next_action = move_toward(ship, Point(1, 1))
+    next_board = board.next()
+    assert len(next_board.current_player.ships) == 1
+    assert len(next_board.ships) == 1
+
+
+def first(iterable):
+    return next(iter(iterable))
+
+
+def test_ship_shipyard_collision_destroys_both():
+    board = create_board(agent_count=2)
+    player_ship = first(board.current_player.ships)
+    opponent_ship = first(first(board.opponents).ships)
+    opponent_ship.next_action = ShipAction.CONVERT
+    board = board.next()
+    assert len(board.ships) == 1
+    assert len(board.shipyards) == 1
+    while player_ship.id in board.ships:
+        board.ships[player_ship.id].next_action = move_toward(player_ship, opponent_ship.position)
+        board = board.next()
+    assert len(board.ships) == 0
+    assert len(board.shipyards) == 0
+
+
+def test_cells_regen_halite():
+    board = create_board(starting_halite=1000, agent_count=1)
+    cell = first(board.cells.values())
+    next_board = board.next()
+    next_cell = next_board[cell.position]
+    expected_regen = round(cell.halite * board.configuration.regen_rate, 3)
+    # We compare to a floating point value here to handle float rounding errors
+    assert next_cell.halite - cell.halite - expected_regen < 0.000001
+
+
+def test_no_move_on_halite_gathers_halite():
+    board = create_board(starting_halite=1000, agent_count=1)
+    ship = first(board.ships.values())
+    expected_delta = int(ship.cell.halite * board.configuration.collect_rate)
+    next_board = board.next()
+    next_ship = next_board.ships[ship.id]
+    ship_delta = next_ship.halite - ship.halite
+    cell_delta = round(ship.cell.halite - next_ship.cell.halite, 3)
+    assert ship_delta == expected_delta
+    assert cell_delta == expected_delta
+
+
+def test_move_on_halite_gathers_no_halite():
+    board = create_board(starting_halite=1000, agent_count=1)
+    ship = first(board.ships.values())
+    ship.next_action = ShipAction.NORTH
+    next_board = board.next()
+    next_ship = next_board.ships[ship.id]
+    ship_delta = next_ship.halite - ship.halite
+    assert ship_delta == 0
+
+
+def test_failed_convert_gathers_halite():
+    board = create_board(starting_halite=1000, agent_count=1)
+    board.current_player._halite = board.configuration.convert_cost - 1
+    ship = first(board.ships.values())
+    ship.next_action = ShipAction.CONVERT
+    expected_delta = int(ship.cell.halite * board.configuration.collect_rate)
+    next_board = board.next()
+    next_ship = next_board.ships[ship.id]
+    ship_delta = next_ship.halite - ship.halite
+    cell_delta = round(ship.cell.halite - next_ship.cell.halite, 3)
+    assert ship_delta == expected_delta
+    assert cell_delta == expected_delta
+
+
+def test_shipyard_ids_not_reused():
+    board = create_board(starting_halite=1000, agent_count=1)
+    ship = first(board.ships.values())
+    ship.next_action = ShipAction.CONVERT
+    board = board.next()
+    shipyard = board.cells[ship.position].shipyard
+    assert ship.id != shipyard.id
+
+
+def test_seed_parameter():
+    seed = 9
+
+    def aggregate_halite_for_board(seed):
+        board = create_board(starting_halite=1000, agent_count=1, random_seed=seed)
+        return sum(map(lambda c: c.halite, board.cells.values()))
+
+    assert aggregate_halite_for_board(seed) == aggregate_halite_for_board(seed)

kaggle_environments/envs/{battlegeese/battlegeese.js → hungry_geese/hungry_geese.js}

@@ -151,36 +151,53 @@ function renderer({
     ],
   };
 
-  const getRowCol = (cell) => [Math.floor(cell / columns), cell % columns];
+  // Javascript does not correctly handle mod of negatives
+  const mod = (number, divisor) => ((number % divisor) + divisor) % divisor;
+
+  const getRowCol = (cell) => [Math.floor(cell / columns), mod(cell, columns)];
+
+  const diff = (row, column, nextRow, nextColumn, rows, columns) => {
+    const north = mod(row - 1, rows) === nextRow;
+    const south = mod(row + 1, rows) === nextRow;
+    const east = mod(column + 1, columns) === nextColumn;
+    const west = mod(column - 1, columns) === nextColumn;
+    return [north, south, east, west];
+  }
 
-  // Observation.
   const { geese, food } = environment.steps[step][0].observation;
 
   // Organize the geese positions for rendering.
   const geesePositions = {};
-  geese.forEach((goose, index) => {
+  geese.forEach((goose, gooseIndex) => {
     const active = goose.length > 0;
     let s = step;
     if (!active) {
       // Find the last step where the goose existed.
-      while (s >= 0 && !goose.length) {
-        goose = environment.steps[--s][0].observation.geese[index];
+      while (s > 0 && !goose.length) {
+        goose = environment.steps[--s][0].observation.geese[gooseIndex];
       }
     }
-    goose.forEach((pos, posIndex) => {
-      if (!active && pos in geesePositions) return;
-      const [r, c] = getRowCol(pos);
-      const [br, bc] = posIndex === 0 ? [r, c] : getRowCol(goose[posIndex - 1]);
-      const [ar, ac] =
-        posIndex === goose.length - 1 ? [r, c] : getRowCol(goose[posIndex + 1]);
-      geesePositions[pos] = {
-        index,
-        head: posIndex === 0,
-        tail: posIndex === goose.length - 1,
-        east: bc > c || ac > c,
-        west: bc < c || ac < c,
-        south: br > r || ar > r,
-        north: br < r || ar < r,
+    goose.forEach((position, segmentIndex) => {
+      if (!active && position in geesePositions) return;
+      const [row, column] = getRowCol(position);
+      const [previousRow, previousColumn] =
+          segmentIndex === 0
+              ? [row, column]
+              : getRowCol(goose[segmentIndex - 1]);
+      const [nextRow, nextColumn] =
+          segmentIndex === goose.length - 1
+              ? [row, column]
+              : getRowCol(goose[segmentIndex + 1]);
+      const [previousNorth, previousSouth, previousEast, previousWest] = diff(row, column, previousRow, previousColumn, rows, columns)
+      const [nextNorth, nextSouth, nextEast, nextWest] = diff(row, column, nextRow, nextColumn, rows, columns)
+      geesePositions[position] = {
+        index: gooseIndex,
+        head: segmentIndex === 0,
+        tail: segmentIndex === goose.length - 1,
+        east: previousEast || nextEast,
+        west: previousWest || nextWest,
+        south: previousSouth || nextSouth,
+        north: previousNorth || nextNorth,
         active,
       };
     });
@@ -189,7 +206,7 @@ function renderer({
   // Common Dimensions.
   const unit = 8;
   const minCanvasSize = Math.min(height, width);
-  const minOffset = minCanvasSize > 400 ? 30 : unit / 2;
+  const minOffset = minCanvasSize > 800 ? 50 : unit / 2;
   const cellSize = Math.min(
     (width - minOffset * 2) / columns,
     (height - minOffset * 2) / rows
@@ -312,7 +329,7 @@ function renderer({
 
   // Canvas setup and reset.
   const [bufferCanvas] = getCanvas("buffer");
-  const [canvas, c] = getCanvas("battlegeese");
+  const [canvas, c] = getCanvas("hungry_geese");
   c.fillStyle = "#000B2A";
   c.fillRect(0, 0, canvas.width, canvas.height);
 
@@ -384,7 +401,6 @@ function renderer({
         width: 100,
         height: 100,
       });
-      canvas.style.marginLeft = "10000px";
       ctx.drawImage(
         bufferCanvas,
         cellSize * agent.index,

kaggle_environments/envs/{battlegeese/battlegeese.json → hungry_geese/hungry_geese.json}

@@ -1,28 +1,28 @@
 {
-  "name": "battlegeese",
-  "title": "Battle Geese",
+  "name": "hungry_geese",
+  "title": "Hungry Geese",
   "description": "Similar to the classic snake game with multiple players",
   "version": "1.0.0",
-  "agents": [2, 3, 4, 5, 6, 7, 8],
+  "agents": [1, 2, 3, 4, 5, 6, 7, 8],
   "configuration": {
-    "episodeSteps": 100,
+    "episodeSteps": 200,
+    "actTimeout": 1,
     "columns": {
       "description": "Horizontal number of cells on the board.",
       "type": "integer",
       "default": 11,
-      "minimum": 3,
-      "maximum": 50
+      "minimum": 3
     },
     "rows": {
       "description": "Vertical number of cells on the board.",
       "type": "integer",
       "default": 7,
-      "minimum": 3,
-      "maximum": 50
+      "minimum": 3
     },
     "hunger_rate": {
       "description": "The number of steps before the goose shrinks a cell.",
       "type": "integer",
+      "minimum": 1,
       "default": 40
     },
     "min_food": {
@@ -30,12 +30,18 @@
       "type": "integer",
       "default": 2,
       "minimum": 1
+    },
+    "max_length": {
+      "description": "The max length any goose can be. Total reward = (max length + 1) * steps survived + goose length.",
+      "type": "integer",
+      "default": 99
     }
   },
   "reward": {
-    "description": "The number of steps the goose has moved plus it's length.",
+    "description": "steps survived * (max goose length + 1) + current goose length.",
     "type": "integer",
-    "default": 0
+    "default": 0,
+    "minimum": 0
   },
   "observation": {
     "geese": {
@@ -64,16 +70,17 @@
       }
     },
     "index": {
-      "description": "Index of the agents goose in the list of geese.",
+      "description": "Index of the current agent's goose in the list of geese.",
       "type": "integer",
       "minimum": 0,
       "defaults": [0, 1, 2, 3, 4, 5, 6, 7]
-    }
+    },
+    "remainingOverageTime": 60
   },
   "action": {
     "description": "Direction to move the head of your players goose.",
     "type": "string",
-    "enum": ["N", "E", "S", "W"],
-    "default": "N"
+    "enum": ["NORTH", "EAST", "SOUTH", "WEST"],
+    "default": "NORTH"
   }
 }

kaggle_environments/envs/hungry_geese/hungry_geese.py

@@ -0,0 +1,316 @@
+# Copyright 2020 Kaggle Inc
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+from enum import Enum, auto
+from os import path
+from random import choice, sample
+from typing import *
+
+import kaggle_environments.helpers
+from kaggle_environments.helpers import histogram
+
+
+class Observation(kaggle_environments.helpers.Observation):
+    @property
+    def geese(self) -> List[List[int]]:
+        return self["geese"]
+
+    @property
+    def food(self) -> List[int]:
+        return self["food"]
+
+    @property
+    def index(self) -> int:
+        return self["index"]
+
+
+class Configuration(kaggle_environments.helpers.Configuration):
+    @property
+    def columns(self) -> int:
+        return self["columns"]
+
+    @property
+    def rows(self) -> int:
+        return self["rows"]
+
+    @property
+    def hunger_rate(self) -> int:
+        return self["hunger_rate"]
+
+    @property
+    def min_food(self) -> int:
+        return self["min_food"]
+
+    @property
+    def max_length(self) -> int:
+        return self["max_length"]
+
+
+class Action(Enum):
+    NORTH = auto()
+    EAST = auto()
+    SOUTH = auto()
+    WEST = auto()
+
+    def to_row_col(self):
+        if self == Action.NORTH:
+            return -1, 0
+        if self == Action.SOUTH:
+            return 1, 0
+        if self == Action.EAST:
+            return 0, 1
+        if self == Action.WEST:
+            return 0, -1
+        return 0, 0
+
+    def opposite(self):
+        if self == Action.NORTH:
+            return Action.SOUTH
+        if self == Action.SOUTH:
+            return Action.NORTH
+        if self == Action.EAST:
+            return Action.WEST
+        if self == Action.WEST:
+            return Action.EAST
+        raise TypeError(str(self) + " is not a valid Action.")
+
+
+def row_col(position: int, columns: int) -> Tuple[int, int]:
+    return position // columns, position % columns
+
+
+def translate(position: int, direction: Action, columns: int, rows: int) -> int:
+    row, column = row_col(position, columns)
+    row_offset, column_offset = direction.to_row_col()
+    row = (row + row_offset) % rows
+    column = (column + column_offset) % columns
+    return row * columns + column
+
+
+def adjacent_positions(position: int, columns: int, rows: int) -> List[int]:
+    return [translate(position, action, columns, rows) for action in Action]
+
+
+def min_distance(position: int, food: List[int], columns: int):
+    row, column = row_col(position, columns)
+    return min(
+        abs(row - food_row) + abs(column - food_column)
+        for food_position in food
+        for food_row, food_column in [row_col(food_position, columns)]
+    )
+
+
+def random_agent():
+    return choice([action for action in Action]).name
+
+
+class GreedyAgent:
+    def __init__(self, configuration: Configuration):
+        self.configuration = configuration
+        self.last_action = None
+
+    def __call__(self, observation: Observation):
+        rows, columns = self.configuration.rows, self.configuration.columns
+
+        food = observation.food
+        geese = observation.geese
+        opponents = [goose for index, goose in enumerate(geese) if index != observation.index and len(goose) > 0]
+
+        # Don't move adjacent to any heads
+        head_adjacent_positions = {
+            opponent_head_adjacent
+            for opponent in opponents
+            for opponent_head in [opponent[0]]
+            for opponent_head_adjacent in adjacent_positions(opponent_head, columns, rows)
+        }
+        # Don't move into any bodies
+        bodies = {position for goose in geese for position in goose}
+
+        # Move to the closest food
+        position = geese[observation.index][0]
+        actions = {
+            action: min_distance(new_position, food, columns)
+            for action in Action
+            for new_position in [translate(position, action, columns, rows)]
+            if (
+                new_position not in head_adjacent_positions
+                and new_position not in bodies
+                and (self.last_action is None or action != self.last_action.opposite())
+            )
+        }
+
+        action = min(actions, key=actions.get) if any(actions) else choice([action for action in Action])
+        self.last_action = action
+        return action.name
+
+
+cached_greedy_agents = {}
+
+
+def greedy_agent(obs, config):
+    index = obs["index"]
+    if index not in cached_greedy_agents:
+        cached_greedy_agents[index] = GreedyAgent(Configuration(config))
+    return cached_greedy_agents[index](Observation(obs))
+
+
+agents = {"random": random_agent, "greedy": greedy_agent}
+
+
+def interpreter(state, env):
+    configuration = Configuration(env.configuration)
+    columns = configuration.columns
+    rows = configuration.rows
+    min_food = configuration.min_food
+    state[0].observation = shared_observation = Observation(state[0].observation)
+
+    # Reset the environment.
+    if env.done:
+        agent_count = len(state)
+        heads = sample(range(columns * rows), agent_count)
+        shared_observation["geese"] = [[head] for head in heads]
+        food_candidates = set(range(columns * rows)).difference(heads)
+        # Ensure we only place as many food as there are open squares
+        min_food = min(min_food, len(food_candidates))
+        shared_observation["food"] = sample(food_candidates, min_food)
+        return state
+
+    geese = shared_observation.geese
+    food = shared_observation.food
+
+    # If there is no last state, reuse current state so that current action is never the opposite of the last action.
+    last_state = env.steps[-1] if len(env.steps) > 1 else state
+    # Apply the actions from active agents.
+    for index, agent in enumerate(state):
+        if agent.status != "ACTIVE":
+            if agent.status != "INACTIVE" and agent.status != "DONE":
+                # ERROR, INVALID, or TIMEOUT, remove the goose.
+                geese[index] = []
+            continue
+
+        action = Action[agent.action]
+
+        # Check action direction
+        last_agent = last_state[index]
+        last_action = Action[last_agent["action"]] if "action" in last_agent else action
+        if last_action == action.opposite():
+            env.debug_print(f"Opposite action: {agent.observation.index, action, last_action}")
+            agent.status = "DONE"
+            geese[index] = []
+            continue
+
+        goose = geese[index]
+        head = translate(goose[0], action, columns, rows)
+
+        # Consume food or drop a tail piece.
+        if head in food:
+            food.remove(head)
+        else:
+            goose.pop()
+
+        # Self collision.
+        if head in goose:
+            env.debug_print(f"Body Hit: {agent.observation.index, action, head, goose}")
+            agent.status = "DONE"
+            geese[index] = []
+            continue
+
+        while len(goose) >= configuration.max_length:
+            # Free a spot for the new head if needed
+            goose.pop()
+        # Add New Head to the Goose.
+        goose.insert(0, head)
+
+        # If hunger strikes remove from the tail.
+        if len(env.steps) % configuration.hunger_rate == 0:
+            if len(goose) > 0:
+                goose.pop()
+            if len(goose) == 0:
+                env.debug_print(f"Goose Starved: {action}")
+                agent.status = "DONE"
+                continue
+
+    goose_positions = histogram(position for goose in geese for position in goose)
+
+    # Check for collisions.
+    for index, agent in enumerate(state):
+        goose = geese[index]
+        if len(goose) > 0:
+            head = geese[index][0]
+            if goose_positions[head] > 1:
+                env.debug_print(f"Goose Collision: {agent.action}")
+                agent.status = "DONE"
+                geese[index] = []
+
+    # Add food if min_food threshold reached.
+    needed_food = min_food - len(food)
+    if needed_food > 0:
+        collisions = {position for goose in geese for position in goose}
+        available_positions = set(range(rows * columns)).difference(collisions).difference(food)
+        # Ensure we don't sample more food than available positions.
+        needed_food = min(needed_food, len(available_positions))
+        food.extend(sample(available_positions, needed_food))
+
+    # Set rewards after deleting all geese to ensure that geese don't receive a reward on the turn they perish.
+    for index, agent in enumerate(state):
+        if agent.status == "ACTIVE":
+            # Adding 1 to len(env.steps) ensures that if an agent gets reward 4507, it died on turn 45 with length 7.
+            agent.reward = (len(env.steps) + 1) * (configuration.max_length + 1) + len(geese[index])
+
+    # If only one ACTIVE agent left, set it to DONE.
+    active_agents = [a for a in state if a.status == "ACTIVE"]
+    if len(active_agents) == 1:
+        agent = active_agents[0]
+        agent.status = "DONE"
+
+    return state
+
+
+def renderer(state, env):
+    config = env.configuration
+    columns = config.columns
+    rows = config.rows
+
+    food_symbol = "F"
+    column_divider = "|"
+    row_divider = "+" + "+".join(["---"] * columns) + "+\n"
+
+    board = [" "] * (rows * columns)
+    for pos in state[0].observation.food:
+        board[pos] = food_symbol
+
+    for index, goose in enumerate(state[0].observation.geese):
+        for position in goose:
+            board[position] = index
+
+    out = row_divider
+    for row in range(rows):
+        for col in range(columns):
+            out += column_divider + f" {board[(row * columns) + col]} "
+        out += column_divider + "\n" + row_divider
+
+    return out
+
+
+dirpath = path.dirname(__file__)
+jsonpath = path.abspath(path.join(dirpath, "hungry_geese.json"))
+with open(jsonpath) as f:
+    specification = json.load(f)
+
+
+def html_renderer():
+    jspath = path.abspath(path.join(dirpath, "hungry_geese.js"))
+    with open(jspath, encoding="utf-8") as f:
+        return f.read()