rngine 0.7.1 → 0.8.0

package/README.md

@@ -16,7 +16,7 @@ npm install rngine react-native-nitro-modules
 import { GameEngine, configure, update } from 'rngine';
 
 configure({
-  tickRate: 60,
+  world: { tickRate: 60 },
   screen: { width: 800, height: 800, color: '#1a1a1a' },
   entities: [
     {

package/lib/module/GameMethods.js

@@ -3,7 +3,7 @@
 import { gameMethods } from "./GameMethods.nitro.js";
 /** Sets up the game engine with the given configuration. Call this before anything else. */
 export const configure = ({
-  tickRate,
+  world,
   screen,
   entities = [],
   systems = [],
@@ -22,7 +22,7 @@ export const configure = ({
       }
     });
   }
-  gameMethods.setTickRate(tickRate);
+  gameMethods.setWorld(world);
   gameMethods.setScreen(screen);
   gameMethods.setEntities(entities);
   gameMethods.setSystems(nativeSystems);

package/lib/module/GameMethods.js.map

@@ -1 +1 @@
-{"version":3,"names":["gameMethods","configure","tickRate","screen","entities","systems","paused","nativeSystems","system","push","collisions","onTick","e","c","start","Date","now","finish","setTickRate","setScreen","setEntities","setSystems","pause","resume","spawn","entityArray","Array","isArray","despawn","id","update","updates","entityUpdateArray"],"sourceRoot":"../../src","sources":["GameMethods.ts"],"mappings":";;AAAA,SAASA,WAAW,QAAQ,wBAAqB;AAIjD;AACA,OAAO,MAAMC,SAAS,GAAGA,CAAC;EACxBC,QAAQ;EACRC,MAAM;EACNC,QAAQ,GAAG,EAAE;EACbC,OAAO,GAAG,EAAE;EACZC,MAAM,GAAG;AACH,CAAC,KAAK;EACZ,IAAIC,aAAuB,GAAG,EAAE;EAEhC,KAAK,MAAMC,MAAM,IAAIH,OAAO,EAAE;IAC5BE,aAAa,CAACE,IAAI,CAAC;MACjBL,QAAQ,EAAEI,MAAM,CAACJ,QAAQ;MACzBM,UAAU,EAAEF,MAAM,CAACE,UAAU;MAC7BC,MAAM,EAAEA,CAACC,CAAC,EAAEC,CAAC,KAAK;QAChB,MAAMC,KAAK,GAAGC,IAAI,CAACC,GAAG,CAAC,CAAC;QACxBR,MAAM,CAACG,MAAM,CAACC,CAAC,EAAEC,CAAC,CAAC;QACnB,MAAMI,MAAM,GAAGF,IAAI,CAACC,GAAG,CAAC,CAAC;QACzB,OAAOC,MAAM,GAAGH,KAAK;MACvB;IACF,CAAC,CAAC;EACJ;EAEAd,WAAW,CAACkB,WAAW,CAAChB,QAAQ,CAAC;EACjCF,WAAW,CAACmB,SAAS,CAAChB,MAAM,CAAC;EAC7BH,WAAW,CAACoB,WAAW,CAAChB,QAAQ,CAAC;EACjCJ,WAAW,CAACqB,UAAU,CAACd,aAAa,CAAC;EACrC,IAAID,MAAM,EAAE;IACVN,WAAW,CAACsB,KAAK,CAAC,CAAC;EACrB,CAAC,MAAM;IACLtB,WAAW,CAACuB,MAAM,CAAC,CAAC;EACtB;AACF,CAAC;;AAED;AACA,OAAO,MAAMD,KAAK,GAAGA,CAAA,KAAMtB,WAAW,CAACsB,KAAK,CAAC,CAAC;;AAE9C;AACA,OAAO,MAAMC,MAAM,GAAGA,CAAA,KAAMvB,WAAW,CAACuB,MAAM,CAAC,CAAC;;AAEhD;AACA,OAAO,MAAMC,KAAK,GAAIpB,QAA2B,IAAK;EACpD,MAAMqB,WAAW,GAAGC,KAAK,CAACC,OAAO,CAACvB,QAAQ,CAAC,GAAGA,QAAQ,GAAG,CAACA,QAAQ,CAAC;EACnEJ,WAAW,CAACwB,KAAK,CAACC,WAAW,CAAC;AAChC,CAAC;;AAED;AACA,OAAO,MAAMG,OAAO,GAAIC,EAAU,IAAK7B,WAAW,CAAC4B,OAAO,CAACC,EAAE,CAAC;;AAE9D;AACA,OAAO,MAAMC,MAAM,GAAIC,OAAsC,IAAK;EAChE,MAAMC,iBAAiB,GAAGN,KAAK,CAACC,OAAO,CAACI,OAAO,CAAC,GAAGA,OAAO,GAAG,CAACA,OAAO,CAAC;EACtE/B,WAAW,CAAC8B,MAAM,CAACE,iBAAiB,CAAC;AACvC,CAAC","ignoreList":[]}
+{"version":3,"names":["gameMethods","configure","world","screen","entities","systems","paused","nativeSystems","system","push","collisions","onTick","e","c","start","Date","now","finish","setWorld","setScreen","setEntities","setSystems","pause","resume","spawn","entityArray","Array","isArray","despawn","id","update","updates","entityUpdateArray"],"sourceRoot":"../../src","sources":["GameMethods.ts"],"mappings":";;AAAA,SAASA,WAAW,QAAQ,wBAAqB;AAIjD;AACA,OAAO,MAAMC,SAAS,GAAGA,CAAC;EACxBC,KAAK;EACLC,MAAM;EACNC,QAAQ,GAAG,EAAE;EACbC,OAAO,GAAG,EAAE;EACZC,MAAM,GAAG;AACH,CAAC,KAAK;EACZ,IAAIC,aAAuB,GAAG,EAAE;EAEhC,KAAK,MAAMC,MAAM,IAAIH,OAAO,EAAE;IAC5BE,aAAa,CAACE,IAAI,CAAC;MACjBL,QAAQ,EAAEI,MAAM,CAACJ,QAAQ;MACzBM,UAAU,EAAEF,MAAM,CAACE,UAAU;MAC7BC,MAAM,EAAEA,CAACC,CAAC,EAAEC,CAAC,KAAK;QAChB,MAAMC,KAAK,GAAGC,IAAI,CAACC,GAAG,CAAC,CAAC;QACxBR,MAAM,CAACG,MAAM,CAACC,CAAC,EAAEC,CAAC,CAAC;QACnB,MAAMI,MAAM,GAAGF,IAAI,CAACC,GAAG,CAAC,CAAC;QACzB,OAAOC,MAAM,GAAGH,KAAK;MACvB;IACF,CAAC,CAAC;EACJ;EAEAd,WAAW,CAACkB,QAAQ,CAAChB,KAAK,CAAC;EAC3BF,WAAW,CAACmB,SAAS,CAAChB,MAAM,CAAC;EAC7BH,WAAW,CAACoB,WAAW,CAAChB,QAAQ,CAAC;EACjCJ,WAAW,CAACqB,UAAU,CAACd,aAAa,CAAC;EACrC,IAAID,MAAM,EAAE;IACVN,WAAW,CAACsB,KAAK,CAAC,CAAC;EACrB,CAAC,MAAM;IACLtB,WAAW,CAACuB,MAAM,CAAC,CAAC;EACtB;AACF,CAAC;;AAED;AACA,OAAO,MAAMD,KAAK,GAAGA,CAAA,KAAMtB,WAAW,CAACsB,KAAK,CAAC,CAAC;;AAE9C;AACA,OAAO,MAAMC,MAAM,GAAGA,CAAA,KAAMvB,WAAW,CAACuB,MAAM,CAAC,CAAC;;AAEhD;AACA,OAAO,MAAMC,KAAK,GAAIpB,QAA2B,IAAK;EACpD,MAAMqB,WAAW,GAAGC,KAAK,CAACC,OAAO,CAACvB,QAAQ,CAAC,GAAGA,QAAQ,GAAG,CAACA,QAAQ,CAAC;EACnEJ,WAAW,CAACwB,KAAK,CAACC,WAAW,CAAC;AAChC,CAAC;;AAED;AACA,OAAO,MAAMG,OAAO,GAAIC,EAAU,IAAK7B,WAAW,CAAC4B,OAAO,CAACC,EAAE,CAAC;;AAE9D;AACA,OAAO,MAAMC,MAAM,GAAIC,OAAsC,IAAK;EAChE,MAAMC,iBAAiB,GAAGN,KAAK,CAACC,OAAO,CAACI,OAAO,CAAC,GAAGA,OAAO,GAAG,CAACA,OAAO,CAAC;EACtE/B,WAAW,CAAC8B,MAAM,CAACE,iBAAiB,CAAC;AACvC,CAAC","ignoreList":[]}

package/lib/module/GameMethods.nitro.js.map

@@ -1 +1 @@
-{"version":3,"names":["NitroModules","gameMethods","createHybridObject"],"sourceRoot":"../../src","sources":["GameMethods.nitro.ts"],"mappings":";;AAEA,SAASA,YAAY,QAAQ,4BAA4B;AAiBzD,OAAO,MAAMC,WAAW,GACtBD,YAAY,CAACE,kBAAkB,CAAc,aAAa,CAAC","ignoreList":[]}
+{"version":3,"names":["NitroModules","gameMethods","createHybridObject"],"sourceRoot":"../../src","sources":["GameMethods.nitro.ts"],"mappings":";;AAQA,SAASA,YAAY,QAAQ,4BAA4B;AAiBzD,OAAO,MAAMC,WAAW,GACtBD,YAAY,CAACE,kBAAkB,CAAc,aAAa,CAAC","ignoreList":[]}

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["GameEngine"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,OAAOA,UAAU,MAAM,iBAAc;AAErC,cAAc,kBAAe;AAC7B,cAAc,iBAAc;AAC5B,cAAc,YAAS;AAQvB,SAASA,UAAU","ignoreList":[]}
+{"version":3,"names":["GameEngine"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,OAAOA,UAAU,MAAM,iBAAc;AAErC,cAAc,kBAAe;AAC7B,cAAc,iBAAc;AAC5B,cAAc,YAAS;AASvB,SAASA,UAAU","ignoreList":[]}

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

@@ -1,7 +1,7 @@
 import type { Entity, EntityUpdate } from './nativeTypes';
 import type { Config } from './types';
 /** Sets up the game engine with the given configuration. Call this before anything else. */
-export declare const configure: ({ tickRate, screen, entities, systems, paused, }: Config) => void;
+export declare const configure: ({ world, screen, entities, systems, paused, }: Config) => void;
 /** Pauses the game loop. Systems will stop running. */
 export declare const pause: () => void;
 /** Resumes the game loop. */

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

@@ -1 +1 @@
-{"version":3,"file":"GameMethods.d.ts","sourceRoot":"","sources":["../../../src/GameMethods.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAU,MAAM,eAAe,CAAC;AAClE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAEtC,4FAA4F;AAC5F,eAAO,MAAM,SAAS,GAAI,kDAMvB,MAAM,SAyBR,CAAC;AAEF,uDAAuD;AACvD,eAAO,MAAM,KAAK,YAA4B,CAAC;AAE/C,6BAA6B;AAC7B,eAAO,MAAM,MAAM,YAA6B,CAAC;AAEjD,0EAA0E;AAC1E,eAAO,MAAM,KAAK,GAAI,UAAU,MAAM,GAAG,MAAM,EAAE,SAGhD,CAAC;AAEF,qFAAqF;AACrF,eAAO,MAAM,OAAO,GAAI,IAAI,MAAM,SAA4B,CAAC;AAE/D,0EAA0E;AAC1E,eAAO,MAAM,MAAM,GAAI,SAAS,YAAY,GAAG,YAAY,EAAE,SAG5D,CAAC"}
+{"version":3,"file":"GameMethods.d.ts","sourceRoot":"","sources":["../../../src/GameMethods.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAU,MAAM,eAAe,CAAC;AAClE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAEtC,4FAA4F;AAC5F,eAAO,MAAM,SAAS,GAAI,+CAMvB,MAAM,SAyBR,CAAC;AAEF,uDAAuD;AACvD,eAAO,MAAM,KAAK,YAA4B,CAAC;AAE/C,6BAA6B;AAC7B,eAAO,MAAM,MAAM,YAA6B,CAAC;AAEjD,0EAA0E;AAC1E,eAAO,MAAM,KAAK,GAAI,UAAU,MAAM,GAAG,MAAM,EAAE,SAGhD,CAAC;AAEF,qFAAqF;AACrF,eAAO,MAAM,OAAO,GAAI,IAAI,MAAM,SAA4B,CAAC;AAE/D,0EAA0E;AAC1E,eAAO,MAAM,MAAM,GAAI,SAAS,YAAY,GAAG,YAAY,EAAE,SAG5D,CAAC"}

package/lib/typescript/src/GameMethods.nitro.d.ts

@@ -1,10 +1,10 @@
 import type { HybridObject } from 'react-native-nitro-modules';
-import type { Entity, EntityUpdate, System, Screen } from './nativeTypes';
+import type { Entity, EntityUpdate, System, Screen, World } from './nativeTypes';
 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;

package/lib/typescript/src/GameMethods.nitro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GameMethods.nitro.d.ts","sourceRoot":"","sources":["../../../src/GameMethods.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAG1E,UAAU,WAAY,SAAQ,YAAY,CAAC;IACzC,GAAG,EAAE,KAAK,CAAC;IACX,OAAO,EAAE,KAAK,CAAC;CAChB,CAAC;IACA,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IACtC,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IACpC,KAAK,IAAI,IAAI,CAAC;IACd,MAAM,IAAI,IAAI,CAAC;IACf,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAChC,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,MAAM,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,IAAI,CAAC;CACvC;AAED,eAAO,MAAM,WAAW,aACqC,CAAC"}
+{"version":3,"file":"GameMethods.nitro.d.ts","sourceRoot":"","sources":["../../../src/GameMethods.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,EACV,MAAM,EACN,YAAY,EACZ,MAAM,EACN,MAAM,EACN,KAAK,EACN,MAAM,eAAe,CAAC;AAGvB,UAAU,WAAY,SAAQ,YAAY,CAAC;IACzC,GAAG,EAAE,KAAK,CAAC;IACX,OAAO,EAAE,KAAK,CAAC;CAChB,CAAC;IACA,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IAC7B,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IACtC,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IACpC,KAAK,IAAI,IAAI,CAAC;IACd,MAAM,IAAI,IAAI,CAAC;IACf,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAChC,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,MAAM,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,IAAI,CAAC;CACvC;AAED,eAAO,MAAM,WAAW,aACqC,CAAC"}

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

@@ -2,6 +2,6 @@ import GameEngine from './GameEngine';
 export * from './GameMethods';
 export * from './GameAssets';
 export * from './types';
-export type { Screen, Entity, CollisionPair, Collision, EntityUpdate, } from './nativeTypes';
+export type { World, Screen, Entity, CollisionPair, Collision, EntityUpdate, } from './nativeTypes';
 export { GameEngine };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,cAAc,CAAC;AAEtC,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC;AACxB,YAAY,EACV,MAAM,EACN,MAAM,EACN,aAAa,EACb,SAAS,EACT,YAAY,GACb,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,UAAU,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,cAAc,CAAC;AAEtC,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC;AACxB,YAAY,EACV,KAAK,EACL,MAAM,EACN,MAAM,EACN,aAAa,EACb,SAAS,EACT,YAAY,GACb,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,UAAU,EAAE,CAAC"}

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

@@ -17,6 +17,8 @@ interface Circle {
 interface Shaped {
     /** Shape of the entity. */
     shape: Rect | Circle;
+    /** Indicates whether the entity is a sensor. Sensors trigger collision events but don't react physically. */
+    isSensor?: boolean;
 }
 interface Renderable {
     /** Fill color as a hex string e.g. `'#00ff00'`. */
@@ -35,6 +37,16 @@ interface Kinematic {
     ax?: number;
     /** Vertical acceleration in game units per second squared. */
     ay?: number;
+    /** Mass in arbitrary units. */
+    mass?: number;
+}
+export interface World {
+    /** Number of game logic updates per second. */
+    tickRate: number;
+    /** Horizontal gravitational acceleration in game units per second squared. */
+    gx?: number;
+    /** Vertical gravitational acceleration in game units per second squared. */
+    gy?: number;
 }
 export interface Screen extends Rect, Renderable {
 }
@@ -59,6 +71,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;IACrB,6GAA6G;IAC7G,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;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;IACZ,+BAA+B;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,KAAK;IACpB,+CAA+C;IAC/C,QAAQ,EAAE,MAAM,CAAC;IACjB,8EAA8E;IAC9E,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,4EAA4E;IAC5E,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/lib/typescript/src/types.d.ts

@@ -1,21 +1,18 @@
-import type { System as NativeSystem, Collision, Screen, Entity } from './nativeTypes';
+import type { System as NativeSystem, Collision, Screen, Entity, World } from './nativeTypes';
 export type System = Omit<NativeSystem, 'onTick'> & {
     /** Called every tick with the resolved entities and collisions. */
     onTick: (entities: Entity[], collisions: Collision[]) => void;
 };
 export type Config = {
-    /** Number of game logic updates per second. */
-    tickRate: number;
-    /** Screen dimensions and background color. */
+    /** World settings: tick rate and gravity. */
+    world: World;
+    /** Screen dimensions and background. */
     screen: Screen;
-    /** Initial entities to spawn. */
+    /** Entities to spawn when the game starts. */
     entities?: Entity[];
-    /**
-     * Systems that define the game logic. Each system runs every tick
-     * and receives the entities matching its ids.
-     */
+    /** Systems that define game logic, each running every tick against its subscribed entities and collisions. */
     systems?: System[];
-    /** Whether to start paused. Defaults to true. */
+    /** Whether the game starts paused. Defaults to true. */
     paused?: boolean;
 };
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,IAAI,YAAY,EACtB,SAAS,EACT,MAAM,EACN,MAAM,EACP,MAAM,eAAe,CAAC;AAEvB,MAAM,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,EAAE,QAAQ,CAAC,GAAG;IAClD,mEAAmE;IACnE,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,KAAK,IAAI,CAAC;CAC/D,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG;IACnB,+CAA+C;IAC/C,QAAQ,EAAE,MAAM,CAAC;IACjB,8CAA8C;IAC9C,MAAM,EAAE,MAAM,CAAC;IACf,iCAAiC;IACjC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,iDAAiD;IACjD,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,IAAI,YAAY,EACtB,SAAS,EACT,MAAM,EACN,MAAM,EACN,KAAK,EACN,MAAM,eAAe,CAAC;AAEvB,MAAM,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,EAAE,QAAQ,CAAC,GAAG;IAClD,mEAAmE;IACnE,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,KAAK,IAAI,CAAC;CAC/D,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG;IACnB,6CAA6C;IAC7C,KAAK,EAAE,KAAK,CAAC;IACb,wCAAwC;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,8CAA8C;IAC9C,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,8GAA8G;IAC9G,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,wDAAwD;IACxD,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC"}

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/nitrogen/generated/shared/c++/Entity.hpp

@@ -50,6 +50,7 @@ namespace margelo::nitro::rngine {
     double px     SWIFT_PRIVATE;
     double py     SWIFT_PRIVATE;
     std::variant<Rect, Circle> shape     SWIFT_PRIVATE;
+    std::optional<bool> isSensor     SWIFT_PRIVATE;
     std::optional<std::string> color     SWIFT_PRIVATE;
     std::optional<double> asset     SWIFT_PRIVATE;
     std::optional<double> progress     SWIFT_PRIVATE;
@@ -57,10 +58,11 @@ namespace margelo::nitro::rngine {
     std::optional<double> vy     SWIFT_PRIVATE;
     std::optional<double> ax     SWIFT_PRIVATE;
     std::optional<double> ay     SWIFT_PRIVATE;
+    std::optional<double> mass     SWIFT_PRIVATE;
 
   public:
     Entity() = default;
-    explicit Entity(std::string id, double px, double py, std::variant<Rect, Circle> shape, std::optional<std::string> color, std::optional<double> asset, std::optional<double> progress, std::optional<double> vx, std::optional<double> vy, std::optional<double> ax, std::optional<double> ay): id(id), px(px), py(py), shape(shape), color(color), asset(asset), progress(progress), vx(vx), vy(vy), ax(ax), ay(ay) {}
+    explicit Entity(std::string id, double px, double py, std::variant<Rect, Circle> shape, std::optional<bool> isSensor, std::optional<std::string> color, std::optional<double> asset, std::optional<double> progress, std::optional<double> vx, std::optional<double> vy, std::optional<double> ax, std::optional<double> ay, std::optional<double> mass): id(id), px(px), py(py), shape(shape), isSensor(isSensor), color(color), asset(asset), progress(progress), vx(vx), vy(vy), ax(ax), ay(ay), mass(mass) {}
 
   public:
     friend bool operator==(const Entity& lhs, const Entity& rhs) = default;
@@ -80,13 +82,15 @@ namespace margelo::nitro {
         JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "px"))),
         JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "py"))),
         JSIConverter<std::variant<margelo::nitro::rngine::Rect, margelo::nitro::rngine::Circle>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "shape"))),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "isSensor"))),
         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"))),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "vx"))),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "vy"))),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ax"))),
-        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ay")))
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ay"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "mass")))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::rngine::Entity& arg) {
@@ -95,6 +99,7 @@ namespace margelo::nitro {
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "px"), JSIConverter<double>::toJSI(runtime, arg.px));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "py"), JSIConverter<double>::toJSI(runtime, arg.py));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "shape"), JSIConverter<std::variant<margelo::nitro::rngine::Rect, margelo::nitro::rngine::Circle>>::toJSI(runtime, arg.shape));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "isSensor"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.isSensor));
       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));
@@ -102,6 +107,7 @@ namespace margelo::nitro {
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "vy"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.vy));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "ax"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.ax));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "ay"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.ay));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "mass"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.mass));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -116,6 +122,7 @@ namespace margelo::nitro {
       if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "px")))) return false;
       if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "py")))) return false;
       if (!JSIConverter<std::variant<margelo::nitro::rngine::Rect, margelo::nitro::rngine::Circle>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "shape")))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "isSensor")))) 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;
@@ -123,6 +130,7 @@ namespace margelo::nitro {
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "vy")))) return false;
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ax")))) return false;
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ay")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "mass")))) return false;
       return true;
     }
   };

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

@@ -50,6 +50,7 @@ namespace margelo::nitro::rngine {
     std::optional<double> px     SWIFT_PRIVATE;
     std::optional<double> py     SWIFT_PRIVATE;
     std::optional<std::variant<Rect, Circle>> shape     SWIFT_PRIVATE;
+    std::optional<bool> isSensor     SWIFT_PRIVATE;
     std::optional<std::string> color     SWIFT_PRIVATE;
     std::optional<double> asset     SWIFT_PRIVATE;
     std::optional<double> progress     SWIFT_PRIVATE;
@@ -57,10 +58,11 @@ namespace margelo::nitro::rngine {
     std::optional<double> vy     SWIFT_PRIVATE;
     std::optional<double> ax     SWIFT_PRIVATE;
     std::optional<double> ay     SWIFT_PRIVATE;
+    std::optional<double> mass     SWIFT_PRIVATE;
 
   public:
     EntityUpdate() = default;
-    explicit EntityUpdate(std::string id, std::optional<double> px, std::optional<double> py, std::optional<std::variant<Rect, Circle>> shape, std::optional<std::string> color, std::optional<double> asset, std::optional<double> progress, std::optional<double> vx, std::optional<double> vy, std::optional<double> ax, std::optional<double> ay): id(id), px(px), py(py), shape(shape), color(color), asset(asset), progress(progress), vx(vx), vy(vy), ax(ax), ay(ay) {}
+    explicit EntityUpdate(std::string id, std::optional<double> px, std::optional<double> py, std::optional<std::variant<Rect, Circle>> shape, std::optional<bool> isSensor, std::optional<std::string> color, std::optional<double> asset, std::optional<double> progress, std::optional<double> vx, std::optional<double> vy, std::optional<double> ax, std::optional<double> ay, std::optional<double> mass): id(id), px(px), py(py), shape(shape), isSensor(isSensor), color(color), asset(asset), progress(progress), vx(vx), vy(vy), ax(ax), ay(ay), mass(mass) {}
 
   public:
     friend bool operator==(const EntityUpdate& lhs, const EntityUpdate& rhs) = default;
@@ -80,13 +82,15 @@ namespace margelo::nitro {
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "px"))),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "py"))),
         JSIConverter<std::optional<std::variant<margelo::nitro::rngine::Rect, margelo::nitro::rngine::Circle>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "shape"))),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "isSensor"))),
         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"))),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "vx"))),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "vy"))),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ax"))),
-        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ay")))
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ay"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "mass")))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::rngine::EntityUpdate& arg) {
@@ -95,6 +99,7 @@ namespace margelo::nitro {
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "px"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.px));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "py"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.py));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "shape"), JSIConverter<std::optional<std::variant<margelo::nitro::rngine::Rect, margelo::nitro::rngine::Circle>>>::toJSI(runtime, arg.shape));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "isSensor"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.isSensor));
       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));
@@ -102,6 +107,7 @@ namespace margelo::nitro {
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "vy"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.vy));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "ax"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.ax));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "ay"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.ay));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "mass"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.mass));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -116,6 +122,7 @@ namespace margelo::nitro {
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "px")))) return false;
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "py")))) return false;
       if (!JSIConverter<std::optional<std::variant<margelo::nitro::rngine::Rect, margelo::nitro::rngine::Circle>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "shape")))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "isSensor")))) 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;
@@ -123,6 +130,7 @@ namespace margelo::nitro {
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "vy")))) return false;
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ax")))) return false;
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ay")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "mass")))) return false;
       return true;
     }
   };

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

@@ -14,7 +14,7 @@ namespace margelo::nitro::rngine {
     HybridObject::loadHybridMethods();
     // 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);

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

@@ -13,6 +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.
@@ -22,6 +24,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>
@@ -60,7 +63,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;

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 <optional>
+
+namespace margelo::nitro::rngine {
+
+  /**
+   * A struct which can be represented as a JavaScript object (World).
+   */
+  struct World final {
+  public:
+    double tickRate     SWIFT_PRIVATE;
+    std::optional<double> gx     SWIFT_PRIVATE;
+    std::optional<double> gy     SWIFT_PRIVATE;
+
+  public:
+    World() = default;
+    explicit World(double tickRate, std::optional<double> gx, std::optional<double> gy): tickRate(tickRate), gx(gx), gy(gy) {}
+
+  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, "tickRate"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "gx"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "gy")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::rngine::World& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "tickRate"), JSIConverter<double>::toJSI(runtime, arg.tickRate));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "gx"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.gx));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "gy"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.gy));
+      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, "tickRate")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "gx")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "gy")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rngine",
-  "version": "0.7.1",
+  "version": "0.8.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/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

@@ -5,7 +5,6 @@
 #include <android/log.h>
 #include <chrono>
 #include <cinttypes>
-#include <set>
 
 namespace margelo::nitro::rngine {
 
@@ -32,6 +31,11 @@ GameLoop::~GameLoop() {
   __android_log_print(ANDROID_LOG_INFO, "GameLoop", "Destructor - Complete");
 }
 
+bool GameLoop::entityIdMatches(const std::string &entityId,
+                               const std::string &prefix) {
+  return entityId == prefix || entityId.starts_with(prefix + "_");
+}
+
 std::vector<Entity *>
 GameLoop::resolveEntitiesInternal(const std::string &prefix) {
   std::vector<Entity *> results;
@@ -69,7 +73,11 @@ void GameLoop::runGameLoop() {
   double accumulator = 0.0;
 
   while (_isRunning) {
-    double targetDeltaTime = 1.0 / _tickRate.load();
+    double targetDeltaTime;
+    {
+      std::lock_guard<std::mutex> lock(_worldMutex);
+      targetDeltaTime = 1.0 / _world.tickRate;
+    }
     auto currentTime = steady_clock::now();
     double frameTime = duration<double>(currentTime - previousTime).count();
     previousTime = currentTime;
@@ -108,28 +116,14 @@ void GameLoop::runSystems() {
     }
 
     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 (const auto &entityA : resolvedEntitiesInternalA) {
-          for (const auto &entityB : resolvedEntitiesInternalB) {
-            if (entityA == entityB)
-              continue;
-
-            auto uniqueEntityIdPairKey = std::minmax(entityA->id, entityB->id);
-
-            if (uniqueEntityIdPairs.count(uniqueEntityIdPairKey))
-              continue;
-
-            uniqueEntityIdPairs.insert(uniqueEntityIdPairKey);
-
-            if (auto ov = CollisionUtils::shapeOverlap(*entityA, *entityB)) {
-              collisions.push_back(
-                  Collision(entityA->id, entityB->id, ov.value()));
-            }
+      for (const auto &pair : system.collisions.value()) {
+        for (const auto &c : _collisions) {
+          bool matchesForward =
+              entityIdMatches(c.a, pair.a) && entityIdMatches(c.b, pair.b);
+          bool matchesReverse =
+              entityIdMatches(c.a, pair.b) && entityIdMatches(c.b, pair.a);
+          if (matchesForward || matchesReverse) {
+            collisions.push_back(c);
           }
         }
       }
@@ -161,6 +155,8 @@ void GameLoop::captureSnapshot() {
 void GameLoop::update(double deltaTime) {
   updateStats(deltaTime);
   updateEntities(deltaTime);
+  computeCollisions();
+  resolveCollisions();
   runSystems();
   captureSnapshot();
 }
@@ -189,10 +185,20 @@ void GameLoop::updateStats(double deltaTime) {
 }
 
 void GameLoop::updateEntities(double deltaTime) {
+  std::lock_guard<std::mutex> worldLock(_worldMutex);
   std::lock_guard<std::mutex> lock(_mutex);
 
   for (auto &[id, entity] : _entities) {
 
+    if (entity.mass.has_value() && entity.mass.value() > 0.0) {
+      if (_world.gx.has_value()) {
+        entity.vx = entity.vx.value_or(0.0) + _world.gx.value() * deltaTime;
+      }
+      if (_world.gy.has_value()) {
+        entity.vy = entity.vy.value_or(0.0) + _world.gy.value() * deltaTime;
+      }
+    }
+
     if (entity.ax.has_value()) {
       entity.vx = entity.vx.value_or(0.0) + entity.ax.value() * deltaTime;
     }
@@ -216,4 +222,77 @@ void GameLoop::updateEntities(double deltaTime) {
     }
   }
 }
+
+void GameLoop::computeCollisions() {
+  std::lock_guard<std::mutex> lock(_mutex);
+  _collisions.clear();
+
+  std::vector<Entity *> entities;
+  entities.reserve(_entities.size());
+  for (auto &[id, entity] : _entities) {
+    entities.push_back(&entity);
+  }
+
+  for (size_t i = 0; i < entities.size(); ++i) {
+    for (size_t j = i + 1; j < entities.size(); ++j) {
+      auto result = CollisionUtils::shapeOverlap(*entities[i], *entities[j]);
+      if (result.has_value()) {
+        _collisions.push_back(result.value());
+      }
+    }
+  }
+}
+
+void GameLoop::resolveCollisions() {
+  std::lock_guard<std::mutex> lock(_mutex);
+
+  const double percent = 0.8;
+  const double slop = 0.01;
+
+  for (const auto &c : _collisions) {
+    auto itA = _entities.find(c.a);
+    auto itB = _entities.find(c.b);
+    if (itA == _entities.end() || itB == _entities.end())
+      continue;
+
+    Entity &a = itA->second;
+    Entity &b = itB->second;
+
+    if (a.isSensor.value_or(false) || b.isSensor.value_or(false))
+      continue;
+
+    double inverseMassA = (a.mass.has_value() && a.mass.value() > 0.0)
+                              ? 1.0 / a.mass.value()
+                              : 0.0;
+    double inverseMassB = (b.mass.has_value() && b.mass.value() > 0.0)
+                              ? 1.0 / b.mass.value()
+                              : 0.0;
+    double totalInverseMass = inverseMassA + inverseMassB;
+    if (totalInverseMass == 0.0)
+      continue;
+
+    double correctionDepth = std::max(c.depth - slop, 0.0);
+    double correction = (correctionDepth / totalInverseMass) * percent;
+    a.px -= c.nx * correction * inverseMassA;
+    a.py -= c.ny * correction * inverseMassA;
+    b.px += c.nx * correction * inverseMassB;
+    b.py += c.ny * correction * inverseMassB;
+
+    double avx = a.vx.value_or(0.0), avy = a.vy.value_or(0.0);
+    double bvx = b.vx.value_or(0.0), bvy = b.vy.value_or(0.0);
+    double relativeVx = bvx - avx, relativeVy = bvy - avy;
+    double velocityAlongNormal = relativeVx * c.nx + relativeVy * c.ny;
+    if (velocityAlongNormal > 0)
+      continue;
+
+    double restitution = 0.0;
+    double impulse =
+        -(1 + restitution) * velocityAlongNormal / totalInverseMass;
+
+    a.vx = avx - impulse * c.nx * inverseMassA;
+    a.vy = avy - impulse * c.ny * inverseMassA;
+    b.vx = bvx + impulse * c.nx * inverseMassB;
+    b.vy = bvy + impulse * c.ny * inverseMassB;
+  }
+}
 } // namespace margelo::nitro::rngine

package/shared/GameLoop.hpp

@@ -4,6 +4,7 @@
 #include "GameStats.hpp"
 #include "Screen.hpp"
 #include "System.hpp"
+#include "World.hpp"
 #include <atomic>
 #include <memory>
 #include <thread>
@@ -20,6 +21,7 @@ public:
 
   ~GameLoop();
 
+  std::mutex &getWorldMutexInternal() { return _worldMutex; };
   std::mutex &getMutexInternal() { return _mutex; };
   std::mutex &getSnapshotMutexInternal() { return _snapshotMutex; };
   std::map<string, Entity> &getEntitiesInternal() { return _entities; };
@@ -28,25 +30,27 @@ public:
   };
   std::vector<System> &getSystemsInternal() { return _systems; };
   std::atomic<bool> &getIsPausedInternal() { return _isPaused; };
+  World &getWorldInternal() { return _world; };
   Screen &getScreenInternal() { return _screen; };
   Screen &getScreenSnapshotInternal() { return _screenSnapshot; };
 
+  bool entityIdMatches(const std::string &entityId, const std::string &prefix);
   std::vector<Entity *> resolveEntitiesInternal(const std::string &prefix);
   void registerLottieDuration(double, double);
 
-  void setTickRate(double tickRate) { _tickRate.store(tickRate); };
-
 private:
   explicit GameLoop();
+  std::mutex _worldMutex;
   std::mutex _mutex;
   std::mutex _snapshotMutex;
   std::map<std::string, Entity> _entities;
   std::map<std::string, Entity> _entitiesSnapshot;
   std::map<double, double> _lottieDurations;
+  std::vector<Collision> _collisions{};
   std::vector<System> _systems{};
   std::atomic<bool> _isRunning{true};
   std::atomic<bool> _isPaused{true};
-  std::atomic<double> _tickRate{60.0};
+  World _world;
   Screen _screen;
   Screen _screenSnapshot;
   GameStats _gameStats;
@@ -54,6 +58,8 @@ private:
 
   void runGameLoop();
   void runSystems();
+  void computeCollisions();
+  void resolveCollisions();
   void captureSnapshot();
   void update(double deltaTime);
   void updateStats(double deltaTime);

package/shared/GameMethods.cpp

@@ -4,11 +4,12 @@
 #include <android/log.h>
 
 namespace margelo::nitro::rngine {
-void GameMethods::setTickRate(double tickRate) {
+void GameMethods::setWorld(const World &world) {
   auto &instance = GameLoop::getInstance();
-  instance.setTickRate(tickRate);
+  std::lock_guard<std::mutex> lock(instance.getWorldMutexInternal());
+  instance.getWorldInternal() = world;
   __android_log_print(ANDROID_LOG_INFO, "GameMethods",
-                      "setTickRate: tickRate=%.1f", tickRate);
+                      "setWorld: tickRate=%.1f", world.tickRate);
 }
 
 void GameMethods::setScreen(const Screen &screen) {
@@ -19,7 +20,7 @@ void GameMethods::setScreen(const Screen &screen) {
   instance.getScreenSnapshotInternal() = screen;
 
   __android_log_print(ANDROID_LOG_INFO, "GameMethods",
-                      "setWorld: width=%.0f height=%.0f", screen.width,
+                      "setScreen: width=%.0f height=%.0f", screen.width,
                       screen.height);
 }
 
@@ -130,6 +131,9 @@ void GameMethods::update(const std::vector<EntityUpdate> &updates) {
       if (update.shape.has_value()) {
         entity->shape = update.shape.value();
       }
+      if (update.isSensor.has_value()) {
+        entity->isSensor = update.isSensor.value();
+      }
       if (update.asset.has_value()) {
         entity->asset = update.asset.value();
       }
@@ -151,6 +155,9 @@ void GameMethods::update(const std::vector<EntityUpdate> &updates) {
       if (update.ay.has_value()) {
         entity->ay = update.ay.value();
       }
+      if (update.mass.has_value()) {
+        entity->mass = update.mass.value();
+      }
     }
 
     __android_log_print(ANDROID_LOG_INFO, "GameMethods",

package/shared/GameMethods.hpp

@@ -1,12 +1,13 @@
 #pragma once
 
 #include "HybridGameMethodsSpec.hpp"
+#include "World.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 setScreen(const Screen &screen) override;
   void setEntities(const std::vector<Entity> &entities) override;
   void setSystems(const std::vector<System> &systems) override;

package/src/GameMethods.nitro.ts

@@ -1,12 +1,18 @@
 import type { HybridObject } from 'react-native-nitro-modules';
-import type { Entity, EntityUpdate, System, Screen } from './nativeTypes';
+import type {
+  Entity,
+  EntityUpdate,
+  System,
+  Screen,
+  World,
+} from './nativeTypes';
 import { NitroModules } from 'react-native-nitro-modules';
 
 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;

package/src/GameMethods.ts

@@ -4,7 +4,7 @@ import type { Config } from './types';
 
 /** Sets up the game engine with the given configuration. Call this before anything else. */
 export const configure = ({
-  tickRate,
+  world,
   screen,
   entities = [],
   systems = [],
@@ -25,7 +25,7 @@ export const configure = ({
     });
   }
 
-  gameMethods.setTickRate(tickRate);
+  gameMethods.setWorld(world);
   gameMethods.setScreen(screen);
   gameMethods.setEntities(entities);
   gameMethods.setSystems(nativeSystems);

package/src/index.tsx

@@ -4,6 +4,7 @@ export * from './GameMethods';
 export * from './GameAssets';
 export * from './types';
 export type {
+  World,
   Screen,
   Entity,
   CollisionPair,

package/src/nativeTypes.ts

@@ -20,6 +20,8 @@ interface Circle {
 interface Shaped {
   /** Shape of the entity. */
   shape: Rect | Circle;
+  /** Indicates whether the entity is a sensor. Sensors trigger collision events but don't react physically. */
+  isSensor?: boolean;
 }
 
 interface Renderable {
@@ -40,6 +42,17 @@ interface Kinematic {
   ax?: number;
   /** Vertical acceleration in game units per second squared. */
   ay?: number;
+  /** Mass in arbitrary units. */
+  mass?: number;
+}
+
+export interface World {
+  /** Number of game logic updates per second. */
+  tickRate: number;
+  /** Horizontal gravitational acceleration in game units per second squared. */
+  gx?: number;
+  /** Vertical gravitational acceleration in game units per second squared. */
+  gy?: number;
 }
 
 export interface Screen extends Rect, Renderable {}
@@ -70,6 +83,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 {

package/src/types.ts

@@ -3,6 +3,7 @@ import type {
   Collision,
   Screen,
   Entity,
+  World,
 } from './nativeTypes';
 
 export type System = Omit<NativeSystem, 'onTick'> & {
@@ -11,17 +12,14 @@ export type System = Omit<NativeSystem, 'onTick'> & {
 };
 
 export type Config = {
-  /** Number of game logic updates per second. */
-  tickRate: number;
-  /** Screen dimensions and background color. */
+  /** World settings: tick rate and gravity. */
+  world: World;
+  /** Screen dimensions and background. */
   screen: Screen;
-  /** Initial entities to spawn. */
+  /** Entities to spawn when the game starts. */
   entities?: Entity[];
-  /**
-   * Systems that define the game logic. Each system runs every tick
-   * and receives the entities matching its ids.
-   */
+  /** Systems that define game logic, each running every tick against its subscribed entities and collisions. */
   systems?: System[];
-  /** Whether to start paused. Defaults to true. */
+  /** Whether the game starts paused. Defaults to true. */
   paused?: boolean;
 };