rngine 0.1.0

package/nitrogen/generated/shared/c++/World.hpp

@@ -0,0 +1,91 @@
+///
+/// World.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+
+namespace margelo::nitro::rngine {
+
+  /**
+   * A struct which can be represented as a JavaScript object (World).
+   */
+  struct World final {
+  public:
+    double width     SWIFT_PRIVATE;
+    double height     SWIFT_PRIVATE;
+    std::string color     SWIFT_PRIVATE;
+
+  public:
+    World() = default;
+    explicit World(double width, double height, std::string color): width(width), height(height), color(color) {}
+
+  public:
+    friend bool operator==(const World& lhs, const World& rhs) = default;
+  };
+
+} // namespace margelo::nitro::rngine
+
+namespace margelo::nitro {
+
+  // C++ World <> JS World (object)
+  template <>
+  struct JSIConverter<margelo::nitro::rngine::World> final {
+    static inline margelo::nitro::rngine::World fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::rngine::World(
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "width"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "height"))),
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "color")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::rngine::World& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "width"), JSIConverter<double>::toJSI(runtime, arg.width));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "height"), JSIConverter<double>::toJSI(runtime, arg.height));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "color"), JSIConverter<std::string>::toJSI(runtime, arg.color));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "width")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "height")))) return false;
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "color")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/views/HybridGameEngineComponent.cpp

@@ -0,0 +1,72 @@
+///
+/// HybridGameEngineComponent.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridGameEngineComponent.hpp"
+
+#include <string>
+#include <exception>
+#include <utility>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JSIConverter.hpp>
+#include <NitroModules/PropNameIDCache.hpp>
+#include <react/renderer/core/RawValue.h>
+#include <react/renderer/core/ShadowNode.h>
+#include <react/renderer/core/ComponentDescriptor.h>
+#include <react/renderer/components/view/ViewProps.h>
+
+namespace margelo::nitro::rngine::views {
+
+  extern const char HybridGameEngineComponentName[] = "GameEngine";
+
+  HybridGameEngineProps::HybridGameEngineProps(const react::PropsParserContext& context,
+                                               const HybridGameEngineProps& sourceProps,
+                                               const react::RawProps& rawProps):
+    react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
+    hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridGameEngineSpec>& /* ref */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("hybridRef", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.hybridRef;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridGameEngineSpec>& /* ref */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, PropNameIDCache::get(*runtime, "f")), sourceProps.hybridRef);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("GameEngine.hybridRef: ") + exc.what());
+      }
+    }()) { }
+
+  bool HybridGameEngineProps::filterObjectKeys(const std::string& propName) {
+    switch (hashString(propName)) {
+      case hashString("hybridRef"): return true;
+      default: return false;
+    }
+  }
+
+  HybridGameEngineComponentDescriptor::HybridGameEngineComponentDescriptor(const react::ComponentDescriptorParameters& parameters)
+    : ConcreteComponentDescriptor(parameters,
+                                  react::RawPropsParser(/* enableJsiParser */ true)) {}
+
+  std::shared_ptr<const react::Props> HybridGameEngineComponentDescriptor::cloneProps(const react::PropsParserContext& context,
+                                                                                      const std::shared_ptr<const react::Props>& props,
+                                                                                      react::RawProps rawProps) const {
+    // 1. Prepare raw props parser
+    rawProps.parse(rawPropsParser_);
+    // 2. Copy props with Nitro's cached copy constructor
+    return HybridGameEngineShadowNode::Props(context, /* & */ rawProps, props);
+  }
+
+#ifdef ANDROID
+  void HybridGameEngineComponentDescriptor::adopt(react::ShadowNode& shadowNode) const {
+    // This is called immediately after `ShadowNode` is created, cloned or in progress.
+    // On Android, we need to wrap props in our state, which gets routed through Java and later unwrapped in JNI/C++.
+    auto& concreteShadowNode = static_cast<HybridGameEngineShadowNode&>(shadowNode);
+    const std::shared_ptr<const HybridGameEngineProps>& constProps = concreteShadowNode.getConcreteSharedProps();
+    const std::shared_ptr<HybridGameEngineProps>& props = std::const_pointer_cast<HybridGameEngineProps>(constProps);
+    HybridGameEngineState state{props};
+    concreteShadowNode.setStateData(std::move(state));
+  }
+#endif
+
+} // namespace margelo::nitro::rngine::views

package/nitrogen/generated/shared/c++/views/HybridGameEngineComponent.hpp

@@ -0,0 +1,109 @@
+///
+/// HybridGameEngineComponent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <optional>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/NitroHash.hpp>
+#include <NitroModules/CachedProp.hpp>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/components/view/ViewProps.h>
+
+#include <memory>
+#include "HybridGameEngineSpec.hpp"
+#include <functional>
+#include <optional>
+
+namespace margelo::nitro::rngine::views {
+
+  using namespace facebook;
+
+  /**
+   * The name of the actual native View.
+   */
+  extern const char HybridGameEngineComponentName[];
+
+  /**
+   * Props for the "GameEngine" View.
+   */
+  class HybridGameEngineProps final: public react::ViewProps {
+  public:
+    HybridGameEngineProps() = default;
+    HybridGameEngineProps(const react::PropsParserContext& context,
+                          const HybridGameEngineProps& sourceProps,
+                          const react::RawProps& rawProps);
+
+  public:
+    CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridGameEngineSpec>& /* ref */)>>> hybridRef;
+
+  private:
+    static bool filterObjectKeys(const std::string& propName);
+  };
+
+  /**
+   * State for the "GameEngine" View.
+   */
+  class HybridGameEngineState final {
+  public:
+    HybridGameEngineState() = default;
+    explicit HybridGameEngineState(const std::shared_ptr<HybridGameEngineProps>& props):
+      _props(props) {}
+
+  public:
+    [[nodiscard]]
+    const std::shared_ptr<HybridGameEngineProps>& getProps() const {
+      return _props;
+    }
+
+  public:
+#ifdef ANDROID
+  HybridGameEngineState(const HybridGameEngineState& /* previousState */, folly::dynamic /* data */) {}
+  folly::dynamic getDynamic() const {
+    throw std::runtime_error("HybridGameEngineState does not support folly!");
+  }
+  react::MapBuffer getMapBuffer() const {
+    throw std::runtime_error("HybridGameEngineState does not support MapBuffer!");
+  };
+#endif
+
+  private:
+    std::shared_ptr<HybridGameEngineProps> _props;
+  };
+
+  /**
+   * The Shadow Node for the "GameEngine" View.
+   */
+  using HybridGameEngineShadowNode = react::ConcreteViewShadowNode<HybridGameEngineComponentName /* "HybridGameEngine" */,
+                                                                   HybridGameEngineProps /* custom props */,
+                                                                   react::ViewEventEmitter /* default */,
+                                                                   HybridGameEngineState /* custom state */>;
+
+  /**
+   * The Component Descriptor for the "GameEngine" View.
+   */
+  class HybridGameEngineComponentDescriptor final: public react::ConcreteComponentDescriptor<HybridGameEngineShadowNode> {
+  public:
+    explicit HybridGameEngineComponentDescriptor(const react::ComponentDescriptorParameters& parameters);
+
+  public:
+    /**
+     * A faster path for cloning props - reuses the caching logic from `HybridGameEngineProps`.
+     */
+    std::shared_ptr<const react::Props> cloneProps(const react::PropsParserContext& context,
+                                                   const std::shared_ptr<const react::Props>& props,
+                                                   react::RawProps rawProps) const override;
+#ifdef ANDROID
+    void adopt(react::ShadowNode& shadowNode) const override;
+#endif
+  };
+
+  /* The actual view for "GameEngine" needs to be implemented in platform-specific code. */
+
+} // namespace margelo::nitro::rngine::views

package/nitrogen/generated/shared/json/GameEngineConfig.json

@@ -0,0 +1,9 @@
+{
+  "uiViewClassName": "GameEngine",
+  "supportsRawText": false,
+  "bubblingEventTypes": {},
+  "directEventTypes": {},
+  "validAttributes": {
+    "hybridRef": true
+  }
+}

package/package.json

@@ -0,0 +1,180 @@
+{
+  "name": "rngine",
+  "version": "0.1.0",
+  "description": "React native library for building 2d games",
+  "main": "./lib/module/index.js",
+  "types": "./lib/typescript/src/index.d.ts",
+  "exports": {
+    ".": {
+      "source": "./src/index.tsx",
+      "types": "./lib/typescript/src/index.d.ts",
+      "default": "./lib/module/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "lib",
+    "android",
+    "ios",
+    "cpp",
+    "nitrogen",
+    "nitro.json",
+    "*.podspec",
+    "react-native.config.js",
+    "!ios/build",
+    "!android/build",
+    "!android/gradle",
+    "!android/gradlew",
+    "!android/gradlew.bat",
+    "!android/local.properties",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__",
+    "!**/.*"
+  ],
+  "scripts": {
+    "example": "yarn workspace rngine-example",
+    "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build lib",
+    "prepare": "bob build",
+    "nitrogen": "nitrogen",
+    "typecheck": "tsc",
+    "lint": "eslint \"**/*.{js,ts,tsx}\"",
+    "test": "jest",
+    "release": "release-it --only-version",
+    "web": "vite",
+    "build:web": "vite build"
+  },
+  "keywords": [
+    "react-native",
+    "ios",
+    "android"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/amine-by/rngine.git"
+  },
+  "author": "amine-by <aminebenyedder@outlook.com> (https://github.com/amine-by)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/amine-by/rngine/issues"
+  },
+  "homepage": "https://github.com/amine-by/rngine#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@commitlint/config-conventional": "^20.5.0",
+    "@eslint/compat": "^2.0.3",
+    "@eslint/eslintrc": "^3.3.5",
+    "@eslint/js": "^10.0.1",
+    "@jest/globals": "^30.0.0",
+    "@react-native/babel-preset": "0.85.0",
+    "@react-native/eslint-config": "0.85.0",
+    "@react-native/jest-preset": "0.85.0",
+    "@release-it/conventional-changelog": "^10.0.6",
+    "@types/react": "^19.2.0",
+    "commitlint": "^20.5.0",
+    "del-cli": "^7.0.0",
+    "eslint": "^9.39.4",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-ft-flow": "^3.0.11",
+    "eslint-plugin-prettier": "^5.5.5",
+    "jest": "^30.3.0",
+    "lefthook": "^2.1.4",
+    "nitrogen": "^0.35.3",
+    "prettier": "^3.8.1",
+    "react": "19.2.3",
+    "react-native": "0.85.0",
+    "react-native-builder-bob": "^0.41.0",
+    "react-native-nitro-modules": "^0.35.3",
+    "react-native-web": "~0.21.1",
+    "release-it": "^19.2.4",
+    "turbo": "^2.8.21",
+    "typescript": "^6.0.2"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*",
+    "react-native-nitro-modules": "^0.35.3"
+  },
+  "workspaces": [
+    "example"
+  ],
+  "packageManager": "yarn@4.11.0",
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      [
+        "custom",
+        {
+          "script": "nitrogen",
+          "clean": "nitrogen/"
+        }
+      ],
+      [
+        "module",
+        {
+          "esm": true
+        }
+      ],
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  },
+  "prettier": {
+    "quoteProps": "consistent",
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "es5",
+    "useTabs": false
+  },
+  "jest": {
+    "preset": "@react-native/jest-preset",
+    "modulePathIgnorePatterns": [
+      "<rootDir>/example/node_modules",
+      "<rootDir>/lib/"
+    ]
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
+  "release-it": {
+    "git": {
+      "commitMessage": "chore: release ${version}",
+      "tagName": "v${version}"
+    },
+    "npm": {
+      "publish": true
+    },
+    "github": {
+      "release": true
+    },
+    "plugins": {
+      "@release-it/conventional-changelog": {
+        "preset": {
+          "name": "angular"
+        }
+      }
+    }
+  },
+  "create-react-native-library": {
+    "type": "nitro-view",
+    "languages": "kotlin-swift",
+    "tools": [
+      "eslint",
+      "jest",
+      "lefthook",
+      "release-it",
+      "vite"
+    ],
+    "version": "0.61.0"
+  }
+}

package/src/GameEngine.nitro.ts

@@ -0,0 +1,10 @@
+import type {
+  HybridView,
+  HybridViewMethods,
+  HybridViewProps,
+} from 'react-native-nitro-modules';
+
+export interface GameEngineProps extends HybridViewProps {}
+export interface GameEngineMethods extends HybridViewMethods {}
+
+export type GameEngine = HybridView<GameEngineProps, GameEngineMethods>;

package/src/GameEngine.tsx

@@ -0,0 +1,17 @@
+import { getHostComponent } from 'react-native-nitro-modules';
+const GameEngineConfig = require('../nitrogen/generated/shared/json/GameEngineConfig.json');
+import type { GameEngineMethods, GameEngineProps } from './GameEngine.nitro';
+
+/**
+ * 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<GameEngineProps, GameEngineMethods>(
+  'GameEngine',
+  () => GameEngineConfig
+);

package/src/GameMethods.nitro.ts

@@ -0,0 +1,18 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { Entity, System, World } from './types';
+
+export interface GameMethods extends HybridObject<{
+  ios: 'c++';
+  android: 'c++';
+}> {
+  setTickRate(tickRate: number): void;
+  setWorld(world: World): void;
+  setEntities(entities: Entity[]): void;
+  setSystems(systems: System[]): void;
+  pause(): void;
+  resume(): void;
+  spawn(entities: Entity[]): void;
+  despawn(id: string): void;
+  setP(id: string, px: number, py: number): void;
+  setV(id: string, vx: number, vy: number): void;
+}

package/src/GameMethods.ts

@@ -0,0 +1,46 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import type { GameMethods } from './GameMethods.nitro';
+import type { Config, Entity } from './types';
+
+const gameMethods = NitroModules.createHybridObject<GameMethods>('GameMethods');
+
+/** Sets up the game engine with the given configuration. Call this before anything else. */
+export function configure({
+  tickRate,
+  world,
+  entities = [],
+  systems = [],
+  paused = true,
+}: Config) {
+  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: Entity | Entity[]) => {
+  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: string) => gameMethods.despawn(id);
+
+/** Sets the position of the entity with the exact given id. */
+export const setPosition = (id: string, px: number, py: number) =>
+  gameMethods.setP(id, px, py);
+
+/** Sets the velocity of all entities matching the given id or prefix. */
+export const setVelocity = (id: string, vx: number, vy: number) =>
+  gameMethods.setV(id, vx, vy);

package/src/index.tsx

@@ -0,0 +1,21 @@
+import GameEngine from './GameEngine';
+import {
+  configure,
+  pause,
+  resume,
+  spawn,
+  despawn,
+  setPosition,
+  setVelocity,
+} from './GameMethods';
+
+export {
+  GameEngine,
+  configure,
+  pause,
+  resume,
+  spawn,
+  despawn,
+  setPosition,
+  setVelocity,
+};

package/src/types.ts

@@ -0,0 +1,50 @@
+export type World = {
+  /** Width of the world in game units. */
+  width: number;
+  /** Height of the world in game units. */
+  height: number;
+  /** Background color of the world as a hex string e.g. `'#1a1a1a'`. */
+  color: string;
+};
+
+export type Entity = {
+  /** Unique identifier. Use `_` as a separator for group queries e.g. `'enemy_1'`. */
+  id: string;
+  /** X position in game units. */
+  px: number;
+  /** Y position in game units. */
+  py: number;
+  /** Width in game units. */
+  width: number;
+  /** Height in game units. */
+  height: number;
+  /** Fill color as a hex string e.g. `'#00ff00'`. */
+  color: string;
+  /** Velocity on the X axis in game units per second. */
+  vx: number;
+  /** Velocity on the Y axis in game units per second. */
+  vy: number;
+};
+
+export type System = {
+  /** Entity ids or prefixes this system subscribes to. */
+  ids: string[];
+  /** Called every tick with the resolved entities. */
+  onTick: (entities: Entity[]) => void;
+};
+
+export type Config = {
+  /** Number of game logic updates per second. */
+  tickRate: number;
+  /** World dimensions and background color. */
+  world: World;
+  /** Initial entities to spawn. */
+  entities?: Entity[];
+  /**
+   * Systems that define the game logic. Each system runs every tick
+   * and receives the entities matching its ids.
+   */
+  systems?: System[];
+  /** Whether to start paused. Defaults to true. */
+  paused?: boolean;
+};