code-battles 1.2.1 → 1.3.0

package/dist/cjs/index.js

@@ -16020,6 +16020,7 @@ const Simulation = () => {
                 !location.search.includes("background=true") && (React.createElement(React.Fragment, null,
                     React.createElement("div", { style: { textAlign: "center", flexGrow: 1 } },
                         showcaseMode || (React.createElement(React.Fragment, null,
+                            React.createElement("span", { id: "render-status", style: { marginRight: 10 } }),
                             React.createElement(core.NumberInput, { id: "breakpoint", label: "Breakpoint", min: 0, leftSection: React.createElement("i", { className: "fa-solid fa-stopwatch" }), display: "inline-block", maw: "35%", mr: "xs" }),
                             React.createElement(core.Button, { style: { flex: "none" }, my: "xs", w: 100, leftSection: React.createElement("i", { className: "fa-solid fa-wand-magic" }), color: "grape", id: "step", mr: "xs", radius: "20px" }, "Step"))),
                         React.createElement(PlayPauseButton, null)),

package/dist/code_battles/__init__.py

@@ -1,9 +1,7 @@
 import sys
 
-from code_battles.utilities import GameCanvas, Alignment
-from code_battles.battles import CodeBattles, is_web
-from js import window
-from pyscript.ffi import create_proxy
+from code_battles.utilities import GameCanvas, Alignment, is_web, is_worker
+from code_battles.battles import CodeBattles
 
 
 def run_game(battles: CodeBattles):
@@ -11,8 +9,18 @@ def run_game(battles: CodeBattles):
     Binds the given code battles instance to the React code to enable all simulations.
     """
 
-    if is_web:
+    if is_web():
+        from js import window
+        from pyscript.ffi import create_proxy
+
         window._startSimulation = create_proxy(battles._start_simulation)
+    elif is_worker():
+        setattr(
+            sys.modules["__main__"],
+            "_run_webworker_simulation",
+            battles._run_webworker_simulation,
+        )
+        setattr(sys.modules["__main__"], "__export__", ["_run_webworker_simulation"])
     else:
         battles._run_local_simulation()
 

package/dist/code_battles/battles.py

@@ -1,4 +1,5 @@
 import asyncio
+import base64
 import json
 import math
 import time
@@ -13,25 +14,20 @@ from code_battles.utilities import (
     download_image,
     set_results,
     show_alert,
+    web_only,
+    is_web,
 )
-from js import Audio, Image, document, window, FontFace
-from pyscript.ffi import create_proxy
+
+try:
+    import js
+except Exception:
+    pass
 
 GameStateType = TypeVar("GameStateType")
 APIImplementationType = TypeVar("APIImplementationType")
 APIType = TypeVar("APIType")
 PlayerRequestsType = TypeVar("PlayerRequestsType")
 
-is_web = "MicroPython" in sys.version or "pyodide" in sys.executable
-
-
-def web_only(method):
-    def wrapper(*args, **kwargs):
-        if is_web:
-            return method(*args, **kwargs)
-
-    return wrapper
-
 
 class CodeBattles(
     Generic[GameStateType, APIImplementationType, APIType, PlayerRequestsType]
@@ -56,7 +52,7 @@ class CodeBattles(
     """The name of the players. This is populated before any of the overridable methods run."""
     map: str
     """The name of the map. This is populated before any of the overridable methods run."""
-    map_image: Image
+    map_image: "js.Image"
     """The map image. This is populated before any of the overridable methods run."""
     canvas: GameCanvas
     """The game's canvas. Useful for the :func:`render` method. This is populated before any of the overridable methods run, but it isn't populated for background simulations, so you should only use it in :func:`render`."""
@@ -79,7 +75,8 @@ class CodeBattles(
     _player_globals: List[Dict[str, Any]]
     _initialized: bool
     _eliminated: List[int]
-    _sounds: Dict[str, Audio] = {}
+    _sounds: Dict[str, "js.Audio"] = {}
+    _decisions: List[bytes]
 
     def render(self) -> None:
         """
@@ -227,11 +224,12 @@ class CodeBattles(
     @web_only
     def download_images(
         self, sources: List[Tuple[str, str]]
-    ) -> asyncio.Future[Dict[str, Image]]:
+    ) -> asyncio.Future[Dict[str, "js.Image"]]:
         """
         :param sources: A list of ``(image_name, image_url)`` to download.
         :returns: A future which can be ``await``'d containing a dictionary mapping each ``image_name`` to its loaded image.
         """
+        from js import Image
 
         remaining_images: List[str] = []
         result = asyncio.Future()
@@ -268,6 +266,7 @@ class CodeBattles(
     @web_only
     async def load_font(self, name: str, url: str) -> None:
         """Loads the font from the specified url as the specified name."""
+        from js import FontFace, document
 
         ff = FontFace.new(name, f"url({url})")
         await ff.load()
@@ -334,7 +333,7 @@ class CodeBattles(
 
         For game-global log entries (not coming from a specific player), don't specify a ``player_index``.
         """
-        if is_web:
+        if is_web():
             console_log(-1 if player_index is None else player_index, text, color)
         else:
             self._logs.append(
@@ -349,6 +348,7 @@ class CodeBattles(
     @web_only
     def play_sound(self, sound: str):
         """Plays the given sound, from the URL given by :func:`configure_sound_url`."""
+        from js import window, Audio
 
         if sound not in self._sounds:
             self._sounds[sound] = Audio.new(self.configure_sound_url(sound))
@@ -370,7 +370,11 @@ class CodeBattles(
 
         return len(self.active_players) <= 1
 
+    @web_only
     def _initialize(self):
+        from js import window, document
+        from pyscript.ffi import create_proxy
+
         window.addEventListener("resize", create_proxy(lambda _: self._resize_canvas()))
         document.getElementById("playpause").onclick = create_proxy(
             lambda _: asyncio.get_event_loop().run_until_complete(self._play_pause())
@@ -383,6 +387,8 @@ class CodeBattles(
 
     def _initialize_simulation(self, player_codes: List[str]):
         self.step = 0
+        self._logs = []
+        self._decisions = []
         self.active_players = list(range(len(self.player_names)))
         self.active_players = list(range(len(self.player_names)))
         self.state = self.create_initial_state()
@@ -392,6 +398,38 @@ class CodeBattles(
         ]
         self._eliminated = []
         self._player_globals = self._get_initial_player_globals(player_codes)
+        self._webworker_frame = 0
+
+    def _run_webworker_simulation(
+        self, map: str, player_names_str: str, player_codes_str: str
+    ):
+        from pyscript import sync
+
+        # JS to Python
+        player_names = json.loads(player_names_str)
+        player_codes = json.loads(player_codes_str)
+
+        self.map = map
+        self.player_names = player_names
+        self.background = True
+        self.console_visible = False
+        self.verbose = False
+        self._initialize_simulation(player_codes)
+        while not self.over:
+            self._logs = []
+            decisions = self.make_decisions()
+            logs = self._logs
+            self._logs = []
+            self.apply_decisions(decisions)
+
+            sync.update_step(
+                base64.b64encode(decisions).decode(),
+                json.dumps(logs),
+                "true" if self.over else "false",
+            )
+
+            if not self.over:
+                self.step += 1
 
     def _run_local_simulation(self):
         self.map = sys.argv[1]
@@ -399,7 +437,6 @@ class CodeBattles(
         self.background = True
         self.console_visible = False
         self.verbose = False
-        self._logs = []
         player_codes = []
         for filename in sys.argv[3:]:
             with open(filename, "r") as f:
@@ -432,6 +469,7 @@ class CodeBattles(
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._start_simulation_async(*args, **kwargs))
 
+    @web_only
     async def _start_simulation_async(
         self,
         map: str,
@@ -441,7 +479,18 @@ class CodeBattles(
         console_visible: bool,
         verbose: bool,
     ):
+        from js import document
+        from pyscript import workers
+
+        # JS to Python
+        player_names = [str(x) for x in player_names]
+        player_codes = [str(x) for x in player_codes]
+
         try:
+            render_status = document.getElementById("render-status")
+            if render_status is not None:
+                render_status.textContent = "Rendering: Initializing..."
+
             self.map = map
             self.player_names = player_names
             self.map_image = await download_image(self.configure_map_image_url(map))
@@ -472,11 +521,36 @@ class CodeBattles(
                 document.getElementById("loader").style.display = "none"
                 self.render()
 
+                self._worker = await workers["worker"]
+                self._worker.update_step = self._update_step
+                self._worker._run_webworker_simulation(
+                    map, json.dumps(player_names), json.dumps(player_codes)
+                )
+
             if self.background:
                 await self._play_pause()
         except Exception:
             traceback.print_exc()
 
+    def _update_step(self, decisions_str: str, logs_str: str, is_over_str: str):
+        from js import document
+
+        decisions = base64.b64decode(str(decisions_str))
+        logs: list = json.loads(str(logs_str))
+        is_over = str(is_over_str) == "true"
+
+        self._decisions.append(decisions)
+        self._logs.append(logs)
+        self._webworker_frame += 1
+
+        render_status = document.getElementById("render-status")
+        if render_status is not None:
+            render_status.textContent = (
+                "Rendering: Complete!"
+                if is_over
+                else f"Rendering: Frame {self._webworker_frame}"
+            )
+
     def _get_initial_player_globals(self, player_codes: List[str]):
         contexts = [
             self.create_api_implementation(i) for i in range(len(self.player_names))
@@ -542,7 +616,10 @@ class CodeBattles(
 
         return player_globals
 
+    @web_only
     def _resize_canvas(self):
+        from js import document
+
         if not hasattr(self, "canvas"):
             return
 
@@ -555,9 +632,25 @@ class CodeBattles(
         if not self.background:
             self.render()
 
+    @web_only
     def _step(self):
+        from js import document, setTimeout
+        from pyscript.ffi import create_proxy
+
         if not self.over:
-            self.apply_decisions(self.make_decisions())
+            if len(self._decisions) == 0:
+                print("Warning: sleeping because decisions were not made yet!")
+                setTimeout(create_proxy(self._step), 100)
+                return
+            else:
+                logs = self._logs.pop(0)
+                for log in logs:
+                    console_log(
+                        -1 if log["player_index"] is None else log["player_index"],
+                        log["text"],
+                        log["color"],
+                    )
+                self.apply_decisions(self._decisions.pop(0))
 
         if not self.over:
             self.step += 1
@@ -585,7 +678,10 @@ class CodeBattles(
             if self.over:
                 document.getElementById("noui-progress").style.display = "none"
 
+    @web_only
     def _should_play(self):
+        from js import document
+
         if self.over:
             return False
 
@@ -600,7 +696,10 @@ class CodeBattles(
 
         return True
 
+    @web_only
     def _get_playback_speed(self):
+        from js import document
+
         return 2 ** float(
             document.getElementById("timescale")
             .getElementsByClassName("mantine-Slider-thumb")
@@ -608,7 +707,10 @@ class CodeBattles(
             .ariaValueNow
         )
 
+    @web_only
     def _get_breakpoint(self):
+        from js import document
+
         breakpoint_element = document.getElementById("breakpoint")
         if breakpoint_element is None or breakpoint_element.value == "":
             return -1

package/dist/code_battles/js.pyi

@@ -15,6 +15,7 @@ class TwoDContext:
     font: str
     fillStyle: str
     strokeStyle: str
+    lineWidth: int
 
     @staticmethod
     def beginPath(): ...
@@ -28,6 +29,10 @@ class TwoDContext:
         counterclockwise=False,
     ): ...
     @staticmethod
+    def moveTo(x: int, y: int): ...
+    @staticmethod
+    def lineTo(x: int, y: int): ...
+    @staticmethod
     def stroke(): ...
     @staticmethod
     def fill(): ...

package/dist/code_battles/pyscript/__init__.pyi

@@ -0,0 +1,4 @@
+from typing import Literal
+
+class PyWorker:
+    def __init__(self, path: str, type: Literal["micropython", "pyodide"]): ...

package/dist/code_battles/utilities.py

@@ -2,10 +2,39 @@
 
 import asyncio
 import math
+import sys
 from typing import Callable, List, Union
 from enum import Enum
 
-from js import Element, Image, window
+try:
+    import js
+except Exception:
+    pass
+
+
+def is_worker():
+    try:
+        from js import window  # noqa: F401
+
+        return False
+    except Exception:
+        return True
+
+
+def is_web():
+    return (
+        "MicroPython" in sys.version or "pyodide" in sys.executable
+    ) and not is_worker()
+
+
+def web_only(method):
+    if is_web():
+        return method
+
+    def wrapper(*args, **kwargs):
+        print(f"Warning: {method.__name__} should only be called in a web context.")
+
+    return wrapper
 
 
 class Alignment(Enum):
@@ -13,7 +42,10 @@ class Alignment(Enum):
     TOP_LEFT = 1
 
 
-def download_image(src: str) -> Image:
+@web_only
+def download_image(src: str):
+    from js import Image
+
     result = asyncio.Future()
     image = Image.new()
     image.onload = lambda _: result.set_result(image)
@@ -24,14 +56,22 @@ def download_image(src: str) -> Image:
 def show_alert(
     title: str, alert: str, color: str, icon: str, limit_time: int = 5000, is_code=True
 ):
-    if hasattr(window, "showAlert"):
-        try:
-            window.showAlert(title, alert, color, icon, limit_time, is_code)
-        except Exception as e:
-            print(e)
+    if is_web():
+        from js import window
+
+        if hasattr(window, "showAlert"):
+            try:
+                window.showAlert(title, alert, color, icon, limit_time, is_code)
+            except Exception as e:
+                print(e)
+    else:
+        print(f"[ALERT] {title}: {alert}")
 
 
+@web_only
 def set_results(player_names: List[str], places: List[int], map: str, verbose: bool):
+    from js import window
+
     if hasattr(window, "setResults"):
         try:
             window.setResults(player_names, places, map, verbose)
@@ -39,7 +79,10 @@ def set_results(player_names: List[str], places: List[int], map: str, verbose: b
             print(e)
 
 
+@web_only
 def download_json(filename: str, contents: str):
+    from js import window
+
     if hasattr(window, "downloadJson"):
         try:
             window.downloadJson(filename, contents)
@@ -47,7 +90,10 @@ def download_json(filename: str, contents: str):
             print(e)
 
 
+@web_only
 def console_log(player_index: int, text: str, color: str):
+    from js import window
+
     if hasattr(window, "consoleLog"):
         try:
             window.consoleLog(player_index, text, color)
@@ -71,9 +117,9 @@ class GameCanvas:
 
     def __init__(
         self,
-        canvas: Element,
+        canvas: "js.Element",
         player_count: int,
-        map_image: Image,
+        map_image: "js.Image",
         max_width: int,
         max_height: int,
         extra_width: int,
@@ -89,7 +135,7 @@ class GameCanvas:
 
     def draw_element(
         self,
-        image: Image,
+        image: "js.Image",
         x: int,
         y: int,
         width: int,
@@ -143,6 +189,26 @@ class GameCanvas:
         self.context.fillStyle = color
         self.context.fillText(text, x, y)
 
+    def draw_line(
+        self,
+        start_x: int,
+        start_y: int,
+        end_x: int,
+        end_y: int,
+        stroke="black",
+        stroke_width=10,
+        board_index=0,
+    ):
+        start_x, start_y = self._translate_position(board_index, start_x, start_y)
+        end_x, end_y = self._translate_position(board_index, end_x, end_y)
+
+        self.context.strokeStyle = stroke
+        self.context.lineWidth = stroke_width * self._scale
+        self.context.beginPath()
+        self.context.moveTo(start_x, start_y)
+        self.context.lineTo(end_x, end_y)
+        self.context.stroke()
+
     def draw_circle(
         self,
         x: int,
@@ -150,6 +216,7 @@ class GameCanvas:
         radius: float,
         fill="black",
         stroke="transparent",
+        stroke_width=2,
         board_index=0,
     ):
         """
@@ -157,8 +224,10 @@ class GameCanvas:
         """
 
         x, y = self._translate_position(board_index, x, y)
+
         self.context.fillStyle = fill
         self.context.strokeStyle = stroke
+        self.context.lineWidth = stroke_width * self._scale
         self.context.beginPath()
         self.context.arc(x, y, radius * self._scale, 0, 2 * math.pi)
         self.context.stroke()
@@ -187,6 +256,8 @@ class GameCanvas:
         return self.map_image.width * self.player_count
 
     def _fit_into(self, max_width: int, max_height: int):
+        from js import window
+
         if self.map_image.width == 0 or self.map_image.height == 0:
             raise Exception("Map image invalid!")
         aspect_ratio = (self.map_image.width * self.player_count + self.extra_width) / (

package/dist/code_battles/worker.py

@@ -0,0 +1,6 @@
+def run_game(game):
+    # game = pickle.loads(game)
+    print("Hi", game, type(game))  # game.player_names)
+
+
+__export__ = ["run_game"]

package/dist/esm/index.js

@@ -16018,6 +16018,7 @@ const Simulation = () => {
                 !location.search.includes("background=true") && (React.createElement(React.Fragment, null,
                     React.createElement("div", { style: { textAlign: "center", flexGrow: 1 } },
                         showcaseMode || (React.createElement(React.Fragment, null,
+                            React.createElement("span", { id: "render-status", style: { marginRight: 10 } }),
                             React.createElement(NumberInput, { id: "breakpoint", label: "Breakpoint", min: 0, leftSection: React.createElement("i", { className: "fa-solid fa-stopwatch" }), display: "inline-block", maw: "35%", mr: "xs" }),
                             React.createElement(Button, { style: { flex: "none" }, my: "xs", w: 100, leftSection: React.createElement("i", { className: "fa-solid fa-wand-magic" }), color: "grape", id: "step", mr: "xs", radius: "20px" }, "Step"))),
                         React.createElement(PlayPauseButton, null)),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-battles",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "A library for building interactive competitive coding battles",
   "repository": "https://github.com/noamzaks/code-battles",
   "homepage": "https://code-battles.readthedocs.org",
@@ -52,16 +52,16 @@
     "@rollup/plugin-commonjs": "^26.0.3",
     "@rollup/plugin-node-resolve": "^15.3.0",
     "@rollup/plugin-typescript": "^11.1.6",
-    "@types/prismjs": "^1.26.4",
-    "@types/react": "^18.3.11",
+    "@types/prismjs": "^1.26.5",
+    "@types/react": "^18.3.12",
     "@types/react-dom": "^18.3.1",
     "chokidar-cli": "^3.0.0",
-    "rollup": "^4.24.0",
+    "rollup": "^4.24.3",
     "rollup-plugin-copy": "^3.5.0",
     "rollup-plugin-dts": "^6.1.1",
-    "rollup-plugin-import-css": "^3.5.5",
+    "rollup-plugin-import-css": "^3.5.6",
     "rollup-plugin-peer-deps-external": "^2.2.4",
-    "tslib": "^2.8.0",
+    "tslib": "^2.8.1",
     "typescript": "^5.6.3"
   },
   "prettier": {