sm64-binds 0.0.1__tar.gz

sm64_binds-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Gumbo64
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sm64_binds-0.0.1/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: sm64-binds
+Version: 0.0.1
+Summary: Mario 64 using WASM. Requires a US .z64 version ROM to work (8.00MB)
+Author-email: Gumbo64 <gumbo64isme@proton.me>
+License-Expression: MIT
+Project-URL: homepage, https://github.com/Gumbo64/sm64-binds
+Project-URL: repository, https://github.com/Gumbo64/sm64-binds
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+https://github.com/Gumbo64/sm64-binds

sm64_binds-0.0.1/README.md

@@ -0,0 +1 @@
+https://github.com/Gumbo64/sm64-binds

sm64_binds-0.0.1/pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "sm64-binds"
+version = "0.0.1"
+authors = [
+  { name="Gumbo64", email="gumbo64isme@proton.me" },
+]
+description = "Mario 64 using WASM. Requires a US .z64 version ROM to work (8.00MB)"
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[build-system]
+requires = ["setuptools>=61", "wheel", "wasmtime"]
+build-backend = "setuptools.build_meta"
+
+[project.urls]
+homepage = "https://github.com/Gumbo64/sm64-binds"
+repository = "https://github.com/Gumbo64/sm64-binds"

sm64_binds-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sm64_binds-0.0.1/src/sm64_binds/Sm64Game.py

@@ -0,0 +1,174 @@
+import struct
+import zipfile
+import io
+import os
+from wasmtime import Engine, Store, Module, Linker, WasiConfig
+
+# ---------------------------------------------------------
+# GamePad and GameState Python versions
+# ---------------------------------------------------------
+
+class GamePad:
+    def __init__(self, button=0, stick_x=0, stick_y=0):
+        self.button = button
+        self.stick_x = stick_x
+        self.stick_y = stick_y
+
+    @staticmethod
+    def from_bytes(b):
+        button = (b[0] << 8) | b[1]
+        stick_x = struct.unpack("b", b[2:3])[0]
+        stick_y = struct.unpack("b", b[3:4])[0]
+        return GamePad(button, stick_x, stick_y)
+
+class GameState:
+    def __init__(self, data):
+        # Rust reads 60 bytes: first 24 bytes are pos/vel floats
+        b_data = bytes(data)
+        floats = [struct.unpack("f", b_data[i:i+4])[0] for i in range(0, 24, 4)]
+        self.pos = floats[0:3]
+        self.vel = floats[3:6]
+
+# ---------------------------------------------------------
+# Utility: unzip and XOR like Rust
+# ---------------------------------------------------------
+
+def unzip_bytes(zipped_bytes):
+    with zipfile.ZipFile(io.BytesIO(zipped_bytes), 'r') as z:
+        return z.read(z.namelist()[0])
+
+import hashlib
+
+ROM_HASH = "9bef1128717f958171a4afac3ed78ee2bb4e86ce"
+def check_hash(data: bytes) -> bool:
+    sha1 = hashlib.sha1()
+    sha1.update(data)
+    hash_result = sha1.hexdigest()
+    return hash_result == ROM_HASH
+
+# ---------------------------------------------------------
+# RngConfig class matching Rust
+# ---------------------------------------------------------
+
+class RngConfig:
+    def __init__(self, window_length, random_amount, random_burst_length,
+                 a_prob, b_prob, z_prob):
+        self.window_length = window_length
+        self.random_amount = random_amount
+        self.random_burst_length = random_burst_length
+        self.a_prob = a_prob
+        self.b_prob = b_prob
+        self.z_prob = z_prob
+
+# ---------------------------------------------------------
+# SM64GameGenerator (Python match of Rust version)
+# ---------------------------------------------------------
+
+class SM64GameGenerator:
+    def __init__(self, wasm_bytes):
+        self.wasm_bytes = wasm_bytes
+
+    @staticmethod
+    def new(rom_bytes):
+        if not check_hash(rom_bytes):
+            raise ValueError("Invalid ROM. Should be US z64 (8MB).")
+
+        wasm_bytes = SM64GameGenerator.rom_to_wasm_bytes(rom_bytes)
+        return SM64GameGenerator(wasm_bytes)
+
+    @staticmethod
+    def from_file(path):
+        with open(path, "rb") as f:
+            return SM64GameGenerator.new(f.read())
+
+    @staticmethod
+    def rom_to_wasm_bytes(rom_bytes):
+        rom_len = len(rom_bytes)
+
+        # load XOR bytes exactly like Rust include_bytes!
+
+        base_dir = os.path.dirname(__file__)
+        xor_path = os.path.join(base_dir, "..", "..", "pkg", "sm64_headless.us.wasm.zip.xor")
+
+        with open(xor_path, "rb") as f:
+            xor_bytes = f.read()
+
+        wasm_zip_bytes = bytes([xor_bytes[i] ^ rom_bytes[i % rom_len]
+                                for i in range(len(xor_bytes))])
+
+        return unzip_bytes(wasm_zip_bytes)
+
+    def create_game(self):
+        return SM64Game(self.wasm_bytes)
+
+# ---------------------------------------------------------
+# SM64Game (Python match of Rust version)
+# ---------------------------------------------------------
+
+class SM64Game:
+    def __init__(self, wasm_bytes):
+        self.engine = Engine()
+        self.module = Module(self.engine, wasm_bytes)
+
+        self.store = Store(self.engine)
+        self.linker = Linker(self.engine)
+        self.linker.define_wasi()
+
+        wasi = WasiConfig()
+        wasi.inherit_stdout()
+        self.store.set_wasi(wasi)
+
+        self.instance = self.linker.instantiate(self.store, self.module)
+
+        self.using_rng_flag = False
+
+        # call main_func like Rust does
+        self.instance.exports(self.store)["main_func"](self.store)
+
+        self.memory = self.instance.exports(self.store)["memory"]
+
+    # -----------------------------------------------------
+    # RNG functions
+    # -----------------------------------------------------
+
+    def set_rng_config(self, cfg: RngConfig):
+        self.using_rng_flag = True
+        func = self.instance.exports(self.store)["set_rng_config"]
+        func(self.store,
+            cfg.window_length,
+            cfg.random_amount,
+            cfg.random_burst_length,
+            cfg.a_prob,
+            cfg.b_prob,
+            cfg.z_prob
+        )
+
+    def set_rng_seed(self, seed):
+        self.using_rng_flag = True
+        func = self.instance.exports(self.store)["set_rng_seed"]
+        func(self.store, seed)
+
+    # -----------------------------------------------------
+    # Game stepping + state
+    # -----------------------------------------------------
+
+    def step_game(self, pad: GamePad):
+        func = self.instance.exports(self.store)["step_game"]
+        func(self.store, pad.button, pad.stick_x, pad.stick_y)
+
+    def get_game_state(self):
+        func = self.instance.exports(self.store)["get_game_state"]
+        ptr = func(self.store)
+
+        raw = self.memory.data_ptr(self.store)[ptr:ptr+60]
+        return GameState(raw)
+
+    def rng_pad(self, pad: GamePad):
+        func = self.instance.exports(self.store)["rng_pad"]
+        ptr = func(self.store, pad.button, pad.stick_x, pad.stick_y)
+
+        raw = self.memory.data_ptr(self.store)[ptr:ptr+4]
+        return GamePad.from_bytes(raw)
+
+    def using_rng(self):
+        return self.using_rng_flag

sm64_binds-0.0.1/src/sm64_binds/__init__.py

@@ -0,0 +1 @@
+from .Sm64Game import SM64Game, SM64GameGenerator, GamePad

sm64_binds-0.0.1/src/sm64_binds.egg-info/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: sm64-binds
+Version: 0.0.1
+Summary: Mario 64 using WASM. Requires a US .z64 version ROM to work (8.00MB)
+Author-email: Gumbo64 <gumbo64isme@proton.me>
+License-Expression: MIT
+Project-URL: homepage, https://github.com/Gumbo64/sm64-binds
+Project-URL: repository, https://github.com/Gumbo64/sm64-binds
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+https://github.com/Gumbo64/sm64-binds

sm64_binds-0.0.1/src/sm64_binds.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+src/sm64_binds/Sm64Game.py
+src/sm64_binds/__init__.py
+src/sm64_binds.egg-info/PKG-INFO
+src/sm64_binds.egg-info/SOURCES.txt
+src/sm64_binds.egg-info/dependency_links.txt
+src/sm64_binds.egg-info/top_level.txt

sm64_binds-0.0.1/src/sm64_binds.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sm64_binds-0.0.1/src/sm64_binds.egg-info/top_level.txt

@@ -0,0 +1 @@
+sm64_binds