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

kaggle_environments/envs/cabt/cabt.js

@@ -0,0 +1,164 @@
+
+function renderer(context) {
+  const step = context.step
+  const visList = context.environment.steps[0][0].visualize
+  const energyText = "CGRWLPFDM A"
+
+  const info = context.environment.info
+  const players = [
+    info?.TeamNames?.[0] || "Player 0",
+    info?.TeamNames?.[1] || "Player 1"
+  ]
+
+  let canvas = context.parent.querySelector("canvas")
+  if (!canvas) {
+    container = document.createElement("div")
+    container.style.position = "relative"
+    context.parent.appendChild(container)
+
+    canvas = document.createElement("canvas")
+    canvas.width = 750
+    canvas.height = 700
+    container.appendChild(canvas)
+
+    if (visList) {
+      for (let k = 0; k < 2; k++) {
+        const button = document.createElement("button")
+        button.style.width = "120px"
+        button.style.height = "50px"
+        button.style.left = k == 0 ? "240px" : "380px"
+        button.style.top = "10px"
+        button.style.position = "absolute"
+        button.style.zIndex = 1
+        button.innerHTML = "Open Visualizer<br>" + players[k]
+        button.addEventListener("click", (e) => {
+          for (let i = 0; i < visList.length; i++) {
+            for (let j = 0; j < 2; j++) {
+              visList[i].current.players[j].ramainingTime = context.environment.steps[i][j].observation.remainingOverageTime
+            }
+          }
+          visList[0].ps = players
+
+          const input = document.createElement("input")
+          input.type = "hidden"
+          input.name = "json"
+          input.value = JSON.stringify(visList)
+
+          const form = document.createElement("form")
+          form.method = "POST"
+          form.action = "https://ptcgvis.heroz.jp/Visualizer/Replay/"
+          if (info.EpisodeId == null) {
+            form.action += k
+          } else {
+            form.action += info.EpisodeId + "/" + k
+          }
+          form.target = "_blank"
+          form.appendChild(input)
+
+          document.body.appendChild(form)
+          form.submit()
+        })
+        container.appendChild(button)
+      }
+    } else {
+      const ctx = canvas.getContext("2d")
+      ctx.strokeStyle = "#ccc"
+      ctx.fillStyle = "#fff"
+      ctx.font = "30px sans-serif"
+      ctx.fillText("No visualize data.", 10, 100)
+      const error = context.environment.steps[0][0].error
+      if (error) {
+        ctx.fillText(error, 10, 150)
+      }
+    }
+  }
+
+  if (visList.length <= step) {
+    return
+  }
+  const vis = visList[step]
+  const state = vis.current
+
+  const ctx = canvas.getContext("2d")
+  ctx.clearRect(0, 0, canvas.width, canvas.height)
+
+  ctx.strokeStyle = "#ccc"
+  ctx.fillStyle = "#fff"
+  ctx.lineWidth = 2
+
+  ctx.font = "20px sans-serif"
+  if (state.result >= 0) {
+    if (state.result == 2) {
+      ctx.fillText("Draw", 330, 70)
+    } else {
+      ctx.fillText(players[state.result] + " Win", 310, 120)
+    }
+  }
+
+  ctx.font = "12px sans-serif"
+
+  const drawCard = (x, y, card) => {
+    ctx.beginPath()
+    ctx.rect(x, y, 80, 60)
+    ctx.stroke()
+    nm = card.name
+    nm2 = null
+    if (nm.length >= 13) {
+      for (let i = 0; i < nm.length; i++) {
+        if (nm[i] == " ") {
+          nm2 = nm.substring(i + 1)
+          nm = nm.substring(0, i)
+          break
+        }
+      }
+    }
+    ctx.fillText(nm, x + 5, y + 13)
+    if (nm2 != null) {
+      ctx.fillText(nm2, x + 5, y + 27)
+    }
+  }
+  const drawField = (x, y, card) => {
+    drawCard(x, y, card)
+    ctx.fillText("HP " + card.hp, x + 5, y + 41)
+    energy = ""
+    for (let e of card.energies) {
+      energy = energy + energyText[e]
+    }
+    ctx.fillText(energy, x + 5, y + 55)
+  }
+  const posY = (index, len) => {
+    const center = 290
+    let height
+    if (len <= 8) {
+      height = 35 * len
+    } else {
+      height = 280
+    }
+    return center + height * (2 * index + 1 - len) / len
+  }
+
+  for (let j = 0; j < state.stadium.length; j++) {
+    drawCard(330, 420, state.stadium[j])
+  }
+
+  for (let i = 0; i < 2; i++) {
+    const ps = state.players[i]
+
+    ctx.fillText("Active", i == 0 ? 245 : 425, 270)
+    ctx.fillText("Bench", i == 0 ? 145 : 525, 10)
+    ctx.fillText("Hand", i == 0 ? 15 : 655, 10)
+    ctx.fillText("Deck " + ps.deckCount, i == 0 ? 258 : 438, 150)
+    ctx.fillText("Discard " + ps.discard.length, i == 0 ? 245 : 425, 170)
+    ctx.fillText("Prize " + ps.prize.length, i == 0 ? 258 : 438, 200)
+
+    for (let j = 0; j < ps.active.length; j++) {
+      drawField(i == 0 ? 240 : 420, posY(j, ps.active.length), ps.active[j])
+    }
+    for (let j = 0; j < ps.bench.length; j++) {
+      drawField(i == 0 ? 140 : 520, posY(j, ps.bench.length), ps.bench[j])
+    }
+    for (let j = 0; j < ps.hand.length; j++) {
+      drawCard(i == 0 ? 10 : 650, posY(j, ps.hand.length), ps.hand[j])
+    }
+  }
+}

kaggle_environments/envs/cabt/cabt.json

@@ -0,0 +1,28 @@
+{
+  "name": "cabt",
+  "title": "Card Battle",
+  "description": "Limited Card Battle.",
+  "version": "1.0.0",
+  "agents": [2],
+  "configuration": {
+    "episodeSteps": 10000,
+    "actTimeout": 0,
+    "runTimeout": 3000
+  },
+  "reward": {
+    "description": "Lost:-1, Won:1, Draw:0",
+    "enum": [-1, 0, 1],
+    "default": 0
+  },
+  "observation": {
+    "remainingOverageTime": 600
+  },
+  "action": {
+    "description": "List of option index.",
+    "type": "array",
+    "default": []
+  },
+  "status": {
+    "defaults": ["INACTIVE", "INACTIVE"]
+  }
+}

kaggle_environments/envs/cabt/cabt.py

@@ -0,0 +1,186 @@
+import json
+import os
+import random
+
+from .cg.game import battle_finish, battle_select, battle_start, visualize_data
+from .cg.sim import Battle
+
+deck = [
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    9,
+    9,
+    77,
+    77,
+    77,
+    77,
+    156,
+    156,
+    156,
+    156,
+    157,
+    157,
+    157,
+    157,
+    331,
+    331,
+    331,
+    331,
+    408,
+    408,
+    408,
+    408,
+    474,
+    474,
+    474,
+    474,
+    528,
+    528,
+    528,
+    528,
+    530,
+    530,
+    530,
+    530,
+    532,
+    554,
+    554,
+    554,
+    576,
+    576,
+    576,
+    576,
+    585,
+    585,
+    585,
+    585,
+    630,
+    630,
+    630,
+    630,
+]
+
+
+def random_agent(obs: dict) -> list[int]:
+    if obs["select"] == None:
+        return deck
+    return random.sample(list(range(len(obs["select"]["option"]))), obs["select"]["maxCount"])
+
+
+def first_agent(obs: dict) -> list[int]:
+    if obs["select"] == None:
+        return deck
+    return list(range(obs["select"]["maxCount"]))
+
+
+agents = {"random": random_agent, "first": first_agent}
+
+
+def finish(env):
+    if len(env.steps) > 0:
+        env.steps[0][0]["visualize"] = json.loads(visualize_data())
+    battle_finish()
+
+
+def interpreter(state, env):
+    if env.done:
+        Battle.battle_ptr = None
+        for i in range(2):
+            state[i].status = "ACTIVE"
+            o = state[i].observation
+            o["select"] = None
+            o["logs"] = []
+            o["current"] = None
+            o["search_begin_input"] = None
+        return state
+    elif Battle.battle_ptr == None:
+        decks = [state[0].action, state[1].action]
+        error = False
+        for i in range(2):
+            if state[i].status == "TIMEOUT" or state[i].status == "ERROR":
+                error = True
+                continue
+            if len(decks[i]) != 60:
+                state[i].status = "INVALID"
+                env.steps[0][0]["error"] = f"Player {i}'s deck does not have 60 cards."
+                error = True
+        if not error:
+            _, start_data = battle_start(state[0].action, state[1].action)
+            if start_data.errorPlayer >= 0:
+                state[start_data.errorPlayer].status = "INVALID"
+                env.steps[0][0]["error"] = f"Player {i}'s deck error."
+                error = True
+        if error:
+            for i in range(2):
+                if state[i].status == "ACTIVE":
+                    state[i].status = "DONE"
+            return state
+        if Battle.battle_ptr == None:
+            raise ValueError("battle_ptr None.")
+    else:
+        error = False
+        select_player = Battle.obs["current"]["yourIndex"]
+        if state[select_player].status == "TIMEOUT" or state[select_player].status == "ERROR":
+            error = True
+        else:
+            try:
+                battle_select(state[select_player].action)
+            except:
+                state[select_player].status = "INVALID"
+                error = True
+
+        if error:
+            state[select_player].reward = -1
+            state[1 - select_player].status = "DONE"
+            state[1 - select_player].reward = 1
+            finish(env)
+            return state
+
+    obs = Battle.obs
+    s = obs["current"]
+    if s["result"] >= 0:
+        state[0].status = "DONE"
+        state[1].status = "DONE"
+        if s["result"] == 0:
+            state[0].reward = 1
+            state[1].reward = -1
+        elif s["result"] == 1:
+            state[0].reward = -1
+            state[1].reward = 1
+        else:
+            state[0].reward = 0
+            state[1].reward = 0
+        finish(env)
+    else:
+        index = s["yourIndex"]
+        state[index].status = "ACTIVE"
+        state[1 - index].status = "INACTIVE"
+        o = state[index].observation
+        o["select"] = obs["select"]
+        o["logs"] = obs["logs"]
+        o["current"] = obs["current"]
+        o["search_begin_input"] = obs["search_begin_input"]
+    return state
+
+
+def renderer(state, env):
+    return json.dumps(Battle.obs)
+
+
+def html_renderer():
+    jspath = os.path.abspath(os.path.join(os.path.dirname(__file__), "cabt.js"))
+    with open(jspath, encoding="utf-8") as f:
+        return f.read()
+
+
+jsonpath = os.path.abspath(os.path.join(os.path.dirname(__file__), "cabt.json"))
+with open(jsonpath) as f:
+    specification = json.load(f)

kaggle_environments/envs/cabt/cg/game.py

@@ -0,0 +1,75 @@
+import ctypes
+import json
+
+from .sim import Battle, StartData, lib
+
+
+def _get_battle_data() -> dict:
+    """Retrieve the current state.
+
+    Returns:
+        dict: Current observation.
+    """
+    sd = lib.GetBattleData(Battle.battle_ptr)
+    Battle.obs = json.loads(sd.json.decode())
+    Battle.obs["search_begin_input"] = ctypes.string_at(sd.data, sd.count).decode("ascii")
+    return Battle.obs
+
+
+def battle_start(deck0: list[int], deck1: list[int]) -> tuple[dict, StartData]:
+    """Start the battle.
+
+    Args:
+        deck0: List of card IDs included in the first player’s deck.
+        deck1: List of card IDs included in the second player’s deck.
+
+    Returns:
+        tuple: A tuple containing:
+            - dict: First observation.
+            - StartData: Battle start data.
+    """
+    if len(deck0) != 60 or len(deck1) != 60:
+        raise ValueError("The deck must contain 60 cards.")
+    cards = deck0 + deck1
+    arg = (ctypes.c_int * len(cards))(*cards)
+    start_data = lib.BattleStart(arg)
+    Battle.battle_ptr = start_data.battlePtr
+    if Battle.battle_ptr == None or Battle.battle_ptr == 0:
+        return (None, start_data)
+    else:
+        return (_get_battle_data(), start_data)
+
+
+def battle_finish():
+    """End the battle and free the memory used during it."""
+    lib.BattleFinish(Battle.battle_ptr)
+
+
+def battle_select(select_list: list[int]) -> dict:
+    """Select option.
+
+    Args:
+        select_list:
+
+    Returns:
+        dict: Next observation.
+    """
+    if not isinstance(select_list, list) or not all(isinstance(i, int) for i in select_list):
+        raise ValueError("select_list is not list[int]")
+    arg = (ctypes.c_int * len(select_list))(*select_list)
+    err = lib.Select(Battle.battle_ptr, arg, len(select_list))
+    if err != 0:
+        if err == 30:
+            raise ValueError("battle_ptr broken.")
+        else:
+            raise IndexError()
+    return _get_battle_data()
+
+
+def visualize_data() -> str:
+    """Retrieve the data to be used by the visualizer.
+
+    Returns:
+        str: The data to be used by the visualizer.
+    """
+    return lib.VisualizeData(Battle.battle_ptr).decode()

kaggle_environments/envs/cabt/cg/sim.py

@@ -0,0 +1,48 @@
+import ctypes
+import os
+
+
+class StartData(ctypes.Structure):
+    _fields_ = [
+        ("battlePtr", ctypes.c_void_p),
+        ("errorPlayer", ctypes.c_int),
+        ("errorType", ctypes.c_int),
+    ]
+
+
+class SerialData(ctypes.Structure):
+    _fields_ = [
+        ("json", ctypes.c_char_p),
+        ("data", ctypes.POINTER(ctypes.c_ubyte)),
+        ("count", ctypes.c_int),
+        ("selectPlayer", ctypes.c_int),
+    ]
+
+
+if os.name == "nt":
+    lib_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "cg.dll")
+else:
+    lib_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "libcg.so")
+lib = ctypes.cdll.LoadLibrary(lib_path)
+
+lib.GameInitialize()
+
+lib.BattleStart.restype = StartData
+lib.BattleStart.argtypes = [ctypes.POINTER(ctypes.c_int)]
+
+lib.BattleFinish.argtypes = [ctypes.c_void_p]
+
+lib.GetBattleData.restype = SerialData
+lib.GetBattleData.argtypes = [ctypes.c_void_p]
+
+lib.Select.restype = ctypes.c_int
+lib.Select.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_int), ctypes.c_int]
+
+lib.VisualizeData.restype = ctypes.c_char_p
+lib.VisualizeData.argtypes = [ctypes.c_void_p]
+
+
+class Battle:
+    battle_ptr = None
+    obs = None
+    raminingTime = [[], []]

kaggle_environments/envs/cabt/test_cabt.py

@@ -0,0 +1,120 @@
+from kaggle_environments import make
+from kaggle_environments.envs.cabt.cabt import deck, first_agent, random_agent
+
+
+def test_cabt_inits():
+    """
+    Test that a game runs to completion with random agents.
+    """
+    env = make("cabt", debug=True)
+    env.run(["random", "random"])
+    env_map = env.toJSON()
+    assert env_map["name"] == "cabt"
+    assert env_map["statuses"] == ["DONE", "DONE"]
+    assert sorted(env_map["rewards"]) in [[-1, 1], [0, 0]]
+
+
+def test_cabt_first_agent_run():
+    """
+    Test that a game runs to completion with first_agent.
+    """
+    env = make("cabt", debug=True)
+    env.run(["first", "first"])
+    env_map = env.toJSON()
+    assert env_map["name"] == "cabt"
+    assert env_map["statuses"] == ["DONE", "DONE"]
+    assert sorted(env_map["rewards"]) in [[-1, 1], [0, 0]]
+
+
+def test_cabt_random_vs_first():
+    """
+    Test a game between a random and a first agent.
+    """
+    env = make("cabt", debug=True)
+    env.run(["random", "first"])
+    env_map = env.toJSON()
+    assert env_map["name"] == "cabt"
+    assert env_map["statuses"] == ["DONE", "DONE"]
+    assert sorted(env_map["rewards"]) in [[-1, 1], [0, 0]]
+
+
+def test_random_agent_deck_submission():
+    """
+    Test random_agent's deck submission phase.
+    """
+    obs = {"select": None}
+    action = random_agent(obs)
+    assert action == deck
+
+
+def test_random_agent_selection():
+    """
+    Test random_agent's selection phase.
+    """
+    obs = {"select": {"option": ["a", "b", "c", "d"], "maxCount": 2}}
+    action = random_agent(obs)
+    assert isinstance(action, list)
+    assert len(action) == 2
+    assert all(isinstance(i, int) for i in action)
+    assert all(0 <= i < 4 for i in action)
+    assert len(set(action)) == 2  # no duplicates
+
+
+def test_first_agent_deck_submission():
+    """
+    Test first_agent's deck submission phase.
+    """
+    obs = {"select": None}
+    action = first_agent(obs)
+    assert action == deck
+
+
+def test_first_agent_selection():
+    """
+    Test first_agent's selection phase.
+    """
+    obs = {"select": {"option": ["a", "b", "c", "d"], "maxCount": 2}}
+    action = first_agent(obs)
+    assert action == [0, 1]
+
+
+def invalid_deck_agent(obs, config):
+    """An agent that submits an invalid deck."""
+    if obs["select"] is None:
+        return [1, 2, 3]  # Invalid deck (not 60 cards)
+    return [0]
+
+
+def test_invalid_deck():
+    """
+    Test the interpreter's handling of an invalid deck submission.
+    """
+    env = make("cabt", debug=True)
+    env.run([invalid_deck_agent, "random"])
+    env_map = env.toJSON()
+    assert env_map["statuses"] == ["INVALID", "DONE"]
+    assert env_map["rewards"] == [None, 0]
+    assert "deck does not have 60 cards" in env_map["steps"][0][0]["error"]
+
+
+def invalid_selection_agent(obs, config):
+    """An agent that makes an invalid selection."""
+    if obs["select"] is None:
+        return deck
+    # Return more items than maxCount, which may cause an error in battle_select
+    return list(range(obs["select"]["maxCount"] + 1))
+
+
+def test_invalid_selection():
+    """
+    Test the interpreter's handling of an invalid selection during a turn.
+    """
+    env = make("cabt", debug=True)
+    env.run([invalid_selection_agent, "random"])
+    env_map = env.toJSON()
+
+    assert sorted(env_map["statuses"]) == ["DONE", "INVALID"]
+    if env_map["statuses"][0] == "INVALID":
+        assert env_map["rewards"] == [None, 1]
+    else:
+        assert env_map["rewards"] == [1, None]