rngine 0.7.1 → 0.7.2

package/lib/typescript/src/nativeTypes.d.ts

@@ -59,6 +59,10 @@ export interface Collision {
     b: string;
     /** Penetration depth of the collision. */
     depth: number;
+    /** X component of a normalised vector that represents the direction between the bodies providing the minimum separating distance. */
+    nx: number;
+    /** Y component of a normalised vector that represents the direction between the bodies providing the minimum separating distance. */
+    ny: number;
 }
 export interface System {
     /** Entity ids or prefixes this system subscribes to. */

package/lib/typescript/src/nativeTypes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nativeTypes.d.ts","sourceRoot":"","sources":["../../../src/nativeTypes.ts"],"names":[],"mappings":"AAAA,UAAU,UAAU;IAClB,gCAAgC;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,gCAAgC;IAChC,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,UAAU,IAAI;IACZ,2BAA2B;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,4BAA4B;IAC5B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,MAAM;IACd,4BAA4B;IAC5B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,MAAM;IACd,2BAA2B;IAC3B,KAAK,EAAE,IAAI,GAAG,MAAM,CAAC;CACtB;AAED,UAAU,UAAU;IAClB,mDAAmD;IACnD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uEAAuE;IACvE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,8FAA8F;IAC9F,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,UAAU,SAAS;IACjB,oDAAoD;IACpD,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,kDAAkD;IAClD,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,gEAAgE;IAChE,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,8DAA8D;IAC9D,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,MAAO,SAAQ,IAAI,EAAE,UAAU;CAAG;AAEnD,MAAM,WAAW,MAAO,SAAQ,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS;IACvE,oFAAoF;IACpF,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,YAAa,SAAQ,OAAO,CAC3C,UAAU,GAAG,MAAM,GAAG,UAAU,GAAG,SAAS,CAC7C;IACC,6DAA6D;IAC7D,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,aAAa;IAC5B,wDAAwD;IACxD,CAAC,EAAE,MAAM,CAAC;IACV,yDAAyD;IACzD,CAAC,EAAE,MAAM,CAAC;CACX;AAED,MAAM,WAAW,SAAS;IACxB,wDAAwD;IACxD,CAAC,EAAE,MAAM,CAAC;IACV,yDAAyD;IACzD,CAAC,EAAE,MAAM,CAAC;IACV,0CAA0C;IAC1C,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,MAAM;IACrB,wDAAwD;IACxD,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,+CAA+C;IAC/C,UAAU,CAAC,EAAE,aAAa,EAAE,CAAC;IAC7B,mEAAmE;IACnE,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,KAAK,MAAM,CAAC;CACjE"}
+{"version":3,"file":"nativeTypes.d.ts","sourceRoot":"","sources":["../../../src/nativeTypes.ts"],"names":[],"mappings":"AAAA,UAAU,UAAU;IAClB,gCAAgC;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,gCAAgC;IAChC,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,UAAU,IAAI;IACZ,2BAA2B;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,4BAA4B;IAC5B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,MAAM;IACd,4BAA4B;IAC5B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,MAAM;IACd,2BAA2B;IAC3B,KAAK,EAAE,IAAI,GAAG,MAAM,CAAC;CACtB;AAED,UAAU,UAAU;IAClB,mDAAmD;IACnD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uEAAuE;IACvE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,8FAA8F;IAC9F,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,UAAU,SAAS;IACjB,oDAAoD;IACpD,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,kDAAkD;IAClD,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,gEAAgE;IAChE,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,8DAA8D;IAC9D,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,MAAO,SAAQ,IAAI,EAAE,UAAU;CAAG;AAEnD,MAAM,WAAW,MAAO,SAAQ,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS;IACvE,oFAAoF;IACpF,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,YAAa,SAAQ,OAAO,CAC3C,UAAU,GAAG,MAAM,GAAG,UAAU,GAAG,SAAS,CAC7C;IACC,6DAA6D;IAC7D,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,aAAa;IAC5B,wDAAwD;IACxD,CAAC,EAAE,MAAM,CAAC;IACV,yDAAyD;IACzD,CAAC,EAAE,MAAM,CAAC;CACX;AAED,MAAM,WAAW,SAAS;IACxB,wDAAwD;IACxD,CAAC,EAAE,MAAM,CAAC;IACV,yDAAyD;IACzD,CAAC,EAAE,MAAM,CAAC;IACV,0CAA0C;IAC1C,KAAK,EAAE,MAAM,CAAC;IACd,qIAAqI;IACrI,EAAE,EAAE,MAAM,CAAC;IACX,qIAAqI;IACrI,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,MAAM;IACrB,wDAAwD;IACxD,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,+CAA+C;IAC/C,UAAU,CAAC,EAAE,aAAa,EAAE,CAAC;IAC7B,mEAAmE;IACnE,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,KAAK,MAAM,CAAC;CACjE"}

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

@@ -42,10 +42,12 @@ namespace margelo::nitro::rngine {
     std::string a     SWIFT_PRIVATE;
     std::string b     SWIFT_PRIVATE;
     double depth     SWIFT_PRIVATE;
+    double nx     SWIFT_PRIVATE;
+    double ny     SWIFT_PRIVATE;
 
   public:
     Collision() = default;
-    explicit Collision(std::string a, std::string b, double depth): a(a), b(b), depth(depth) {}
+    explicit Collision(std::string a, std::string b, double depth, double nx, double ny): a(a), b(b), depth(depth), nx(nx), ny(ny) {}
 
   public:
     friend bool operator==(const Collision& lhs, const Collision& rhs) = default;
@@ -63,7 +65,9 @@ namespace margelo::nitro {
       return margelo::nitro::rngine::Collision(
         JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "a"))),
         JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "b"))),
-        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "depth")))
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "depth"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "nx"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ny")))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::rngine::Collision& arg) {
@@ -71,6 +75,8 @@ namespace margelo::nitro {
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "a"), JSIConverter<std::string>::toJSI(runtime, arg.a));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "b"), JSIConverter<std::string>::toJSI(runtime, arg.b));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "depth"), JSIConverter<double>::toJSI(runtime, arg.depth));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "nx"), JSIConverter<double>::toJSI(runtime, arg.nx));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "ny"), JSIConverter<double>::toJSI(runtime, arg.ny));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -84,6 +90,8 @@ namespace margelo::nitro {
       if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "a")))) return false;
       if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "b")))) return false;
       if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "depth")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "nx")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ny")))) return false;
       return true;
     }
   };

package/package.json

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

package/shared/CollisionUtils.cpp

@@ -1,8 +1,10 @@
 #include "CollisionUtils.hpp"
+#include "Collision.hpp"
+#include <optional>
 
 namespace margelo::nitro::rngine::CollisionUtils {
-std::optional<double> overlap(const Rect &a, double ax, double ay,
-                              const Rect &b, double bx, double by) {
+std::optional<Overlap> overlap(const Rect &a, double ax, double ay,
+                               const Rect &b, double bx, double by) {
 
   double aLeft = ax - a.width / 2.0, aRight = ax + a.width / 2.0;
   double aTop = ay - a.height / 2.0, aBottom = ay + a.height / 2.0;
@@ -12,24 +14,35 @@ std::optional<double> overlap(const Rect &a, double ax, double ay,
   double overlapX = std::min(aRight, bRight) - std::max(aLeft, bLeft);
   double overlapY = std::min(aBottom, bBottom) - std::max(aTop, bTop);
 
-  if (overlapX > 0 && overlapY > 0)
-    return std::min(overlapX, overlapY);
-  return std::nullopt;
+  if (overlapX <= 0 || overlapY <= 0)
+    return std::nullopt;
+
+  if (overlapX < overlapY) {
+    double nx = (bx >= ax) ? 1.0 : -1.0;
+    return Overlap{overlapX, nx, 0.0};
+  } else {
+    double ny = (by >= ay) ? 1.0 : -1.0;
+    return Overlap{overlapY, 0.0, ny};
+  }
 }
 
-std::optional<double> overlap(const Circle &a, double ax, double ay,
-                              const Circle &b, double bx, double by) {
+std::optional<Overlap> overlap(const Circle &a, double ax, double ay,
+                               const Circle &b, double bx, double by) {
   double dx = bx - ax, dy = by - ay;
   double dist = std::sqrt(dx * dx + dy * dy);
   double depth = (a.radius + b.radius) - dist;
 
-  if (depth > 0)
-    return depth;
-  return std::nullopt;
+  if (depth <= 0)
+    return std::nullopt;
+
+  if (dist == 0.0)
+    return Overlap{depth, 0.0, -1.0};
+
+  return Overlap{depth, dx / dist, dy / dist};
 }
 
-std::optional<double> overlap(const Rect &a, double ax, double ay,
-                              const Circle &b, double bx, double by) {
+std::optional<Overlap> overlap(const Rect &a, double ax, double ay,
+                               const Circle &b, double bx, double by) {
   double left = ax - a.width / 2.0, right = ax + a.width / 2.0;
   double top = ay - a.height / 2.0, bottom = ay + a.height / 2.0;
 
@@ -42,26 +55,49 @@ std::optional<double> overlap(const Rect &a, double ax, double ay,
   if (distSq >= b.radius * b.radius)
     return std::nullopt;
 
+  if (distSq == 0.0) {
+    double cdx = bx - ax, cdy = by - ay;
+    double cdist = std::sqrt(cdx * cdx + cdy * cdy);
+    if (cdist == 0.0)
+      return Overlap{b.radius, 0.0, -1.0};
+    return Overlap{b.radius, cdx / cdist, cdy / cdist};
+  }
+
   double dist = std::sqrt(distSq);
-  return b.radius - dist;
+  return Overlap{b.radius - dist, dx / dist, dy / dist};
 }
 
-std::optional<double> overlap(const Circle &a, double ax, double ay,
-                              const Rect &b, double bx, double by) {
-  return overlap(b, bx, by, a, ax, ay);
+std::optional<Overlap> overlap(const Circle &a, double ax, double ay,
+                               const Rect &b, double bx, double by) {
+  auto result = overlap(b, bx, by, a, ax, ay);
+
+  if (!result.has_value()) {
+    return std::nullopt;
+  }
+
+  result.value().nx = -result.value().nx;
+  result.value().ny = -result.value().ny;
+
+  return result;
 }
 
-std::optional<double> shapeOverlap(const Entity &entityA,
-                                   const Entity &entityB) {
-  return std::visit(
-      [&](const auto &shapeA) -> std::optional<double> {
+std::optional<Collision> shapeOverlap(const Entity &entityA,
+                                      const Entity &entityB) {
+  auto result = std::visit(
+      [&](const auto &shapeA) -> std::optional<Overlap> {
         return std::visit(
-            [&](const auto &shapeB) -> std::optional<double> {
+            [&](const auto &shapeB) -> std::optional<Overlap> {
               return overlap(shapeA, entityA.px, entityA.py, shapeB, entityB.px,
                              entityB.py);
             },
             entityB.shape);
       },
       entityA.shape);
+  if (!result.has_value()) {
+    return nullopt;
+  }
+
+  return Collision{entityA.id, entityB.id, result->depth, result->nx,
+                   result->ny};
 }
 } // namespace margelo::nitro::rngine::CollisionUtils

package/shared/CollisionUtils.hpp

@@ -1,19 +1,26 @@
 #pragma once
 
 #include "Circle.hpp"
+#include "Collision.hpp"
 #include "Entity.hpp"
 #include "Rect.hpp"
 #include <optional>
 
 namespace margelo::nitro::rngine::CollisionUtils {
-std::optional<double> overlap(const Rect &a, double ax, double ay,
-                              const Rect &b, double bx, double by);
-std::optional<double> overlap(const Circle &a, double ax, double ay,
-                              const Circle &b, double bx, double by);
-std::optional<double> overlap(const Rect &a, double ax, double ay,
-                              const Circle &b, double bx, double by);
-std::optional<double> overlap(const Circle &a, double ax, double ay,
-                              const Rect &b, double bx, double by);
-std::optional<double> shapeOverlap(const Entity &entityA,
-                                   const Entity &entityB);
+struct Overlap {
+  double depth;
+  double nx;
+  double ny;
+};
+
+std::optional<Overlap> overlap(const Rect &a, double ax, double ay,
+                               const Rect &b, double bx, double by);
+std::optional<Overlap> overlap(const Circle &a, double ax, double ay,
+                               const Circle &b, double bx, double by);
+std::optional<Overlap> overlap(const Rect &a, double ax, double ay,
+                               const Circle &b, double bx, double by);
+std::optional<Overlap> overlap(const Circle &a, double ax, double ay,
+                               const Rect &b, double bx, double by);
+std::optional<Collision> shapeOverlap(const Entity &entityA,
+                                      const Entity &entityB);
 } // namespace margelo::nitro::rngine::CollisionUtils

package/shared/GameLoop.cpp

@@ -126,9 +126,9 @@ void GameLoop::runSystems() {
 
             uniqueEntityIdPairs.insert(uniqueEntityIdPairKey);
 
-            if (auto ov = CollisionUtils::shapeOverlap(*entityA, *entityB)) {
-              collisions.push_back(
-                  Collision(entityA->id, entityB->id, ov.value()));
+            if (auto collision =
+                    CollisionUtils::shapeOverlap(*entityA, *entityB)) {
+              collisions.push_back(collision.value());
             }
           }
         }

package/src/nativeTypes.ts

@@ -70,6 +70,10 @@ export interface Collision {
   b: string;
   /** Penetration depth of the collision. */
   depth: number;
+  /** X component of a normalised vector that represents the direction between the bodies providing the minimum separating distance. */
+  nx: number;
+  /** Y component of a normalised vector that represents the direction between the bodies providing the minimum separating distance. */
+  ny: number;
 }
 
 export interface System {