@lagless/create 0.0.33

package/templates/pixi-react/__packageName__-simulation/src/lib/schema/code-gen/Velocity2d.ts

@@ -0,0 +1,55 @@
+// Generated by @lagless/codegen. Do not edit manually.
+import { MemoryTracker } from '@lagless/binary';
+
+export class Velocity2d {
+  public static readonly ID = 2;
+  public static readonly schema = {
+    velocityX: Float32Array,
+    velocityY: Float32Array,
+  };
+
+  public readonly unsafe = {} as {
+    velocityX: Float32Array;
+    velocityY: Float32Array;
+  };
+
+  private _cursorIndex = 0;
+  private readonly _cursor: {
+    readonly entity: number;
+    velocityX: number;
+    velocityY: number;
+  };
+
+  public getCursor(index: number) {
+    this._cursorIndex = index;
+    return this._cursor;
+  }
+
+  constructor(maxEntities: number, buffer: ArrayBuffer, memTracker: MemoryTracker) {
+    for (const [fieldName, TypedArrayConstructor] of Object.entries(Velocity2d.schema)) {
+      const typedArray = new TypedArrayConstructor(buffer, memTracker.ptr, maxEntities);
+      this.unsafe[fieldName as keyof typeof Velocity2d.schema] =
+        typedArray as Velocity2d['unsafe'][keyof Velocity2d['unsafe']];
+      memTracker.add(typedArray.byteLength);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self = this;
+
+    this._cursor = {
+      get entity(): number { return self._cursorIndex; },
+      get velocityX(): number { return self.unsafe.velocityX[self._cursorIndex]; },
+      set velocityX(value: number) { self.unsafe.velocityX[self._cursorIndex] = value; },
+      get velocityY(): number { return self.unsafe.velocityY[self._cursorIndex]; },
+      set velocityY(value: number) { self.unsafe.velocityY[self._cursorIndex] = value; },
+    };
+  }
+
+  public static calculateSize(maxEntities: number, memTracker: MemoryTracker): void {
+    for (const [, TypedArrayConstructor] of Object.entries(this.schema)) {
+      memTracker.add(maxEntities * TypedArrayConstructor.BYTES_PER_ELEMENT);
+    }
+  }
+}
+
+Object.defineProperty(Velocity2d, 'name', { value: 'Velocity2d' });

package/templates/pixi-react/__packageName__-simulation/src/lib/schema/code-gen/__ProjectName__.core.ts

@@ -0,0 +1,22 @@
+// Generated by @lagless/codegen. Do not edit manually.
+import { ECSDeps } from '@lagless/core';
+
+import { Transform2d } from './Transform2d.js';
+import { Velocity2d } from './Velocity2d.js';
+import { PlayerBody } from './PlayerBody.js';
+import { GameState } from './GameState.js';
+import { PlayerResource } from './PlayerResource.js';
+import { PlayerFilter } from './PlayerFilter.js';
+import { MovingFilter } from './MovingFilter.js';
+import { PlayerJoined } from './PlayerJoined.js';
+import { PlayerLeft } from './PlayerLeft.js';
+import { MoveInput } from './MoveInput.js';
+import { ReportHash } from './ReportHash.js';
+
+export const <%= projectName %>Core: ECSDeps = {
+  components: [Transform2d, Velocity2d, PlayerBody],
+  singletons: [GameState],
+  playerResources: [PlayerResource],
+  filters: [PlayerFilter, MovingFilter],
+  inputs: [PlayerJoined, PlayerLeft, MoveInput, ReportHash],
+};

package/templates/pixi-react/__packageName__-simulation/src/lib/schema/code-gen/__ProjectName__.runner.ts

@@ -0,0 +1,16 @@
+// Generated by @lagless/codegen. Do not edit manually.
+import { AbstractInputProvider, ECSConfig, ECSRunner } from '@lagless/core';
+import { IECSSystemConstructor, ISignalConstructor } from '@lagless/core';
+
+import { <%= projectName %>Core } from './<%= projectName %>.core.js';
+
+export class <%= projectName %>Runner extends ECSRunner {
+  constructor(
+    Config: ECSConfig,
+    InputProviderInstance: AbstractInputProvider,
+    Systems: Array<IECSSystemConstructor>,
+    Signals: Array<ISignalConstructor> = []
+  ) {
+    super(Config, InputProviderInstance, Systems, Signals, <%= projectName %>Core);
+  }
+}

package/templates/pixi-react/__packageName__-simulation/src/lib/schema/code-gen/__ProjectName__InputRegistry.ts

@@ -0,0 +1,8 @@
+// Generated by @lagless/codegen. Do not edit manually.
+import { InputRegistry } from '@lagless/core';
+import { PlayerJoined } from './PlayerJoined.js';
+import { PlayerLeft } from './PlayerLeft.js';
+import { MoveInput } from './MoveInput.js';
+import { ReportHash } from './ReportHash.js';
+
+export const <%= projectName %>InputRegistry = new InputRegistry([PlayerJoined, PlayerLeft, MoveInput, ReportHash]);

package/templates/pixi-react/__packageName__-simulation/src/lib/schema/code-gen/index.ts

@@ -0,0 +1,16 @@
+// Generated by @lagless/codegen. Do not edit manually.
+
+export * from './<%= projectName %>.core.js';
+export * from './<%= projectName %>.runner.js';
+export * from './<%= projectName %>InputRegistry.js';
+export * from './Transform2d.js';
+export * from './Velocity2d.js';
+export * from './PlayerBody.js';
+export * from './GameState.js';
+export * from './PlayerResource.js';
+export * from './PlayerFilter.js';
+export * from './MovingFilter.js';
+export * from './PlayerJoined.js';
+export * from './PlayerLeft.js';
+export * from './MoveInput.js';
+export * from './ReportHash.js';

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

@@ -0,0 +1,52 @@
+# Run codegen: npx @lagless/codegen -c <%= packageName %>-simulation/src/lib/schema/ecs.yaml
+projectName: <%= projectName %>
+
+components:
+  Transform2d:
+    positionX: float32
+    positionY: float32
+    prevPositionX: float32
+    prevPositionY: float32
+  Velocity2d:
+    velocityX: float32
+    velocityY: float32
+  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
+      - PlayerBody
+  MovingFilter:
+    include:
+      - Transform2d
+      - Velocity2d

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

@@ -0,0 +1,5 @@
+import { ISignalConstructor, DivergenceSignal } from '@lagless/core';
+
+export { DivergenceSignal, type DivergenceData } from '@lagless/core';
+
+export const <%= projectName %>Signals: ISignalConstructor[] = [DivergenceSignal];

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

@@ -0,0 +1,23 @@
+import { ECSSystem, IECSSystem, InputProvider, PlayerResources } from '@lagless/core';
+import { MoveInput, PlayerResource, Velocity2d } from '../schema/code-gen/index.js';
+import { <%= projectName %>Arena } from '../arena.js';
+
+@ECSSystem()
+export class ApplyMoveInputSystem implements IECSSystem {
+  constructor(
+    private readonly _InputProvider: InputProvider,
+    private readonly _PlayerResources: PlayerResources,
+    private readonly _Velocity2d: Velocity2d,
+  ) {}
+
+  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;
+      this._Velocity2d.unsafe.velocityX[entity] = rpc.data.directionX * <%= projectName %>Arena.moveSpeed;
+      this._Velocity2d.unsafe.velocityY[entity] = rpc.data.directionY * <%= projectName %>Arena.moveSpeed;
+    }
+  }
+}

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

@@ -0,0 +1,34 @@
+import { ECSSystem, IECSSystem } from '@lagless/core';
+import { Transform2d, PlayerBody, PlayerFilter } from '../schema/code-gen/index.js';
+import { <%= projectName %>Arena } from '../arena.js';
+
+@ECSSystem()
+export class BoundarySystem implements IECSSystem {
+  constructor(
+    private readonly _PlayerFilter: PlayerFilter,
+    private readonly _Transform2d: Transform2d,
+    private readonly _PlayerBody: PlayerBody,
+  ) {}
+
+  public update(): void {
+    for (const entity of this._PlayerFilter) {
+      const radius = this._PlayerBody.unsafe.radius[entity];
+      const minX = radius;
+      const maxX = <%= projectName %>Arena.width - radius;
+      const minY = radius;
+      const maxY = <%= projectName %>Arena.height - radius;
+
+      let x = this._Transform2d.unsafe.positionX[entity];
+      let y = this._Transform2d.unsafe.positionY[entity];
+
+      if (x < minX) x = minX;
+      else if (x > maxX) x = maxX;
+
+      if (y < minY) y = minY;
+      else if (y > maxY) y = maxY;
+
+      this._Transform2d.unsafe.positionX[entity] = x;
+      this._Transform2d.unsafe.positionY[entity] = y;
+    }
+  }
+}

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

@@ -0,0 +1,18 @@
+import { ECSSystem, IECSSystem } from '@lagless/core';
+import { Velocity2d, MovingFilter } from '../schema/code-gen/index.js';
+import { <%= projectName %>Arena } from '../arena.js';
+
+@ECSSystem()
+export class DampingSystem implements IECSSystem {
+  constructor(
+    private readonly _MovingFilter: MovingFilter,
+    private readonly _Velocity2d: Velocity2d,
+  ) {}
+
+  public update(): void {
+    for (const entity of this._MovingFilter) {
+      this._Velocity2d.unsafe.velocityX[entity] *= <%= projectName %>Arena.damping;
+      this._Velocity2d.unsafe.velocityY[entity] *= <%= projectName %>Arena.damping;
+    }
+  }
+}

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

@@ -0,0 +1,17 @@
+import { ECSConfig, ECSSystem, InputProvider, PlayerResources, AbstractHashVerificationSystem, DivergenceSignal } from '@lagless/core';
+import { PlayerResource, ReportHash } from '../schema/code-gen/index.js';
+
+@ECSSystem()
+export class HashVerificationSystem extends AbstractHashVerificationSystem {
+  protected readonly _reportHashRpc = ReportHash;
+  protected readonly _playerResourceClass = PlayerResource;
+
+  constructor(
+    ecsConfig: ECSConfig,
+    inputProvider: InputProvider,
+    playerResources: PlayerResources,
+    divergenceSignal: DivergenceSignal,
+  ) {
+    super(ecsConfig, inputProvider, playerResources, divergenceSignal);
+  }
+}

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

@@ -0,0 +1,20 @@
+import { IECSSystemConstructor } from '@lagless/core';
+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';
+import { IntegrateSystem } from './integrate.system.js';
+import { DampingSystem } from './damping.system.js';
+import { BoundarySystem } from './boundary.system.js';
+import { HashVerificationSystem } from './hash-verification.system.js';
+
+export const <%= projectName %>Systems: IECSSystemConstructor[] = [
+  SavePrevTransformSystem,
+  PlayerConnectionSystem,
+  PlayerLeaveSystem,
+  ApplyMoveInputSystem,
+  IntegrateSystem,
+  DampingSystem,
+  BoundarySystem,
+  HashVerificationSystem,
+];

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

@@ -0,0 +1,18 @@
+import { ECSSystem, IECSSystem } from '@lagless/core';
+import { Transform2d, Velocity2d, MovingFilter } from '../schema/code-gen/index.js';
+
+@ECSSystem()
+export class IntegrateSystem implements IECSSystem {
+  constructor(
+    private readonly _MovingFilter: MovingFilter,
+    private readonly _Velocity2d: Velocity2d,
+    private readonly _Transform2d: Transform2d,
+  ) {}
+
+  public update(): void {
+    for (const entity of this._MovingFilter) {
+      this._Transform2d.unsafe.positionX[entity] += this._Velocity2d.unsafe.velocityX[entity];
+      this._Transform2d.unsafe.positionY[entity] += this._Velocity2d.unsafe.velocityY[entity];
+    }
+  }
+}

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

@@ -0,0 +1,47 @@
+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';
+
+@ECSSystem()
+export class PlayerConnectionSystem implements IECSSystem {
+  private readonly _playerPrefab = Prefab.create()
+    .with(Transform2d)
+    .with(Velocity2d)
+    .with(PlayerBody, { radius: <%= projectName %>Arena.playerRadius });
+
+  constructor(
+    private readonly _ECSConfig: ECSConfig,
+    private readonly _InputProvider: InputProvider,
+    private readonly _Transform2d: Transform2d,
+    private readonly _PlayerBody: PlayerBody,
+    private readonly _EntitiesManager: EntitiesManager,
+    private readonly _PlayerResources: PlayerResources,
+  ) {}
+
+  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;
+      this._Transform2d.unsafe.positionX[entity] = spawnX;
+      this._Transform2d.unsafe.positionY[entity] = spawnY;
+      this._Transform2d.unsafe.prevPositionX[entity] = spawnX;
+      this._Transform2d.unsafe.prevPositionY[entity] = spawnY;
+
+      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];
+      }
+    }
+  }
+}

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

@@ -0,0 +1,21 @@
+import { ECSSystem, EntitiesManager, IECSSystem, InputProvider, PlayerResources } from '@lagless/core';
+import { PlayerLeft, PlayerResource } from '../schema/code-gen/index.js';
+
+@ECSSystem()
+export class PlayerLeaveSystem implements IECSSystem {
+  constructor(
+    private readonly _InputProvider: InputProvider,
+    private readonly _EntitiesManager: EntitiesManager,
+    private readonly _PlayerResources: PlayerResources,
+  ) {}
+
+  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);
+      player.safe.connected = 0;
+      this._EntitiesManager.removeEntity(player.safe.entity);
+    }
+  }
+}

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

@@ -0,0 +1,17 @@
+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 {
+    for (const entity of this._PlayerFilter) {
+      this._Transform2d.unsafe.prevPositionX[entity] = this._Transform2d.unsafe.positionX[entity];
+      this._Transform2d.unsafe.prevPositionY[entity] = this._Transform2d.unsafe.positionY[entity];
+    }
+  }
+}

package/templates/pixi-react/__packageName__-simulation/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "baseUrl": ".",
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src/**/*.ts"]
+}

package/templates/pixi-react/package.json

@@ -0,0 +1,8 @@
+{
+  "private": true,
+  "scripts": {
+    "dev:frontend": "pnpm --filter <%= packageName %>-frontend dev",
+    "dev:backend": "pnpm --filter <%= packageName %>-backend dev",
+    "codegen": "npx @lagless/codegen -c <%= packageName %>-simulation/src/lib/schema/ecs.yaml"
+  }
+}

package/templates/pixi-react/pnpm-workspace.yaml

@@ -0,0 +1,4 @@
+packages:
+  - '<%= packageName %>-simulation'
+  - '<%= packageName %>-frontend'
+  - '<%= packageName %>-backend'

package/templates/pixi-react/tsconfig.base.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "composite": true
+  }
+}