rngine 0.3.2 → 0.4.0

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

@@ -31,6 +31,7 @@
 
 
 #include <string>
+#include <optional>
 
 namespace margelo::nitro::rngine {
 
@@ -41,11 +42,13 @@ namespace margelo::nitro::rngine {
   public:
     double width     SWIFT_PRIVATE;
     double height     SWIFT_PRIVATE;
-    std::string color     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::string color): width(width), height(height), color(color) {}
+    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;
@@ -63,14 +66,18 @@ namespace margelo::nitro {
       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::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "color")))
+        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::string>::toJSI(runtime, arg.color));
+      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) {
@@ -83,7 +90,9 @@ namespace margelo::nitro {
       }
       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;
+      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;
     }
   };

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.2",
+  "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

@@ -3,9 +3,12 @@
 
 namespace margelo::nitro::rngine {
 
-inline uint32_t parseHexColor(const std::string &color) {
-  if (!color.empty() && color[0] == '#') {
-    std::string hex = color.substr(1);
+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;

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,13 +52,24 @@ 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, _screen.width, 0, _screen.height, parseHexColor(_screen.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 > _screen.width ||
@@ -64,11 +77,13 @@ std::vector<Rect> GameLoop::getRectsSnapshot() {
       continue;
     }
 
-    rects.push_back({std::clamp(entity.px, 0.0, _screen.width),
-                     std::clamp(entity.px + entity.width, 0.0, _screen.width),
-                     std::clamp(entity.py, 0.0, _screen.height),
-                     std::clamp(entity.py + entity.height, 0.0, _screen.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

@@ -28,6 +28,7 @@ public:
   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,6 +37,7 @@ 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};

package/shared/GameMethods.cpp

@@ -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/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,7 +1,8 @@
 import type { HybridObject } from 'react-native-nitro-modules';
-import type { Entity, EntityUpdate, System, Screen } 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++';
 }> {
@@ -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,
-  screen,
-  entities = [],
-  systems = [],
-  paused = true,
-}: Config) {
-  gameMethods.setTickRate(tickRate);
-  gameMethods.setScreen(screen);
-  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]);
-};

package/src/Shared.ts

@@ -0,0 +1,83 @@
+import { Image } from 'react-native';
+import { gameAssets } from './GameAssets.nitro';
+import { gameMethods } from './GameMethods.nitro';
+import type {
+  Screen as NativeScreen,
+  Entity as NativeEntity,
+  EntityUpdate as NativeEntityUpdate,
+} from './nativeTypes';
+import type { Asset, Config, Entity, EntityUpdate } from './types';
+
+const assetCache = new WeakMap<object, number>();
+let nextId = -1;
+
+const registerAssetIfNotExist = (asset?: Asset) => {
+  switch (typeof asset) {
+    case 'object':
+      if (assetCache.has(asset)) {
+        return assetCache.get(asset);
+      }
+      const assetId = nextId--;
+      assetCache.set(asset, assetId);
+      gameAssets.registerLottie(assetId, JSON.stringify(asset));
+      return assetId;
+
+    case 'number':
+      if (gameAssets.isAssetRegistered(asset)) {
+        return asset;
+      }
+      const assetUri = Image.resolveAssetSource(asset)?.uri;
+      if (!assetUri) {
+        break;
+      }
+      gameAssets.registerSvg(asset, assetUri);
+      return asset;
+  }
+  return;
+};
+
+/** Sets up the game engine with the given configuration. Call this before anything else. */
+export const configure = ({
+  tickRate,
+  screen,
+  entities = [],
+  systems = [],
+  paused = true,
+}: Config) => {
+  screen.asset = registerAssetIfNotExist(screen.asset);
+  for (const entity of entities) {
+    entity.asset = registerAssetIfNotExist(entity.asset);
+  }
+
+  gameMethods.setTickRate(tickRate);
+  gameMethods.setScreen(screen as NativeScreen);
+  gameMethods.setEntities(entities as NativeEntity[]);
+  gameMethods.setSystems(systems);
+  if (paused) {
+    gameMethods.pause();
+  } else {
+    gameMethods.resume();
+  }
+};
+
+/** Spawns one or more entities into the world. Skips duplicates by id. */
+export const spawn = (entities: Entity | Entity[]) => {
+  const entityArray = Array.isArray(entities) ? entities : [entities];
+
+  for (const entity of entityArray) {
+    entity.asset = registerAssetIfNotExist(entity.asset);
+  }
+
+  gameMethods.spawn(entityArray as NativeEntity[]);
+};
+
+/** Updates one or more entities. Only the provided fields are changed. */
+export const update = (updates: EntityUpdate | EntityUpdate[]) => {
+  const entityUpdateArray = Array.isArray(updates) ? updates : [updates];
+
+  for (const entityUpdate of entityUpdateArray) {
+    entityUpdate.asset = registerAssetIfNotExist(entityUpdate.asset);
+  }
+
+  gameMethods.update(entityUpdateArray as NativeEntityUpdate[]);
+};

package/src/index.tsx

@@ -1,5 +1,7 @@
 import GameEngine from './GameEngine';
 
 export * from './GameMethods';
+export * from './Shared';
+export type { System } from './nativeTypes';
 export * from './types';
 export { GameEngine };

package/src/nativeTypes.ts

@@ -0,0 +1,83 @@
+export type Screen = {
+  /** Width of the screen in game units. */
+  width: number;
+  /** Height of the screen in game units. */
+  height: number;
+  /** Background color of the screen as a hex string e.g. `'#1a1a1a'`. */
+  color?: string;
+  /** Asset to render, use `require` with the file path to get the id. */
+  asset?: number;
+  /** Animation progress between 0 and 1, automatically advanced each tick for Lottie assets. */
+  progress?: number;
+};
+
+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;
+  /** Asset to render, use `require` with the file path to get the id. */
+  asset?: number;
+  /** Animation progress between 0 and 1, automatically advanced each tick for Lottie assets. */
+  progress?: number;
+  /** 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 CollisionPair = {
+  /** Entity id or prefix of the first entity to watch. */
+  a: string;
+  /** Entity id or prefix of the second entity to watch. */
+  b: string;
+};
+
+export type Collision = {
+  /** Id of the first entity involved in the collision. */
+  a: string;
+  /** Id of the second entity involved in the collision. */
+  b: string;
+  /** Penetration depth of the collision. */
+  depth: number;
+};
+
+export type System = {
+  /** Entity ids or prefixes this system subscribes to. */
+  entities?: string[];
+  /** Collision pairs to watch for every tick. */
+  collisions?: CollisionPair[];
+  /** Called every tick with the resolved entities and collisions. */
+  onTick: (entities: Entity[], collisions: Collision[]) => void;
+};
+
+export type EntityUpdate = {
+  /** Unique identifier or prefix of the entities to update. */
+  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;
+  /** Asset to render, use `require` with the file path to get the id. */
+  asset?: number;
+  /** Animation progress between 0 and 1, automatically advanced each tick for Lottie assets. */
+  progress?: number;
+  /** Velocity on the X axis in game units per second. */
+  vx?: number;
+  /** Velocity on the Y axis in game units per second. */
+  vy?: number;
+};