rngine 0.1.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2026 amine-by
+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.

package/README.md

@@ -0,0 +1,150 @@
+# rngine
+
+A React Native game engine for building 2D games, powered by [Nitro Modules](https://nitro.margelo.com/) for high-performance C++ game logic.
+
+## Installation
+
+```sh
+npm install rngine react-native-nitro-modules
+```
+
+> `react-native-nitro-modules` is required as this library relies on [Nitro Modules](https://nitro.margelo.com/).
+
+## Usage
+
+```tsx
+import { GameEngine, configure, setVelocity } from 'rngine';
+
+configure({
+  tickRate: 60,
+  world: { width: 800, height: 800, color: '#1a1a1a' },
+  entities: [
+    {
+      id: 'player',
+      px: 400,
+      py: 400,
+      width: 40,
+      height: 40,
+      color: '#00ff00',
+      vx: 0,
+      vy: 0,
+    },
+    {
+      id: 'enemy_1',
+      px: 100,
+      py: 100,
+      width: 40,
+      height: 40,
+      color: '#ff0000',
+      vx: 1000,
+      vy: 0,
+    },
+    {
+      id: 'enemy_2',
+      px: 200,
+      py: 200,
+      width: 40,
+      height: 40,
+      color: '#ff0000',
+      vx: -1000,
+      vy: 0,
+    },
+  ],
+  systems: [
+    {
+      // runs every tick for all enemies
+      ids: ['enemy'],
+      onTick: (enemies) => {
+        enemies.forEach((enemy) => {
+          // reverse direction when reaching world edges
+          if (enemy.px <= 0 || enemy.px + enemy.width >= 800) {
+            setVelocity(enemy.id, -enemy.vx, enemy.vy);
+          }
+        });
+      },
+    },
+  ],
+  paused: false,
+});
+
+export default function App() {
+  return <GameEngine style={{ flex: 1 }} />;
+}
+```
+
+## Concepts
+
+**Entities** are the objects in your game world. Each entity has a position, size, color, and velocity. See [`Entity`](./src/types.ts).
+
+**Systems** define your game logic. Each system declares which entities it cares about via `ids` and runs every tick receiving those entities. See [`System`](./src/types.ts).
+
+**World** defines the game world dimensions and background color. Entities outside the world bounds are automatically clipped. See [`World`](./src/types.ts).
+
+## Entity Querying
+
+Entity ids use `_` as a hierarchy separator, which enables prefix matching in systems and functions like `setVelocity`. Querying `'enemy'` matches all entities whose id starts with `enemy_`. So `enemy_1`, `enemy_magician_1`, and `enemy_warrior_2` are all returned. Querying `'enemy_magician'` narrows it down to only magician entities. Querying `'enemy_magician_1'` is an exact match.
+
+This makes it easy to build entity groups naturally through naming. No extra configuration needed.
+
+```ts
+// matches enemy_1, enemy_magician_1, enemy_warrior_2
+{ ids: ['enemy'], onTick: (entities) => {} }
+
+// matches only enemy_magician_1, enemy_magician_2
+{ ids: ['enemy_magician'], onTick: (entities) => {} }
+
+// exact match
+{ ids: ['enemy_magician_1'], onTick: (entities) => {} }
+```
+
+## API
+
+### `configure(config)`
+
+Sets up the game engine. Call this before anything else.
+
+| param      | required | type       | default | description                           |
+| ---------- | -------- | ---------- | ------- | ------------------------------------- |
+| `tickRate` | ✓        | `number`   | —       | Game logic updates per second         |
+| `world`    | ✓        | `World`    | —       | World dimensions and background color |
+| `entities` |          | `Entity[]` | `[]`    | Initial entities to spawn             |
+| `systems`  |          | `System[]` | `[]`    | Systems to run each tick              |
+| `paused`   |          | `boolean`  | `true`  | Whether to start paused               |
+
+### `spawn(entity | entity[])`
+
+Spawns one or more entities into the world. Skips duplicates by id.
+
+### `despawn(id)`
+
+Removes the entity with the given id, or all entities matching the given prefix.
+
+### `setPosition(id, px, py)`
+
+Sets the position of a single entity. Requires an exact id.
+
+### `setVelocity(id, vx, vy)`
+
+Sets the velocity of all entities matching the given id or prefix.
+
+### `pause()`
+
+Pauses the game loop. Systems stop running.
+
+### `resume()`
+
+Resumes the game loop.
+
+## Contributing
+
+- [Development workflow](CONTRIBUTING.md#development-workflow)
+- [Sending a pull request](CONTRIBUTING.md#sending-a-pull-request)
+- [Code of conduct](CODE_OF_CONDUCT.md)
+
+## License
+
+MIT
+
+---
+
+Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)

package/Rngine.podspec

@@ -0,0 +1,29 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "Rngine"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/amine-by/rngine.git", :tag => "#{s.version}" }
+
+  s.source_files = [
+    "ios/**/*.{swift}",
+    "ios/**/*.{m,mm}",
+    "cpp/**/*.{hpp,cpp}",
+  ]
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+
+  load 'nitrogen/generated/ios/Rngine+autolinking.rb'
+  add_nitrogen_files(s)
+
+  install_modules_dependencies(s)
+end

package/android/CMakeLists.txt

@@ -0,0 +1,31 @@
+project(rngine)
+cmake_minimum_required(VERSION 3.9.0)
+
+set(PACKAGE_NAME rngine)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 20)
+
+# Define C++ library and add all sources
+add_library(
+        ${PACKAGE_NAME}
+        SHARED
+        src/main/cpp/cpp-adapter.cpp
+        src/main/cpp/GameLoopJNI.cpp
+        ../shared/GameLoop.cpp
+        ../shared/GameMethods.cpp
+)
+
+# Add Nitrogen specs :)
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/rngine+autolinking.cmake)
+
+# Set up local includes
+include_directories("src/main/cpp" "../shared")
+
+find_library(LOG_LIB log)
+
+# Link all libraries together
+target_link_libraries(
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        android # <-- Android core
+)

package/android/build.gradle

@@ -0,0 +1,118 @@
+buildscript {
+  ext.Rngine = [
+    kotlinVersion: "2.0.21",
+    minSdkVersion: 24,
+    compileSdkVersion: 36,
+    targetSdkVersion: 36
+  ]
+
+  ext.getExtOrDefault = { prop ->
+    if (rootProject.ext.has(prop)) {
+      return rootProject.ext.get(prop)
+    }
+
+    return Rngine[prop]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+apply from: '../nitrogen/generated/android/rngine+autolinking.gradle'
+
+apply plugin: "com.facebook.react"
+
+android {
+  namespace "com.margelo.nitro.rngine"
+
+  compileSdkVersion getExtOrDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrDefault("minSdkVersion")
+    targetSdkVersion getExtOrDefault("targetSdkVersion")
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+      "META-INF",
+      "META-INF/**",
+      "**/libc++_shared.so",
+      "**/libfbjni.so",
+      "**/libjsi.so",
+      "**/libfolly_json.so",
+      "**/libfolly_runtime.so",
+      "**/libglog.so",
+      "**/libhermes.so",
+      "**/libhermes-executor-debug.so",
+      "**/libhermes_executor.so",
+      "**/libreactnative.so",
+      "**/libreactnativejni.so",
+      "**/libturbomodulejsijni.so",
+      "**/libreact_nativemodule_core.so",
+      "**/libjscexecutor.so"
+    ]
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lint {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation project(":react-native-nitro-modules")
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/cpp/GameLoopJNI.cpp

@@ -0,0 +1,31 @@
+#include "GameLoop.hpp"
+#include <jni.h>
+
+extern "C" {
+JNIEXPORT jobject JNICALL
+Java_com_margelo_nitro_rngine_GameView_getRectsSnapshot(JNIEnv *env, jobject) {
+  auto rects =
+      margelo::nitro::rngine::GameLoop::getInstance().getRectsSnapshot();
+  const size_t size = rects.size() * margelo::nitro::rngine::RECT_SIZE;
+
+  static std::vector<uint8_t> buffer;
+  buffer.resize(size);
+
+  uint8_t *data = buffer.data();
+
+  for (const auto &rect : rects) {
+    memcpy(data, &rect.left, sizeof(double));
+    data += sizeof(double);
+    memcpy(data, &rect.right, sizeof(double));
+    data += sizeof(double);
+    memcpy(data, &rect.top, sizeof(double));
+    data += sizeof(double);
+    memcpy(data, &rect.bottom, sizeof(double));
+    data += sizeof(double);
+    memcpy(data, &rect.color,  sizeof(uint32_t));
+    data += sizeof(uint32_t);
+  }
+
+  return env->NewDirectByteBuffer(buffer.data(), (jlong)size);
+}
+} // extern "C"

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,11 @@
+#include <jni.h>
+#include "rngineOnLoad.hpp"
+
+#include <fbjni/fbjni.h>
+
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return facebook::jni::initialize(vm, []() {
+    margelo::nitro::rngine::registerAllNatives();
+  });
+}

package/android/src/main/java/com/margelo/nitro/rngine/GameEngine.kt

@@ -0,0 +1,34 @@
+package com.margelo.nitro.rngine
+
+import android.os.Handler
+import android.os.HandlerThread
+import android.view.Choreographer
+import com.facebook.react.uimanager.ThemedReactContext
+
+class GameEngine(val context: ThemedReactContext) : HybridGameEngineSpec() {
+  private var renderThread: HandlerThread? = null
+  private var renderHandler: Handler? = null
+
+  private val frameCallback = object : Choreographer.FrameCallback {
+    override fun doFrame(frameTimeNanos: Long) {
+      renderHandler?.post { view.drawFrame() }
+      Choreographer.getInstance().postFrameCallback(this)
+    }
+  }
+
+  override val view: GameView = GameView(
+    context
+  ).apply {
+    onAttached = {
+      renderThread = HandlerThread("RenderThread").also { it.start() }
+      renderHandler = Handler(renderThread!!.looper)
+      Choreographer.getInstance().postFrameCallback(frameCallback)
+    }
+    onDetached = {
+      Choreographer.getInstance().removeFrameCallback(frameCallback)
+      renderThread?.quitSafely()
+      renderThread = null
+      renderHandler = null
+    }
+  }
+}

package/android/src/main/java/com/margelo/nitro/rngine/GameView.kt

@@ -0,0 +1,63 @@
+package com.margelo.nitro.rngine
+
+import android.content.Context
+import android.graphics.Color
+import android.graphics.Paint
+import android.util.AttributeSet
+import android.view.SurfaceView
+import android.view.View
+import java.nio.ByteBuffer
+
+class GameView(
+  context: Context,
+  attrs: AttributeSet? = null,
+  defStyleAttr: Int = 0,
+) : SurfaceView(
+  context,
+  attrs,
+  defStyleAttr,
+) {
+  private external fun getRectsSnapshot(): ByteBuffer
+  var onAttached: () -> Unit = {}
+  var onDetached: () -> Unit = {}
+
+  private val paint = Paint().apply {
+    color = Color.TRANSPARENT
+    style = Paint.Style.FILL
+  }
+
+  init {
+    addOnAttachStateChangeListener(
+      object : OnAttachStateChangeListener {
+        override fun onViewAttachedToWindow(view: View) = onAttached()
+        override fun onViewDetachedFromWindow(view: View) = onDetached()
+      })
+  }
+
+  fun drawFrame() {
+    if (!holder.surface.isValid) return
+    val canvas = holder.lockCanvas() ?: return
+
+    val rects = RectSerializer.decode(getRectsSnapshot())
+
+    val worldRect = rects.first()
+    val scaleX = canvas.width / worldRect.right.toFloat()
+    val scaleY = canvas.height / worldRect.bottom.toFloat()
+    val scale = minOf(scaleX, scaleY)
+
+    val offsetX = (canvas.width - worldRect.right.toFloat() * scale) / 2f
+    val offsetY = (canvas.height - worldRect.bottom.toFloat() * scale) / 2f
+
+    rects.forEach { rect ->
+      paint.color = rect.color
+      canvas.drawRect(
+        rect.left.toFloat() * scale + offsetX,
+        rect.top.toFloat() * scale + offsetY,
+        rect.right.toFloat() * scale + offsetX,
+        rect.bottom.toFloat() * scale + offsetY,
+        paint
+      )
+    }
+    holder.unlockCanvasAndPost(canvas)
+  }
+}

package/android/src/main/java/com/margelo/nitro/rngine/Rect.kt

@@ -0,0 +1,9 @@
+package com.margelo.nitro.rngine
+
+data class Rect(
+  val left: Double,
+  val right: Double,
+  val top: Double,
+  val bottom: Double,
+  val color: Int
+)

package/android/src/main/java/com/margelo/nitro/rngine/RectSerializer.kt

@@ -0,0 +1,23 @@
+package com.margelo.nitro.rngine
+
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+
+object RectSerializer {
+  private const val RECT_SIZE = 4 * 8 + 4
+  fun decode(buffer: ByteBuffer): ArrayList<Rect> {
+    buffer.order(ByteOrder.nativeOrder())
+    val rects = ArrayList<Rect>()
+
+    while (buffer.remaining() >= RECT_SIZE) {
+      val left = buffer.double
+      val right = buffer.double
+      val top = buffer.double
+      val bottom = buffer.double
+      val color = buffer.int
+
+      rects.add(Rect(left, right, top, bottom, color))
+    }
+    return rects
+  }
+}

package/android/src/main/java/com/margelo/nitro/rngine/RnginePackage.kt

@@ -0,0 +1,29 @@
+package com.margelo.nitro.rngine
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.uimanager.ViewManager
+
+import com.margelo.nitro.rngine.views.HybridGameEngineManager
+
+class RnginePackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return null
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider { HashMap() }
+  }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return listOf(HybridGameEngineManager())
+  }
+
+  companion object {
+    init {
+      System.loadLibrary("rngine")
+    }
+  }
+}

package/ios/Rngine.swift

@@ -0,0 +1,28 @@
+class HybridRngine : HybridRngineSpec {
+
+  // UIView
+  var view: UIView = UIView()
+
+  // props
+  var color: String = "#000" {
+    didSet {
+      view.backgroundColor = hexStringToUIColor(hexColor: color)
+    }
+  }
+  
+  func hexStringToUIColor(hexColor: String) -> UIColor {
+    let stringScanner = Scanner(string: hexColor)
+
+    if(hexColor.hasPrefix("#")) {
+      stringScanner.scanLocation = 1
+    }
+    var color: UInt32 = 0
+    stringScanner.scanHexInt32(&color)
+
+    let r = CGFloat(Int(color >> 16) & 0x000000FF)
+    let g = CGFloat(Int(color >> 8) & 0x000000FF)
+    let b = CGFloat(Int(color) & 0x000000FF)
+
+    return UIColor(red: r / 255.0, green: g / 255.0, blue: b / 255.0, alpha: 1)
+  }  
+}

package/lib/module/GameEngine.js

@@ -0,0 +1,15 @@
+"use strict";
+
+import { getHostComponent } from 'react-native-nitro-modules';
+const GameEngineConfig = require('../nitrogen/generated/shared/json/GameEngineConfig.json');
+/**
+ * A game engine view component that renders the game world.
+ * Size it using the style prop like any other React Native view.
+ *
+ * @example
+ * ```tsx
+ * <GameEngine style={{ flex: 1 }} />
+ * ```
+ */
+export default getHostComponent('GameEngine', () => GameEngineConfig);
+//# sourceMappingURL=GameEngine.js.map

package/lib/module/GameEngine.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["getHostComponent","GameEngineConfig","require"],"sourceRoot":"../../src","sources":["GameEngine.tsx"],"mappings":";;AAAA,SAASA,gBAAgB,QAAQ,4BAA4B;AAC7D,MAAMC,gBAAgB,GAAGC,OAAO,CAAC,yDAAyD,CAAC;AAG3F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAeF,gBAAgB,CAC7B,YAAY,EACZ,MAAMC,gBACR,CAAC","ignoreList":[]}

package/lib/module/GameEngine.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=GameEngine.nitro.js.map

package/lib/module/GameEngine.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["GameEngine.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/module/GameMethods.js

@@ -0,0 +1,44 @@
+"use strict";
+
+import { NitroModules } from 'react-native-nitro-modules';
+const gameMethods = NitroModules.createHybridObject('GameMethods');
+
+/** Sets up the game engine with the given configuration. Call this before anything else. */
+export function configure({
+  tickRate,
+  world,
+  entities = [],
+  systems = [],
+  paused = true
+}) {
+  gameMethods.setTickRate(tickRate);
+  gameMethods.setWorld(world);
+  gameMethods.setEntities(entities);
+  gameMethods.setSystems(systems);
+  if (paused) {
+    gameMethods.pause();
+  } else {
+    gameMethods.resume();
+  }
+}
+
+/** Pauses the game loop. Systems will stop running. */
+export const pause = () => gameMethods.pause();
+
+/** Resumes the game loop. */
+export const resume = () => gameMethods.resume();
+
+/** Spawns one or more entities into the world. Skips duplicates by id. */
+export const spawn = entities => {
+  gameMethods.spawn(Array.isArray(entities) ? entities : [entities]);
+};
+
+/** Removes an entity or all entities matching the given id prefix from the world. */
+export const despawn = id => gameMethods.despawn(id);
+
+/** Sets the position of the entity with the exact given id. */
+export const setPosition = (id, px, py) => gameMethods.setP(id, px, py);
+
+/** Sets the velocity of all entities matching the given id or prefix. */
+export const setVelocity = (id, vx, vy) => gameMethods.setV(id, vx, vy);
+//# sourceMappingURL=GameMethods.js.map

package/lib/module/GameMethods.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NitroModules","gameMethods","createHybridObject","configure","tickRate","world","entities","systems","paused","setTickRate","setWorld","setEntities","setSystems","pause","resume","spawn","Array","isArray","despawn","id","setPosition","px","py","setP","setVelocity","vx","vy","setV"],"sourceRoot":"../../src","sources":["GameMethods.ts"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAIzD,MAAMC,WAAW,GAAGD,YAAY,CAACE,kBAAkB,CAAc,aAAa,CAAC;;AAE/E;AACA,OAAO,SAASC,SAASA,CAAC;EACxBC,QAAQ;EACRC,KAAK;EACLC,QAAQ,GAAG,EAAE;EACbC,OAAO,GAAG,EAAE;EACZC,MAAM,GAAG;AACH,CAAC,EAAE;EACTP,WAAW,CAACQ,WAAW,CAACL,QAAQ,CAAC;EACjCH,WAAW,CAACS,QAAQ,CAACL,KAAK,CAAC;EAC3BJ,WAAW,CAACU,WAAW,CAACL,QAAQ,CAAC;EACjCL,WAAW,CAACW,UAAU,CAACL,OAAO,CAAC;EAC/B,IAAIC,MAAM,EAAE;IACVP,WAAW,CAACY,KAAK,CAAC,CAAC;EACrB,CAAC,MAAM;IACLZ,WAAW,CAACa,MAAM,CAAC,CAAC;EACtB;AACF;;AAEA;AACA,OAAO,MAAMD,KAAK,GAAGA,CAAA,KAAMZ,WAAW,CAACY,KAAK,CAAC,CAAC;;AAE9C;AACA,OAAO,MAAMC,MAAM,GAAGA,CAAA,KAAMb,WAAW,CAACa,MAAM,CAAC,CAAC;;AAEhD;AACA,OAAO,MAAMC,KAAK,GAAIT,QAA2B,IAAK;EACpDL,WAAW,CAACc,KAAK,CAACC,KAAK,CAACC,OAAO,CAACX,QAAQ,CAAC,GAAGA,QAAQ,GAAG,CAACA,QAAQ,CAAC,CAAC;AACpE,CAAC;;AAED;AACA,OAAO,MAAMY,OAAO,GAAIC,EAAU,IAAKlB,WAAW,CAACiB,OAAO,CAACC,EAAE,CAAC;;AAE9D;AACA,OAAO,MAAMC,WAAW,GAAGA,CAACD,EAAU,EAAEE,EAAU,EAAEC,EAAU,KAC5DrB,WAAW,CAACsB,IAAI,CAACJ,EAAE,EAAEE,EAAE,EAAEC,EAAE,CAAC;;AAE9B;AACA,OAAO,MAAME,WAAW,GAAGA,CAACL,EAAU,EAAEM,EAAU,EAAEC,EAAU,KAC5DzB,WAAW,CAAC0B,IAAI,CAACR,EAAE,EAAEM,EAAE,EAAEC,EAAE,CAAC","ignoreList":[]}

package/lib/module/GameMethods.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=GameMethods.nitro.js.map

package/lib/module/GameMethods.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["GameMethods.nitro.ts"],"mappings":"","ignoreList":[]}