@lagless/create 0.0.38 → 0.0.39

package/templates/pixi-react/__packageName__-simulation/src/lib/arena.ts

@@ -1,8 +1,20 @@
+<% if (simulationType === 'physics3d') { -%>
+export const <%= projectName %>Arena = {
+  width: 40,
+  depth: 30,
+  playerRadius: 0.5,
+  moveSpeed: 5.0,
+  hashReportInterval: 120,
+} as const;
+<% } else { -%>
 export const <%= projectName %>Arena = {
   width: 800,
   height: 600,
   playerRadius: 20,
   moveSpeed: 3.0,
+<% if (simulationType === 'raw') { -%>
   damping: 0.85,
+<% } -%>
   hashReportInterval: 120,
 } as const;
+<% } -%>

package/templates/pixi-react/__packageName__-simulation/src/lib/schema/ecs.yaml

@@ -1,3 +1,4 @@
+<% if (simulationType === 'raw') { -%>
 # Run codegen: npx @lagless/codegen -c <%= packageName %>-simulation/src/lib/schema/ecs.yaml
 projectName: <%= projectName %>
 
@@ -43,10 +44,93 @@ inputs:
 
 filters:
   PlayerFilter:
-    include:
-      - Transform2d
-      - PlayerBody
+    include: [Transform2d, PlayerBody]
   MovingFilter:
-    include:
-      - Transform2d
-      - Velocity2d
+    include: [Transform2d, Velocity2d]
+<% } else if (simulationType === 'physics2d') { -%>
+# Run codegen: npx @lagless/codegen -c <%= packageName %>-simulation/src/lib/schema/ecs.yaml
+projectName: <%= projectName %>
+simulationType: physics2d
+
+# Transform2d (positionX/Y, rotation, prevPositionX/Y, prevRotation) and PhysicsRefs
+# are auto-prepended by codegen when simulationType is physics2d.
+
+components:
+  PlayerBody:
+    playerSlot: uint8
+    radius: float32
+
+singletons:
+  GameState:
+    gamePhase: uint8
+
+playerResources:
+  PlayerResource:
+    id: uint8[16]
+    entity: uint32
+    connected: uint8
+    lastReportedHash: uint32
+    lastReportedHashTick: uint32
+    hashMismatchCount: uint16
+
+inputs:
+  PlayerJoined:
+    slot: uint8
+    playerId: uint8[16]
+  PlayerLeft:
+    slot: uint8
+    reason: uint8
+  MoveInput:
+    directionX: float32
+    directionY: float32
+  ReportHash:
+    hash: uint32
+    atTick: uint32
+
+filters:
+  PlayerFilter:
+    include: [Transform2d, PhysicsRefs, PlayerBody]
+<% } else { -%>
+# Run codegen: npx @lagless/codegen -c <%= packageName %>-simulation/src/lib/schema/ecs.yaml
+projectName: <%= projectName %>
+simulationType: physics3d
+
+# Transform3d (positionX/Y/Z, rotationX/Y/Z/W, prev*) and PhysicsRefs
+# are auto-prepended by codegen when simulationType is physics3d.
+
+components:
+  PlayerBody:
+    playerSlot: uint8
+    radius: float32
+
+singletons:
+  GameState:
+    gamePhase: uint8
+
+playerResources:
+  PlayerResource:
+    id: uint8[16]
+    entity: uint32
+    connected: uint8
+    lastReportedHash: uint32
+    lastReportedHashTick: uint32
+    hashMismatchCount: uint16
+
+inputs:
+  PlayerJoined:
+    slot: uint8
+    playerId: uint8[16]
+  PlayerLeft:
+    slot: uint8
+    reason: uint8
+  MoveInput:
+    directionX: float32
+    directionY: float32
+  ReportHash:
+    hash: uint32
+    atTick: uint32
+
+filters:
+  PlayerFilter:
+    include: [Transform3d, PhysicsRefs, PlayerBody]
+<% } -%>

package/templates/pixi-react/__packageName__-simulation/src/lib/systems/apply-move-input.system.ts

@@ -1,3 +1,75 @@
+<% if (simulationType === 'physics3d') { -%>
+import { ECSSystem, IECSSystem, InputProvider, PlayerResources } from '@lagless/core';
+import { MoveInput, PlayerResource } from '../schema/code-gen/index.js';
+import { PhysicsWorldManager3d } from '@lagless/physics3d';
+import { PhysicsRefs } from '../schema/code-gen/index.js';
+import { <%= projectName %>Arena } from '../arena.js';
+
+const finite = (v: number): number => Number.isFinite(v) ? v : 0;
+
+@ECSSystem()
+export class ApplyMoveInputSystem implements IECSSystem {
+  constructor(
+    private readonly _InputProvider: InputProvider,
+    private readonly _PlayerResources: PlayerResources,
+    private readonly _PhysicsRefs: PhysicsRefs,
+    private readonly _WorldManager: PhysicsWorldManager3d,
+  ) {}
+
+  public update(tick: number): void {
+    const rpcs = this._InputProvider.collectTickRPCs(tick, MoveInput);
+
+    for (const rpc of rpcs) {
+      const playerResource = this._PlayerResources.get(PlayerResource, rpc.meta.playerSlot);
+      const entity = playerResource.safe.entity;
+
+      // Sanitize input
+      const dirX = finite(rpc.data.directionX);
+      const dirZ = finite(rpc.data.directionY); // directionY maps to Z axis in 3D
+
+      const body = this._WorldManager.getBody(this._PhysicsRefs.unsafe.bodyHandle[entity]);
+      body.setLinvel(
+        { x: dirX * <%= projectName %>Arena.moveSpeed, y: body.linvel().y, z: dirZ * <%= projectName %>Arena.moveSpeed },
+        true,
+      );
+    }
+  }
+}
+<% } else if (simulationType === 'physics2d') { -%>
+import { ECSSystem, IECSSystem, InputProvider, PlayerResources } from '@lagless/core';
+import { MoveInput, PlayerResource } from '../schema/code-gen/index.js';
+import { PhysicsWorldManager2d } from '@lagless/physics2d';
+import { PhysicsRefs } from '../schema/code-gen/index.js';
+import { <%= projectName %>Arena } from '../arena.js';
+
+const finite = (v: number): number => Number.isFinite(v) ? v : 0;
+
+@ECSSystem()
+export class ApplyMoveInputSystem implements IECSSystem {
+  constructor(
+    private readonly _InputProvider: InputProvider,
+    private readonly _PlayerResources: PlayerResources,
+    private readonly _PhysicsRefs: PhysicsRefs,
+    private readonly _WorldManager: PhysicsWorldManager2d,
+  ) {}
+
+  public update(tick: number): void {
+    const rpcs = this._InputProvider.collectTickRPCs(tick, MoveInput);
+
+    for (const rpc of rpcs) {
+      const playerResource = this._PlayerResources.get(PlayerResource, rpc.meta.playerSlot);
+      const entity = playerResource.safe.entity;
+
+      // Sanitize input
+      const dirX = finite(rpc.data.directionX);
+      const dirY = finite(rpc.data.directionY);
+
+      const body = this._WorldManager.getBody(this._PhysicsRefs.unsafe.bodyHandle[entity]);
+      body.setLinvel({ x: dirX * <%= projectName %>Arena.moveSpeed, y: dirY * <%= projectName %>Arena.moveSpeed }, true);
+    }
+  }
+}
+<% } else { -%>
 import { ECSSystem, IECSSystem, InputProvider, PlayerResources } from '@lagless/core';
 import { MoveInput, PlayerResource, Velocity2d } from '../schema/code-gen/index.js';
 import { <%= projectName %>Arena } from '../arena.js';
@@ -21,3 +93,4 @@ export class ApplyMoveInputSystem implements IECSSystem {
     }
   }
 }
+<% } -%>

package/templates/pixi-react/__packageName__-simulation/src/lib/systems/boundary.system.ts

@@ -1,3 +1,4 @@
+<% if (simulationType === 'raw') { -%>
 import { ECSSystem, IECSSystem } from '@lagless/core';
 import { Transform2d, PlayerBody, PlayerFilter } from '../schema/code-gen/index.js';
 import { <%= projectName %>Arena } from '../arena.js';
@@ -32,3 +33,4 @@ export class BoundarySystem implements IECSSystem {
     }
   }
 }
+<% } -%>

package/templates/pixi-react/__packageName__-simulation/src/lib/systems/damping.system.ts

@@ -1,3 +1,4 @@
+<% if (simulationType === 'raw') { -%>
 import { ECSSystem, IECSSystem } from '@lagless/core';
 import { Velocity2d, MovingFilter } from '../schema/code-gen/index.js';
 import { <%= projectName %>Arena } from '../arena.js';
@@ -16,3 +17,4 @@ export class DampingSystem implements IECSSystem {
     }
   }
 }
+<% } -%>

package/templates/pixi-react/__packageName__-simulation/src/lib/systems/index.ts

@@ -3,9 +3,13 @@ import { SavePrevTransformSystem } from './save-prev-transform.system.js';
 import { PlayerConnectionSystem } from './player-connection.system.js';
 import { PlayerLeaveSystem } from './player-leave.system.js';
 import { ApplyMoveInputSystem } from './apply-move-input.system.js';
+<% if (simulationType === 'raw') { -%>
 import { IntegrateSystem } from './integrate.system.js';
 import { DampingSystem } from './damping.system.js';
 import { BoundarySystem } from './boundary.system.js';
+<% } else { -%>
+import { PhysicsStepSystem } from './physics-step.system.js';
+<% } -%>
 import { HashVerificationSystem } from './hash-verification.system.js';
 
 export const <%= projectName %>Systems: IECSSystemConstructor[] = [
@@ -13,8 +17,12 @@ export const <%= projectName %>Systems: IECSSystemConstructor[] = [
   PlayerConnectionSystem,
   PlayerLeaveSystem,
   ApplyMoveInputSystem,
+<% if (simulationType === 'raw') { -%>
   IntegrateSystem,
   DampingSystem,
   BoundarySystem,
+<% } else { -%>
+  PhysicsStepSystem,
+<% } -%>
   HashVerificationSystem,
 ];

package/templates/pixi-react/__packageName__-simulation/src/lib/systems/integrate.system.ts

@@ -1,3 +1,4 @@
+<% if (simulationType === 'raw') { -%>
 import { ECSSystem, IECSSystem } from '@lagless/core';
 import { Transform2d, Velocity2d, MovingFilter } from '../schema/code-gen/index.js';
 
@@ -16,3 +17,4 @@ export class IntegrateSystem implements IECSSystem {
     }
   }
 }
+<% } -%>

package/templates/pixi-react/__packageName__-simulation/src/lib/systems/physics-step.system.ts

@@ -0,0 +1,65 @@
+<% if (simulationType === 'physics3d') { -%>
+import { ECSSystem, IECSSystem } from '@lagless/core';
+import { PhysicsWorldManager3d } from '@lagless/physics3d';
+import { Transform3d, PhysicsRefs, PlayerFilter } from '../schema/code-gen/index.js';
+
+@ECSSystem()
+export class PhysicsStepSystem implements IECSSystem {
+  constructor(
+    private readonly _WorldManager: PhysicsWorldManager3d,
+    private readonly _PlayerFilter: PlayerFilter,
+    private readonly _Transform3d: Transform3d,
+    private readonly _PhysicsRefs: PhysicsRefs,
+  ) {}
+
+  public update(): void {
+    this._WorldManager.step();
+
+    // Sync dynamic bodies: Rapier → ECS Transform
+    const t = this._Transform3d.unsafe;
+    const pr = this._PhysicsRefs.unsafe;
+    for (const entity of this._PlayerFilter) {
+      const body = this._WorldManager.getBody(pr.bodyHandle[entity]);
+      const pos = body.translation();
+      t.positionX[entity] = pos.x;
+      t.positionY[entity] = pos.y;
+      t.positionZ[entity] = pos.z;
+
+      const rot = body.rotation();
+      t.rotationX[entity] = rot.x;
+      t.rotationY[entity] = rot.y;
+      t.rotationZ[entity] = rot.z;
+      t.rotationW[entity] = rot.w;
+    }
+  }
+}
+<% } else if (simulationType === 'physics2d') { -%>
+import { ECSSystem, IECSSystem } from '@lagless/core';
+import { PhysicsWorldManager2d } from '@lagless/physics2d';
+import { Transform2d, PhysicsRefs, PlayerFilter } from '../schema/code-gen/index.js';
+
+@ECSSystem()
+export class PhysicsStepSystem implements IECSSystem {
+  constructor(
+    private readonly _WorldManager: PhysicsWorldManager2d,
+    private readonly _PlayerFilter: PlayerFilter,
+    private readonly _Transform2d: Transform2d,
+    private readonly _PhysicsRefs: PhysicsRefs,
+  ) {}
+
+  public update(): void {
+    this._WorldManager.step();
+
+    // Sync dynamic bodies: Rapier → ECS Transform
+    const t = this._Transform2d.unsafe;
+    const pr = this._PhysicsRefs.unsafe;
+    for (const entity of this._PlayerFilter) {
+      const body = this._WorldManager.getBody(pr.bodyHandle[entity]);
+      const pos = body.translation();
+      t.positionX[entity] = pos.x;
+      t.positionY[entity] = pos.y;
+      t.rotation[entity] = body.rotation();
+    }
+  }
+}
+<% } -%>

package/templates/pixi-react/__packageName__-simulation/src/lib/systems/player-connection.system.ts

@@ -1,3 +1,160 @@
+<% if (simulationType === 'physics3d') { -%>
+import { ECSConfig, ECSSystem, EntitiesManager, IECSSystem, InputProvider, PlayerResources, Prefab } from '@lagless/core';
+import { PlayerBody, PlayerJoined, PlayerResource, Transform3d, PhysicsRefs } from '../schema/code-gen/index.js';
+import { PhysicsWorldManager3d } from '@lagless/physics3d';
+import { BodyType } from '@lagless/physics-shared';
+import { <%= projectName %>Arena } from '../arena.js';
+
+@ECSSystem()
+export class PlayerConnectionSystem implements IECSSystem {
+  private readonly _playerPrefab = Prefab.create()
+    .with(Transform3d)
+    .with(PhysicsRefs)
+    .with(PlayerBody, { radius: <%= projectName %>Arena.playerRadius });
+
+  constructor(
+    private readonly _ECSConfig: ECSConfig,
+    private readonly _InputProvider: InputProvider,
+    private readonly _Transform3d: Transform3d,
+    private readonly _PhysicsRefs: PhysicsRefs,
+    private readonly _PlayerBody: PlayerBody,
+    private readonly _EntitiesManager: EntitiesManager,
+    private readonly _PlayerResources: PlayerResources,
+    private readonly _WorldManager: PhysicsWorldManager3d,
+  ) {}
+
+  public update(tick: number): void {
+    const rpcs = this._InputProvider.collectTickRPCs(tick, PlayerJoined);
+    const maxPlayers = this._ECSConfig.maxPlayers;
+    const spacing = <%= projectName %>Arena.width * 0.5 / Math.max(maxPlayers, 1);
+
+    for (const rpc of rpcs) {
+      const slot = rpc.data.slot;
+      const entity = this._EntitiesManager.createEntity(this._playerPrefab);
+
+      this._PlayerBody.unsafe.playerSlot[entity] = slot;
+
+      const spawnX = -<%= projectName %>Arena.width * 0.25 + slot * spacing;
+      const spawnY = 1.0;
+      const spawnZ = 0;
+
+      const t = this._Transform3d.unsafe;
+      t.positionX[entity] = spawnX;
+      t.positionY[entity] = spawnY;
+      t.positionZ[entity] = spawnZ;
+      t.prevPositionX[entity] = spawnX;
+      t.prevPositionY[entity] = spawnY;
+      t.prevPositionZ[entity] = spawnZ;
+      // Identity quaternion
+      t.rotationX[entity] = 0;
+      t.rotationY[entity] = 0;
+      t.rotationZ[entity] = 0;
+      t.rotationW[entity] = 1;
+      t.prevRotationX[entity] = 0;
+      t.prevRotationY[entity] = 0;
+      t.prevRotationZ[entity] = 0;
+      t.prevRotationW[entity] = 1;
+
+      // Create physics body
+      const body = this._WorldManager.createDynamicBody();
+      body.setTranslation({ x: spawnX, y: spawnY, z: spawnZ }, true);
+      body.setLinearDamping(5.0);
+
+      // Create ball collider
+      const collider = this._WorldManager.createBallCollider(<%= projectName %>Arena.playerRadius, body);
+
+      // Store handles in PhysicsRefs
+      const pr = this._PhysicsRefs.unsafe;
+      pr.bodyHandle[entity] = body.handle;
+      pr.colliderHandle[entity] = collider.handle;
+      pr.bodyType[entity] = BodyType.DYNAMIC;
+
+      // Register in collider-entity map
+      this._WorldManager.registerCollider(collider.handle, entity);
+
+      const playerResource = this._PlayerResources.get(PlayerResource, slot);
+      playerResource.safe.entity = entity;
+      playerResource.safe.connected = 1;
+      for (let i = 0; i < rpc.data.playerId.length; i++) {
+        playerResource.unsafe.id[i] = rpc.data.playerId[i];
+      }
+    }
+  }
+}
+<% } else if (simulationType === 'physics2d') { -%>
+import { ECSConfig, ECSSystem, EntitiesManager, IECSSystem, InputProvider, PlayerResources, Prefab } from '@lagless/core';
+import { PlayerBody, PlayerJoined, PlayerResource, Transform2d, PhysicsRefs } from '../schema/code-gen/index.js';
+import { PhysicsWorldManager2d } from '@lagless/physics2d';
+import { BodyType } from '@lagless/physics-shared';
+import { <%= projectName %>Arena } from '../arena.js';
+
+@ECSSystem()
+export class PlayerConnectionSystem implements IECSSystem {
+  private readonly _playerPrefab = Prefab.create()
+    .with(Transform2d)
+    .with(PhysicsRefs)
+    .with(PlayerBody, { radius: <%= projectName %>Arena.playerRadius });
+
+  constructor(
+    private readonly _ECSConfig: ECSConfig,
+    private readonly _InputProvider: InputProvider,
+    private readonly _Transform2d: Transform2d,
+    private readonly _PhysicsRefs: PhysicsRefs,
+    private readonly _PlayerBody: PlayerBody,
+    private readonly _EntitiesManager: EntitiesManager,
+    private readonly _PlayerResources: PlayerResources,
+    private readonly _WorldManager: PhysicsWorldManager2d,
+  ) {}
+
+  public update(tick: number): void {
+    const rpcs = this._InputProvider.collectTickRPCs(tick, PlayerJoined);
+    const maxPlayers = this._ECSConfig.maxPlayers;
+    const spacing = <%= projectName %>Arena.width * 0.5 / Math.max(maxPlayers, 1);
+
+    for (const rpc of rpcs) {
+      const slot = rpc.data.slot;
+      const entity = this._EntitiesManager.createEntity(this._playerPrefab);
+
+      this._PlayerBody.unsafe.playerSlot[entity] = slot;
+
+      const spawnX = <%= projectName %>Arena.width * 0.25 + slot * spacing;
+      const spawnY = <%= projectName %>Arena.height * 0.5;
+
+      const t = this._Transform2d.unsafe;
+      t.positionX[entity] = spawnX;
+      t.positionY[entity] = spawnY;
+      t.rotation[entity] = 0;
+      t.prevPositionX[entity] = spawnX;
+      t.prevPositionY[entity] = spawnY;
+      t.prevRotation[entity] = 0;
+
+      // Create physics body
+      const body = this._WorldManager.createDynamicBody();
+      body.setTranslation({ x: spawnX, y: spawnY }, true);
+      body.setLinearDamping(5.0);
+
+      // Create ball collider
+      const collider = this._WorldManager.createBallCollider(<%= projectName %>Arena.playerRadius, body);
+
+      // Store handles in PhysicsRefs
+      const pr = this._PhysicsRefs.unsafe;
+      pr.bodyHandle[entity] = body.handle;
+      pr.colliderHandle[entity] = collider.handle;
+      pr.bodyType[entity] = BodyType.DYNAMIC;
+
+      // Register in collider-entity map
+      this._WorldManager.registerCollider(collider.handle, entity);
+
+      const playerResource = this._PlayerResources.get(PlayerResource, slot);
+      playerResource.safe.entity = entity;
+      playerResource.safe.connected = 1;
+      for (let i = 0; i < rpc.data.playerId.length; i++) {
+        playerResource.unsafe.id[i] = rpc.data.playerId[i];
+      }
+    }
+  }
+}
+<% } else { -%>
 import { ECSConfig, ECSSystem, EntitiesManager, IECSSystem, InputProvider, PlayerResources, Prefab } from '@lagless/core';
 import { PlayerBody, PlayerJoined, PlayerResource, Transform2d, Velocity2d } from '../schema/code-gen/index.js';
 import { <%= projectName %>Arena } from '../arena.js';
@@ -45,3 +202,4 @@ export class PlayerConnectionSystem implements IECSSystem {
     }
   }
 }
+<% } -%>

package/templates/pixi-react/__packageName__-simulation/src/lib/systems/player-leave.system.ts

@@ -1,3 +1,72 @@
+<% if (simulationType === 'physics3d') { -%>
+import { ECSSystem, EntitiesManager, IECSSystem, InputProvider, PlayerResources } from '@lagless/core';
+import { PlayerLeft, PlayerResource, PhysicsRefs } from '../schema/code-gen/index.js';
+import { PhysicsWorldManager3d } from '@lagless/physics3d';
+
+@ECSSystem()
+export class PlayerLeaveSystem implements IECSSystem {
+  constructor(
+    private readonly _InputProvider: InputProvider,
+    private readonly _EntitiesManager: EntitiesManager,
+    private readonly _PlayerResources: PlayerResources,
+    private readonly _PhysicsRefs: PhysicsRefs,
+    private readonly _WorldManager: PhysicsWorldManager3d,
+  ) {}
+
+  public update(tick: number): void {
+    const rpcs = this._InputProvider.collectTickRPCs(tick, PlayerLeft);
+
+    for (const rpc of rpcs) {
+      const player = this._PlayerResources.get(PlayerResource, rpc.data.slot);
+      const entity = player.safe.entity;
+
+      // Remove physics objects
+      const colliderHandle = this._PhysicsRefs.unsafe.colliderHandle[entity];
+      const bodyHandle = this._PhysicsRefs.unsafe.bodyHandle[entity];
+      this._WorldManager.unregisterCollider(colliderHandle);
+      this._WorldManager.removeCollider(colliderHandle);
+      this._WorldManager.removeBody(bodyHandle);
+
+      player.safe.connected = 0;
+      this._EntitiesManager.removeEntity(entity);
+    }
+  }
+}
+<% } else if (simulationType === 'physics2d') { -%>
+import { ECSSystem, EntitiesManager, IECSSystem, InputProvider, PlayerResources } from '@lagless/core';
+import { PlayerLeft, PlayerResource, PhysicsRefs } from '../schema/code-gen/index.js';
+import { PhysicsWorldManager2d } from '@lagless/physics2d';
+
+@ECSSystem()
+export class PlayerLeaveSystem implements IECSSystem {
+  constructor(
+    private readonly _InputProvider: InputProvider,
+    private readonly _EntitiesManager: EntitiesManager,
+    private readonly _PlayerResources: PlayerResources,
+    private readonly _PhysicsRefs: PhysicsRefs,
+    private readonly _WorldManager: PhysicsWorldManager2d,
+  ) {}
+
+  public update(tick: number): void {
+    const rpcs = this._InputProvider.collectTickRPCs(tick, PlayerLeft);
+
+    for (const rpc of rpcs) {
+      const player = this._PlayerResources.get(PlayerResource, rpc.data.slot);
+      const entity = player.safe.entity;
+
+      // Remove physics objects
+      const colliderHandle = this._PhysicsRefs.unsafe.colliderHandle[entity];
+      const bodyHandle = this._PhysicsRefs.unsafe.bodyHandle[entity];
+      this._WorldManager.unregisterCollider(colliderHandle);
+      this._WorldManager.removeCollider(colliderHandle);
+      this._WorldManager.removeBody(bodyHandle);
+
+      player.safe.connected = 0;
+      this._EntitiesManager.removeEntity(entity);
+    }
+  }
+}
+<% } else { -%>
 import { ECSSystem, EntitiesManager, IECSSystem, InputProvider, PlayerResources } from '@lagless/core';
 import { PlayerLeft, PlayerResource } from '../schema/code-gen/index.js';
 
@@ -19,3 +88,4 @@ export class PlayerLeaveSystem implements IECSSystem {
     }
   }
 }
+<% } -%>

package/templates/pixi-react/__packageName__-simulation/src/lib/systems/save-prev-transform.system.ts

@@ -1,3 +1,48 @@
+<% if (simulationType === 'physics3d') { -%>
+import { ECSSystem, IECSSystem } from '@lagless/core';
+import { Transform3d, PlayerFilter } from '../schema/code-gen/index.js';
+
+@ECSSystem()
+export class SavePrevTransformSystem implements IECSSystem {
+  constructor(
+    private readonly _PlayerFilter: PlayerFilter,
+    private readonly _Transform3d: Transform3d,
+  ) {}
+
+  public update(): void {
+    const t = this._Transform3d.unsafe;
+    for (const entity of this._PlayerFilter) {
+      t.prevPositionX[entity] = t.positionX[entity];
+      t.prevPositionY[entity] = t.positionY[entity];
+      t.prevPositionZ[entity] = t.positionZ[entity];
+      t.prevRotationX[entity] = t.rotationX[entity];
+      t.prevRotationY[entity] = t.rotationY[entity];
+      t.prevRotationZ[entity] = t.rotationZ[entity];
+      t.prevRotationW[entity] = t.rotationW[entity];
+    }
+  }
+}
+<% } else if (simulationType === 'physics2d') { -%>
+import { ECSSystem, IECSSystem } from '@lagless/core';
+import { Transform2d, PlayerFilter } from '../schema/code-gen/index.js';
+
+@ECSSystem()
+export class SavePrevTransformSystem implements IECSSystem {
+  constructor(
+    private readonly _PlayerFilter: PlayerFilter,
+    private readonly _Transform2d: Transform2d,
+  ) {}
+
+  public update(): void {
+    const t = this._Transform2d.unsafe;
+    for (const entity of this._PlayerFilter) {
+      t.prevPositionX[entity] = t.positionX[entity];
+      t.prevPositionY[entity] = t.positionY[entity];
+      t.prevRotation[entity] = t.rotation[entity];
+    }
+  }
+}
+<% } else { -%>
 import { ECSSystem, IECSSystem } from '@lagless/core';
 import { Transform2d, PlayerFilter } from '../schema/code-gen/index.js';
 
@@ -15,3 +60,4 @@ export class SavePrevTransformSystem implements IECSSystem {
     }
   }
 }
+<% } -%>