rngine 0.1.0 → 0.2.1

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rngine",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "React native library for building 2d games",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
@@ -17,7 +17,7 @@
     "lib",
     "android",
     "ios",
-    "cpp",
+    "shared",
     "nitrogen",
     "nitro.json",
     "*.podspec",
@@ -36,7 +36,7 @@
   "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",
+    "prepare": "bob build && node scripts/nitrogen-patch.js",
     "nitrogen": "nitrogen",
     "typecheck": "tsc",
     "lint": "eslint \"**/*.{js,ts,tsx}\"",

package/shared/ColorUtils.hpp

@@ -0,0 +1,25 @@
+#pragma once
+#include <stdexcept>
+#include <string>
+
+namespace margelo::nitro::rngine {
+
+inline uint32_t parseHexColor(const std::string &color) {
+  if (color.empty() || color[0] != '#') {
+    throw std::invalid_argument("Only hex colors supported");
+  }
+  std::string hex = color.substr(1);
+  if (hex.size() == 6) {
+    return 0xFF000000 | std::stoul(hex, nullptr, 16);
+  } else if (hex.size() == 8) {
+    uint32_t rgba = std::stoul(hex, nullptr, 16);
+    uint32_t r = (rgba >> 24) & 0xFF;
+    uint32_t g = (rgba >> 16) & 0xFF;
+    uint32_t b = (rgba >> 8) & 0xFF;
+    uint32_t a = rgba & 0xFF;
+    return (a << 24) | (r << 16) | (g << 8) | b;
+  }
+  throw std::invalid_argument("Invalid hex color: " + color);
+}
+
+} // namespace margelo::nitro::rngine

package/shared/GameLoop.cpp

@@ -0,0 +1,161 @@
+#include "GameLoop.hpp"
+#include "ColorUtils.hpp"
+#include "Entity.hpp"
+#include <android/log.h>
+#include <chrono>
+#include <cinttypes>
+
+namespace margelo::nitro::rngine {
+
+GameLoop &GameLoop::getInstance() {
+  static GameLoop instance;
+  return instance;
+}
+
+GameLoop::GameLoop() {
+  __android_log_print(ANDROID_LOG_INFO, "GameLoop",
+                      "Constructor - Starting game thread");
+  _gameThread = std::make_unique<std::thread>(&GameLoop::runGameLoop, this);
+}
+
+GameLoop::~GameLoop() {
+  __android_log_print(ANDROID_LOG_INFO, "GameLoop",
+                      "Destructor - Stopping game thread");
+
+  _isRunning.store(false);
+
+  if (_gameThread && _gameThread->joinable()) {
+    _gameThread->join();
+  }
+  __android_log_print(ANDROID_LOG_INFO, "GameLoop", "Destructor - Complete");
+}
+
+std::vector<Entity *>
+GameLoop::resolveEntitiesInternal(const std::string &prefix) {
+  std::vector<Entity *> results;
+
+  auto exact = _entities.find(prefix);
+  if (exact != _entities.end()) {
+    results.push_back(&exact->second);
+    return results;
+  }
+
+  std::string pattern = prefix + "_";
+  for (auto it = _entities.lower_bound(pattern); it != _entities.end(); ++it) {
+    if (it->first.rfind(pattern, 0) != 0)
+      break;
+    results.push_back(&it->second);
+  }
+
+  return results;
+}
+
+std::vector<Rect> GameLoop::getRectsSnapshot() {
+  std::lock_guard<std::mutex> lock(_mutex);
+  std::vector<Rect> rects;
+  rects.reserve(_entities.size() + 1);
+
+  rects.push_back(
+      {0, _world.width, 0, _world.height, parseHexColor(_world.color)});
+
+  for (const auto &[id, entity] : _entities) {
+    if (entity.px + entity.width < 0 || entity.px > _world.width ||
+        entity.py + entity.height < 0 || entity.py > _world.height) {
+      continue;
+    }
+
+    rects.push_back(
+        {std::clamp(entity.px, 0.0, _world.width),
+         std::clamp(entity.px + entity.width, 0.0, _world.width),
+         std::clamp(entity.py, 0.0, _world.height),
+         std::clamp(entity.py + entity.height, 0.0, _world.height),
+         parseHexColor(entity.color)});
+  }
+  return rects;
+}
+
+void GameLoop::runGameLoop() {
+  using namespace std::chrono;
+  double targetDeltaTime = 1.0 / _tickRate;
+
+  __android_log_print(ANDROID_LOG_INFO, "GameLoop", "Game loop thread started");
+
+  auto previousTime = steady_clock::now();
+  double accumulator = 0.0;
+
+  while (_isRunning) {
+    auto currentTime = steady_clock::now();
+    double frameTime = duration<double>(currentTime - previousTime).count();
+    previousTime = currentTime;
+
+    if (frameTime > 0.25) {
+      frameTime = 0.25;
+    }
+
+    if (!_isPaused) {
+      accumulator += frameTime;
+
+      while (accumulator >= targetDeltaTime) {
+        update(targetDeltaTime);
+        accumulator -= targetDeltaTime;
+      }
+    }
+
+    std::this_thread::sleep_for(milliseconds(1));
+  }
+
+  __android_log_print(ANDROID_LOG_INFO, "GameLoop", "Game loop thread stopped");
+}
+
+void GameLoop::runSystems() {
+  for (auto &system : _systems) {
+    std::vector<Entity> entities;
+
+    for (const auto &id : system.ids) {
+      auto resolvedEntitiesInternal = resolveEntitiesInternal(id);
+      for (auto *entity : resolvedEntitiesInternal)
+        entities.push_back(*entity);
+    }
+
+    system.onTick(entities);
+  }
+}
+
+void GameLoop::update(double deltaTime) {
+  updateStats(deltaTime);
+  updateEntities(deltaTime);
+  runSystems();
+}
+
+void GameLoop::updateStats(double deltaTime) {
+  static double timeAccumulator = 0.0;
+  static uint64_t frameCount = 0;
+
+  timeAccumulator += deltaTime;
+  frameCount++;
+
+  if (timeAccumulator >= 1.0) {
+    _gameStats.tickRate = static_cast<double>(frameCount);
+    _gameStats.deltaTime = deltaTime;
+
+    __android_log_print(ANDROID_LOG_DEBUG, "GameLoop",
+                        "TickRate: %.2f, Delta: %.4f, Total Ticks: %" PRIu64,
+                        _gameStats.tickRate, _gameStats.deltaTime,
+                        _gameStats.totalTicks);
+
+    timeAccumulator = 0.0;
+    frameCount = 0;
+  }
+
+  _gameStats.totalTicks++;
+}
+
+void GameLoop::updateEntities(double deltaTime) {
+  std::lock_guard<std::mutex> lock(_mutex);
+
+  for (auto &[id, entity] : _entities) {
+    entity.px += entity.vx * deltaTime;
+    entity.py += entity.vy * deltaTime;
+  }
+}
+} // namespace margelo::nitro::rngine

package/shared/GameLoop.hpp

@@ -0,0 +1,53 @@
+#pragma once
+
+#include "Entity.hpp"
+#include "GameStats.hpp"
+#include "Rect.hpp"
+#include "System.hpp"
+#include "World.hpp"
+#include <atomic>
+#include <memory>
+#include <thread>
+
+namespace margelo::nitro::rngine {
+class GameLoop {
+public:
+  static GameLoop &getInstance();
+
+  GameLoop(const GameLoop &) = delete;
+  GameLoop &operator=(const GameLoop &) = delete;
+  GameLoop(GameLoop &&) = delete;
+  GameLoop &operator=(GameLoop &&) = delete;
+
+  ~GameLoop();
+
+  std::mutex &getMutexInternal() { return _mutex; };
+  std::map<string, Entity> &getEntitiesInternal() { return _entities; };
+  std::vector<System> &getSystemsInternal() { return _systems; };
+  std::atomic<bool> &getIsPausedInternal() { return _isPaused; };
+  World &getWorldInternal() { return _world; };
+
+  std::vector<Entity *> resolveEntitiesInternal(const std::string &prefix);
+  std::vector<Rect> getRectsSnapshot();
+
+  void setTickRate(double tickRate) { _tickRate = tickRate; };
+
+private:
+  explicit GameLoop();
+  std::mutex _mutex;
+  std::map<std::string, Entity> _entities;
+  std::vector<System> _systems{};
+  std::atomic<bool> _isRunning{true};
+  std::atomic<bool> _isPaused{true};
+  double _tickRate{60.0};
+  World _world;
+  GameStats _gameStats;
+  std::unique_ptr<std::thread> _gameThread;
+
+  void runGameLoop();
+  void runSystems();
+  void update(double deltaTime);
+  void updateStats(double deltaTime);
+  void updateEntities(double deltaTime);
+};
+} // namespace margelo::nitro::rngine

package/shared/GameMethods.cpp

@@ -0,0 +1,137 @@
+#include "GameMethods.hpp"
+#include "GameLoop.hpp"
+#include <android/log.h>
+
+namespace margelo::nitro::rngine {
+void GameMethods::setTickRate(double tickRate) {
+  auto &instance = GameLoop::getInstance();
+  std::lock_guard<std::mutex> lock(instance.getMutexInternal());
+  instance.setTickRate(tickRate);
+  __android_log_print(ANDROID_LOG_INFO, "GameMethods",
+                      "setTickRate: tickRate=%.1f", tickRate);
+}
+
+void GameMethods::setWorld(const World &world) {
+  auto &instance = GameLoop::getInstance();
+  std::lock_guard<std::mutex> lock(instance.getMutexInternal());
+  instance.getWorldInternal() = world;
+  __android_log_print(ANDROID_LOG_INFO, "GameMethods",
+                      "setWorld: width=%.0f height=%.0f", world.width,
+                      world.height);
+}
+
+void GameMethods::setEntities(const std::vector<Entity> &entities) {
+  auto &instance = GameLoop::getInstance();
+  std::lock_guard<std::mutex> lock(instance.getMutexInternal());
+  auto &entitiesInternal = instance.getEntitiesInternal();
+  for (auto &entity : entities) {
+    entitiesInternal[entity.id] = entity;
+  }
+  __android_log_print(ANDROID_LOG_INFO, "GameMethods",
+                      "setEntities: loaded %zu entities", entities.size());
+}
+
+void GameMethods::setSystems(const std::vector<System> &systems) {
+  auto &instance = GameLoop::getInstance();
+  std::lock_guard<std::mutex> lock(instance.getMutexInternal());
+  instance.getSystemsInternal() = systems;
+  __android_log_print(ANDROID_LOG_INFO, "GameMethods",
+                      "setSystems: loaded %zu systems", systems.size());
+}
+
+void GameMethods::pause() {
+  auto &isPaused = GameLoop::getInstance().getIsPausedInternal();
+  if (isPaused) {
+    __android_log_print(ANDROID_LOG_INFO, "GameMethods",
+                        "Already paused, ignoring");
+    return;
+  }
+
+  __android_log_print(ANDROID_LOG_INFO, "GameMethods", "Pause");
+  isPaused.store(true);
+}
+
+void GameMethods::resume() {
+  auto &isPaused = GameLoop::getInstance().getIsPausedInternal();
+  if (!isPaused) {
+    __android_log_print(ANDROID_LOG_INFO, "GameMethods",
+                        "Already running, ignoring");
+    return;
+  }
+  __android_log_print(ANDROID_LOG_INFO, "GameMethods", "Resume");
+  isPaused.store(false);
+}
+
+void GameMethods::spawn(const std::vector<Entity> &entities) {
+  auto &instance = GameLoop::getInstance();
+  std::lock_guard<std::mutex> lock(instance.getMutexInternal());
+  auto &entitiesInternal = instance.getEntitiesInternal();
+
+  for (const auto &entity : entities) {
+    if (entitiesInternal.count(entity.id)) {
+      __android_log_print(ANDROID_LOG_WARN, "GameMethods",
+                          "spawn: entity already exists for id=%s",
+                          entity.id.c_str());
+      continue;
+    }
+    entitiesInternal[entity.id] = entity;
+    __android_log_print(ANDROID_LOG_INFO, "GameMethods",
+                        "spawn: spawned entity id=%s", entity.id.c_str());
+  }
+}
+
+void GameMethods::despawn(const std::string &id) {
+  auto &instance = GameLoop::getInstance();
+  std::lock_guard<std::mutex> lock(instance.getMutexInternal());
+  auto &entities = instance.getEntitiesInternal();
+
+  auto resolved = instance.resolveEntitiesInternal(id);
+  if (resolved.empty()) {
+    __android_log_print(ANDROID_LOG_WARN, "GameMethods",
+                        "despawn: no entities found for id=%s", id.c_str());
+    return;
+  }
+
+  for (auto *entity : resolved) {
+    __android_log_print(ANDROID_LOG_INFO, "GameMethods",
+                        "despawn: despawned entity id=%s", entity->id.c_str());
+    entities.erase(entity->id);
+  }
+}
+
+void GameMethods::setP(const std::string &id, double px, double py) {
+  auto &instance = GameLoop::getInstance();
+  std::lock_guard<std::mutex> lock(instance.getMutexInternal());
+  auto &entitiesInternal = instance.getEntitiesInternal();
+  auto it = entitiesInternal.find(id);
+
+  if (it == entitiesInternal.end()) {
+    __android_log_print(ANDROID_LOG_WARN, "GameMethods",
+                        "setP: entity not found for id=%s", id.c_str());
+    return;
+  }
+  __android_log_print(ANDROID_LOG_INFO, "GameMethods",
+                      "setP: entity found, setting px=%f py=%f", px, py);
+  it->second.px = px;
+  it->second.py = py;
+}
+
+void GameMethods::setV(const std::string &id, double vx, double vy) {
+  auto &instance = GameLoop::getInstance();
+  std::lock_guard<std::mutex> lock(instance.getMutexInternal());
+  auto resolvedEntitiesInternals = instance.resolveEntitiesInternal(id);
+
+  if (resolvedEntitiesInternals.empty()) {
+    __android_log_print(ANDROID_LOG_WARN, "GameMethods",
+                        "setV: entity not found for id=%s", id.c_str());
+    return;
+  }
+  for (auto *entity : resolvedEntitiesInternals) {
+    entity->vx = vx;
+    entity->vy = vy;
+  }
+  __android_log_print(ANDROID_LOG_INFO, "GameMethods",
+                      "setV: set vx=%f vy=%f for %zu entities matching id=%s",
+                      vx, vy, resolvedEntitiesInternals.size(), id.c_str());
+}
+} // namespace margelo::nitro::rngine

package/shared/GameMethods.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "HybridGameMethodsSpec.hpp"
+
+namespace margelo::nitro::rngine {
+class GameMethods : public HybridGameMethodsSpec {
+public:
+  GameMethods() : HybridObject(TAG) {}
+  void setTickRate(double tickRate) override;
+  void setWorld(const World &world) override;
+  void setEntities(const std::vector<Entity> &entities) override;
+  void setSystems(const std::vector<System> &systems) override;
+  void pause() override;
+  void resume() override;
+  void spawn(const std::vector<Entity> &entities) override;
+  void despawn(const std::string &id) override;
+  void setP(const std::string &id, double px, double py) override;
+  void setV(const std::string &id, double vx, double vy) override;
+};
+} // namespace margelo::nitro::rngine

package/shared/GameStats.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <cstdint>
+
+namespace margelo::nitro::rngine {
+struct GameStats {
+  double tickRate = 0.0;
+  double deltaTime = 0.0;
+  uint64_t totalTicks = 0;
+};
+} // namespace margelo::nitro::rngine

package/shared/Rect.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+namespace margelo::nitro::rngine {
+static constexpr int RECT_SIZE = sizeof(double) * 4 + sizeof(uint32_t);
+
+struct Rect {
+  double left;
+  double right;
+  double top;
+  double bottom;
+  uint32_t color;
+};
+} // namespace margelo::nitro::rngine