rngine 0.3.1 → 0.4.0

package/nitrogen/generated/shared/c++/HybridGameMethodsSpec.cpp

@@ -15,7 +15,7 @@ namespace margelo::nitro::rngine {
     // load custom methods/properties
     registerHybrids(this, [](Prototype& prototype) {
       prototype.registerHybridMethod("setTickRate", &HybridGameMethodsSpec::setTickRate);
-      prototype.registerHybridMethod("setWorld", &HybridGameMethodsSpec::setWorld);
+      prototype.registerHybridMethod("setScreen", &HybridGameMethodsSpec::setScreen);
       prototype.registerHybridMethod("setEntities", &HybridGameMethodsSpec::setEntities);
       prototype.registerHybridMethod("setSystems", &HybridGameMethodsSpec::setSystems);
       prototype.registerHybridMethod("pause", &HybridGameMethodsSpec::pause);

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

@@ -13,8 +13,8 @@
 #error NitroModules cannot be found! Are you sure you installed NitroModules properly?
 #endif
 
-// Forward declaration of `World` to properly resolve imports.
-namespace margelo::nitro::rngine { struct World; }
+// Forward declaration of `Screen` to properly resolve imports.
+namespace margelo::nitro::rngine { struct Screen; }
 // Forward declaration of `Entity` to properly resolve imports.
 namespace margelo::nitro::rngine { struct Entity; }
 // Forward declaration of `System` to properly resolve imports.
@@ -22,7 +22,7 @@ namespace margelo::nitro::rngine { struct System; }
 // Forward declaration of `EntityUpdate` to properly resolve imports.
 namespace margelo::nitro::rngine { struct EntityUpdate; }
 
-#include "World.hpp"
+#include "Screen.hpp"
 #include "Entity.hpp"
 #include <vector>
 #include "System.hpp"
@@ -61,7 +61,7 @@ namespace margelo::nitro::rngine {
     public:
       // Methods
       virtual void setTickRate(double tickRate) = 0;
-      virtual void setWorld(const World& world) = 0;
+      virtual void setScreen(const Screen& screen) = 0;
       virtual void setEntities(const std::vector<Entity>& entities) = 0;
       virtual void setSystems(const std::vector<System>& systems) = 0;
       virtual void pause() = 0;

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

@@ -0,0 +1,100 @@
+///
+/// Screen.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>
+#include <optional>
+
+namespace margelo::nitro::rngine {
+
+  /**
+   * A struct which can be represented as a JavaScript object (Screen).
+   */
+  struct Screen final {
+  public:
+    double width     SWIFT_PRIVATE;
+    double height     SWIFT_PRIVATE;
+    std::optional<std::string> color     SWIFT_PRIVATE;
+    std::optional<double> asset     SWIFT_PRIVATE;
+    std::optional<double> progress     SWIFT_PRIVATE;
+
+  public:
+    Screen() = default;
+    explicit Screen(double width, double height, std::optional<std::string> color, std::optional<double> asset, std::optional<double> progress): width(width), height(height), color(color), asset(asset), progress(progress) {}
+
+  public:
+    friend bool operator==(const Screen& lhs, const Screen& rhs) = default;
+  };
+
+} // namespace margelo::nitro::rngine
+
+namespace margelo::nitro {
+
+  // C++ Screen <> JS Screen (object)
+  template <>
+  struct JSIConverter<margelo::nitro::rngine::Screen> final {
+    static inline margelo::nitro::rngine::Screen fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::rngine::Screen(
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "width"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "height"))),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "color"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "asset"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "progress")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::rngine::Screen& 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::optional<std::string>>::toJSI(runtime, arg.color));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "asset"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.asset));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "progress"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.progress));
+      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::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "color")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "asset")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "progress")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -28,12 +28,19 @@
 #error NitroModules cannot be found! Are you sure you installed NitroModules properly?
 #endif
 
+// Forward declaration of `CollisionPair` to properly resolve imports.
+namespace margelo::nitro::rngine { struct CollisionPair; }
 // Forward declaration of `Entity` to properly resolve imports.
 namespace margelo::nitro::rngine { struct Entity; }
+// Forward declaration of `Collision` to properly resolve imports.
+namespace margelo::nitro::rngine { struct Collision; }
 
 #include <string>
 #include <vector>
+#include <optional>
+#include "CollisionPair.hpp"
 #include "Entity.hpp"
+#include "Collision.hpp"
 #include <functional>
 
 namespace margelo::nitro::rngine {
@@ -43,12 +50,13 @@ namespace margelo::nitro::rngine {
    */
   struct System final {
   public:
-    std::vector<std::string> ids     SWIFT_PRIVATE;
-    std::function<void(const std::vector<Entity>& /* entities */)> onTick     SWIFT_PRIVATE;
+    std::optional<std::vector<std::string>> entities     SWIFT_PRIVATE;
+    std::optional<std::vector<CollisionPair>> collisions     SWIFT_PRIVATE;
+    std::function<void(const std::vector<Entity>& /* entities */, const std::vector<Collision>& /* collisions */)> onTick     SWIFT_PRIVATE;
 
   public:
     System() = default;
-    explicit System(std::vector<std::string> ids, std::function<void(const std::vector<Entity>& /* entities */)> onTick): ids(ids), onTick(onTick) {}
+    explicit System(std::optional<std::vector<std::string>> entities, std::optional<std::vector<CollisionPair>> collisions, std::function<void(const std::vector<Entity>& /* entities */, const std::vector<Collision>& /* collisions */)> onTick): entities(entities), collisions(collisions), onTick(onTick) {}
 
   public:
     // System is not equatable because these properties are not equatable: onTick
@@ -64,14 +72,16 @@ namespace margelo::nitro {
     static inline margelo::nitro::rngine::System fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       jsi::Object obj = arg.asObject(runtime);
       return margelo::nitro::rngine::System(
-        JSIConverter<std::vector<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ids"))),
-        JSIConverter<std::function<void(const std::vector<margelo::nitro::rngine::Entity>&)>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "onTick")))
+        JSIConverter<std::optional<std::vector<std::string>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "entities"))),
+        JSIConverter<std::optional<std::vector<margelo::nitro::rngine::CollisionPair>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "collisions"))),
+        JSIConverter<std::function<void(const std::vector<margelo::nitro::rngine::Entity>&, const std::vector<margelo::nitro::rngine::Collision>&)>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "onTick")))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::rngine::System& arg) {
       jsi::Object obj(runtime);
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "ids"), JSIConverter<std::vector<std::string>>::toJSI(runtime, arg.ids));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "onTick"), JSIConverter<std::function<void(const std::vector<margelo::nitro::rngine::Entity>&)>>::toJSI(runtime, arg.onTick));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "entities"), JSIConverter<std::optional<std::vector<std::string>>>::toJSI(runtime, arg.entities));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "collisions"), JSIConverter<std::optional<std::vector<margelo::nitro::rngine::CollisionPair>>>::toJSI(runtime, arg.collisions));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "onTick"), JSIConverter<std::function<void(const std::vector<margelo::nitro::rngine::Entity>&, const std::vector<margelo::nitro::rngine::Collision>&)>>::toJSI(runtime, arg.onTick));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -82,8 +92,9 @@ namespace margelo::nitro {
       if (!nitro::isPlainObject(runtime, obj)) {
         return false;
       }
-      if (!JSIConverter<std::vector<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ids")))) return false;
-      if (!JSIConverter<std::function<void(const std::vector<margelo::nitro::rngine::Entity>&)>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "onTick")))) return false;
+      if (!JSIConverter<std::optional<std::vector<std::string>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "entities")))) return false;
+      if (!JSIConverter<std::optional<std::vector<margelo::nitro::rngine::CollisionPair>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "collisions")))) return false;
+      if (!JSIConverter<std::function<void(const std::vector<margelo::nitro::rngine::Entity>&, const std::vector<margelo::nitro::rngine::Collision>&)>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "onTick")))) return false;
       return true;
     }
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rngine",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "React Native 2D game engine powered by Nitro Modules",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/shared/ColorUtils.hpp

@@ -1,25 +1,37 @@
 #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;
+inline uint32_t parseHexColor(const std::optional<std::string> &color) {
+  if (!color.has_value())
+    return 0x00000000;
+  const std::string &c = color.value();
+  if (!c.empty() && c[0] == '#') {
+    std::string hex = c.substr(1);
+
+    if (hex.size() == 3 || hex.size() == 4) {
+      std::string expanded;
+      expanded.reserve(hex.size() * 2);
+      for (char c : hex) {
+        expanded += c;
+        expanded += c;
+      }
+      hex = std::move(expanded);
+    }
+
+    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);
-}
 
+  return 0x00000000;
+}
 } // namespace margelo::nitro::rngine

package/shared/GameLoop.cpp

@@ -1,9 +1,11 @@
 #include "GameLoop.hpp"
+#include "Collision.hpp"
 #include "ColorUtils.hpp"
 #include "Entity.hpp"
 #include <android/log.h>
 #include <chrono>
 #include <cinttypes>
+#include <set>
 
 namespace margelo::nitro::rngine {
 
@@ -50,25 +52,38 @@ GameLoop::resolveEntitiesInternal(const std::string &prefix) {
   return results;
 }
 
+void GameLoop::registerLottieDuration(double id, double duration) {
+  std::lock_guard<std::mutex> lock(_mutex);
+  _lottieDurations[id] = duration;
+  __android_log_print(ANDROID_LOG_DEBUG, "GameLoop",
+                      "Registered lottie duration: id: %.0f, duration: %.4f",
+                      id, duration);
+}
+
 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)});
+  rects.push_back({0, static_cast<float>(_screen.width), 0,
+                   static_cast<float>(_screen.height),
+                   static_cast<float>(_screen.progress.value_or(0)),
+                   parseHexColor(_screen.color),
+                   static_cast<int32_t>(_screen.asset.value_or(0))});
 
   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) {
+    if (entity.px + entity.width < 0 || entity.px > _screen.width ||
+        entity.py + entity.height < 0 || entity.py > _screen.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)});
+    rects.push_back({static_cast<float>(entity.px),
+                     static_cast<float>(entity.px + entity.width),
+                     static_cast<float>(entity.py),
+                     static_cast<float>(entity.py + entity.height),
+                     static_cast<float>(entity.progress.value_or(0)),
+                     parseHexColor(entity.color),
+                     static_cast<int32_t>(entity.asset.value_or(0))});
   }
   return rects;
 }
@@ -109,14 +124,53 @@ void GameLoop::runGameLoop() {
 void GameLoop::runSystems() {
   for (auto &system : _systems) {
     std::vector<Entity> entities;
+    std::vector<Collision> collisions;
 
-    for (const auto &id : system.ids) {
-      auto resolvedEntitiesInternal = resolveEntitiesInternal(id);
-      for (auto *entity : resolvedEntitiesInternal)
-        entities.push_back(*entity);
+    if (system.entities.has_value()) {
+      for (const auto &id : system.entities.value()) {
+        auto resolvedEntitiesInternal = resolveEntitiesInternal(id);
+        for (auto *entity : resolvedEntitiesInternal)
+          entities.push_back(*entity);
+      }
     }
 
-    system.onTick(entities);
+    if (system.collisions.has_value()) {
+      std::set<std::pair<std::string, std::string>> uniqueEntityIdPairs;
+
+      for (const auto &[a, b] : system.collisions.value()) {
+        auto resolvedEntitiesInternalA = resolveEntitiesInternal(a);
+        auto resolvedEntitiesInternalB = resolveEntitiesInternal(b);
+
+        for (auto *entityA : resolvedEntitiesInternalA) {
+          for (auto *entityB : resolvedEntitiesInternalB) {
+            if (entityA == entityB)
+              continue;
+
+            auto uniqueEntityIdPairKey = std::minmax(entityA->id, entityB->id);
+
+            if (uniqueEntityIdPairs.count(uniqueEntityIdPairKey))
+              continue;
+
+            uniqueEntityIdPairs.insert(uniqueEntityIdPairKey);
+
+            float aLeft = entityA->px, aRight = entityA->px + entityA->width;
+            float aTop = entityA->py, aBottom = entityA->py + entityA->height;
+            float bLeft = entityB->px, bRight = entityB->px + entityB->width;
+            float bTop = entityB->py, bBottom = entityB->py + entityB->height;
+
+            float overlapX = std::min(aRight, bRight) - std::max(aLeft, bLeft);
+            float overlapY = std::min(aBottom, bBottom) - std::max(aTop, bTop);
+
+            if (overlapX > 0 && overlapY > 0) {
+              collisions.push_back(Collision(entityA->id, entityB->id,
+                                             std::min(overlapX, overlapY)));
+            }
+          }
+        }
+      }
+    }
+
+    system.onTick(entities, collisions);
   }
 }
 
@@ -156,9 +210,18 @@ void GameLoop::updateEntities(double deltaTime) {
     if (entity.vx) {
       entity.px += *entity.vx * deltaTime;
     }
+
     if (entity.vy) {
       entity.py += *entity.vy * deltaTime;
     }
+
+    if (entity.asset && entity.asset < 0) {
+      auto it = _lottieDurations.find(*entity.asset);
+      if (it != _lottieDurations.end() && it->second > 0.0) {
+        entity.progress =
+            fmod(entity.progress.value_or(0.0) + deltaTime / it->second, 1.0);
+      }
+    }
   }
 }
 } // namespace margelo::nitro::rngine

package/shared/GameLoop.hpp

@@ -3,8 +3,8 @@
 #include "Entity.hpp"
 #include "GameStats.hpp"
 #include "Rect.hpp"
+#include "Screen.hpp"
 #include "System.hpp"
-#include "World.hpp"
 #include <atomic>
 #include <memory>
 #include <thread>
@@ -25,9 +25,10 @@ public:
   std::map<string, Entity> &getEntitiesInternal() { return _entities; };
   std::vector<System> &getSystemsInternal() { return _systems; };
   std::atomic<bool> &getIsPausedInternal() { return _isPaused; };
-  World &getWorldInternal() { return _world; };
+  Screen &getScreenInternal() { return _screen; };
 
   std::vector<Entity *> resolveEntitiesInternal(const std::string &prefix);
+  void registerLottieDuration(double, double);
   std::vector<Rect> getRectsSnapshot();
 
   void setTickRate(double tickRate) { _tickRate = tickRate; };
@@ -36,11 +37,12 @@ private:
   explicit GameLoop();
   std::mutex _mutex;
   std::map<std::string, Entity> _entities;
+  std::map<double, double> _lottieDurations;
   std::vector<System> _systems{};
   std::atomic<bool> _isRunning{true};
   std::atomic<bool> _isPaused{true};
   double _tickRate{60.0};
-  World _world;
+  Screen _screen;
   GameStats _gameStats;
   std::unique_ptr<std::thread> _gameThread;
 

package/shared/GameMethods.cpp

@@ -12,13 +12,13 @@ void GameMethods::setTickRate(double tickRate) {
                       "setTickRate: tickRate=%.1f", tickRate);
 }
 
-void GameMethods::setWorld(const World &world) {
+void GameMethods::setScreen(const Screen &screen) {
   auto &instance = GameLoop::getInstance();
   std::lock_guard<std::mutex> lock(instance.getMutexInternal());
-  instance.getWorldInternal() = world;
+  instance.getScreenInternal() = screen;
   __android_log_print(ANDROID_LOG_INFO, "GameMethods",
-                      "setWorld: width=%.0f height=%.0f", world.width,
-                      world.height);
+                      "setWorld: width=%.0f height=%.0f", screen.width,
+                      screen.height);
 }
 
 void GameMethods::setEntities(const std::vector<Entity> &entities) {
@@ -114,20 +114,33 @@ void GameMethods::update(const std::vector<EntityUpdate> &updates) {
     }
 
     for (auto *entity : resolvedEntitiesInternals) {
-      if (update.px.has_value())
+      if (update.px.has_value()) {
         entity->px = update.px.value();
-      if (update.py.has_value())
+      }
+      if (update.py.has_value()) {
         entity->py = update.py.value();
-      if (update.width.has_value())
+      }
+      if (update.width.has_value()) {
         entity->width = update.width.value();
-      if (update.height.has_value())
+      }
+      if (update.height.has_value()) {
         entity->height = update.height.value();
-      if (update.color.has_value())
+      }
+      if (update.asset.has_value()) {
+        entity->asset = update.asset.value();
+      }
+      if (update.progress.has_value()) {
+        entity->progress = update.progress.value();
+      }
+      if (update.color.has_value()) {
         entity->color = update.color.value();
-      if (update.vx.has_value())
+      }
+      if (update.vx.has_value()) {
         entity->vx = update.vx.value();
-      if (update.vy.has_value())
+      }
+      if (update.vy.has_value()) {
         entity->vy = update.vy.value();
+      }
     }
 
     __android_log_print(ANDROID_LOG_INFO, "GameMethods",

package/shared/GameMethods.hpp

@@ -7,7 +7,7 @@ class GameMethods : public HybridGameMethodsSpec {
 public:
   GameMethods() : HybridObject(TAG) {}
   void setTickRate(double tickRate) override;
-  void setWorld(const World &world) override;
+  void setScreen(const Screen &screen) override;
   void setEntities(const std::vector<Entity> &entities) override;
   void setSystems(const std::vector<System> &systems) override;
   void pause() override;

package/shared/Rect.hpp

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

package/src/GameAssets.nitro.ts

@@ -0,0 +1,14 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import { NitroModules } from 'react-native-nitro-modules';
+
+interface GameAssets extends HybridObject<{
+  ios: 'swift';
+  android: 'kotlin';
+}> {
+  isAssetRegistered(id: number): boolean;
+  registerSvg(id: number, uri: string): void;
+  registerLottie(id: number, json: string): void;
+}
+
+export const gameAssets =
+  NitroModules.createHybridObject<GameAssets>('GameAssets');

package/src/GameMethods.nitro.ts

@@ -1,12 +1,13 @@
 import type { HybridObject } from 'react-native-nitro-modules';
-import type { Entity, EntityUpdate, System, World } from './types';
+import type { Entity, EntityUpdate, System, Screen } from './nativeTypes';
+import { NitroModules } from 'react-native-nitro-modules';
 
-export interface GameMethods extends HybridObject<{
+interface GameMethods extends HybridObject<{
   ios: 'c++';
   android: 'c++';
 }> {
   setTickRate(tickRate: number): void;
-  setWorld(world: World): void;
+  setScreen(screen: Screen): void;
   setEntities(entities: Entity[]): void;
   setSystems(systems: System[]): void;
   pause(): void;
@@ -15,3 +16,6 @@ export interface GameMethods extends HybridObject<{
   despawn(id: string): void;
   update(updates: EntityUpdate[]): void;
 }
+
+export const gameMethods =
+  NitroModules.createHybridObject<GameMethods>('GameMethods');

package/src/GameMethods.ts

@@ -1,27 +1,4 @@
-import { NitroModules } from 'react-native-nitro-modules';
-import type { GameMethods } from './GameMethods.nitro';
-import type { Config, Entity, EntityUpdate } 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();
-  }
-}
+import { gameMethods } from './GameMethods.nitro';
 
 /** Pauses the game loop. Systems will stop running. */
 export const pause = () => gameMethods.pause();
@@ -29,15 +6,5 @@ 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);
-
-/** Updates one or more entities. Only the provided fields are changed. */
-export const update = (updates: EntityUpdate | EntityUpdate[]) => {
-  gameMethods.update(Array.isArray(updates) ? updates : [updates]);
-};