Create new ecs system

.vscode/forge.code-snippets

@@ -0,0 +1,38 @@
+{
+  "Forge: New ECS Component": {
+    "prefix": "fcomp",
+    "body": [
+      "import { createComponentId } from '../../new-ecs/ecs-component.js';",
+      "",
+      "/**",
+      " * ECS-style component interface for ${1:ComponentDescription}.",
+      " */",
+      "export interface ${2:ComponentName}EcsComponent {",
+      "  ${3:field}: ${4:type};",
+      "}",
+      "",
+      "export const ${2}Id = createComponentId<${2}EcsComponent>('${5:${2}}');",
+    ],
+    "description": "Create a new ECS component.",
+    "scope": "typescript",
+  },
+  "Forge: New ECS System": {
+    "prefix": "fsys",
+    "body": [
+      "import { EcsSystem } from '../../new-ecs/ecs-system.js';",
+      "",
+      "/**",
+      " * Creates an ECS system to handle ${1:description}.",
+      " */",
+      "export const create${2:systemName}EcsSystem = (): EcsSystem<[${3:CompA}]> => ({",
+      "  query: [${4:compAId}],",
+      "  run: (result) => {",
+      "    const [${5:compA}] = result.components;",
+      "    // TODO: implement system logic",
+      "  },",
+      "});",
+    ],
+    "description": "Create a new ECS system.",
+    "scope": "typescript",
+  },
+}

demo/src/animationDemo.ts

@@ -9,40 +9,47 @@ import {
   Axis2dAction,
   buttonMoments,
   createAnimation,
-  FlipComponent,
+  createResetInputsEcsSystem,
+  createSpriteAnimationEcsSystem,
+  createUpdateInputEcsSystem,
+  flipId,
   Game,
+  InputManager,
+  inputsId,
   KeyboardAxis1dBinding,
   KeyboardAxis2dBinding,
   KeyboardInputSource,
   KeyboardTriggerBinding,
   keyCodes,
   MouseAxis2dBinding,
   MouseInputSource,
-  PositionComponent,
-  registerInputs,
-  ScaleComponent,
+  positionId,
+  scaleId,
   Sprite,
-  SpriteAnimationComponent,
-  SpriteComponent,
+  spriteAnimationId,
+  spriteId,
   Time,
   TriggerAction,
   Vector2,
-  World,
 } from '../../src';
+import { EcsWorld } from '../../src/new-ecs';
 import { FiniteStateMachine } from '../../src/finite-state-machine/finite-state-machine';
 import { Transition } from '../../src/finite-state-machine/transition';
 import { ADVENTURER_ANIMATIONS, SHIP_ANIMATIONS } from './animationEnums';
-import { ControlAdventurerComponent } from './control-adventurer-component';
+import { controlAdventurerId } from './control-adventurer-component';
 
 export function setupAnimationsDemo(
-  world: World,
+  world: EcsWorld,
   game: Game,
   time: Time,
   shipSprite: Sprite,
   adventurerSprite: Sprite,
 ): ReturnType<typeof setupInputs> {
   const inputs = setupInputs(world, game, time);
 
+  // Add animation system
+  world.addSystem(createSpriteAnimationEcsSystem(time));
+
   const ShipController = createShipAnimationController();
   buildShipEntities(world, shipSprite, ShipController);
 
@@ -58,7 +65,7 @@ export function setupAnimationsDemo(
   return inputs;
 }
 
-function setupInputs(world: World, game: Game, time: Time) {
+function setupInputs(world: EcsWorld, game: Game, time: Time) {
   const gameInputGroup = 'game';
 
   const attackInput = new TriggerAction('attack', gameInputGroup);
@@ -78,22 +85,28 @@ function setupInputs(world: World, game: Game, time: Time) {
     actionResetTypes.noReset,
   );
 
-  const { inputsManager } = registerInputs(world, time, {
-    triggerActions: [
-      attackInput,
-      runRInput,
-      runLInput,
-      jumpInput,
-      takeDamageInput,
-    ],
-    axis2dActions: [axis2dInput],
-    axis1dActions: [axis1dInput],
-  });
+  // Create input manager and register actions
+  const inputsManager = new InputManager(gameInputGroup);
+  inputsManager.addTriggerActions(
+    attackInput,
+    runRInput,
+    runLInput,
+    jumpInput,
+    takeDamageInput,
+  );
+  inputsManager.addAxis2dActions(axis2dInput);
+  inputsManager.addAxis1dActions(axis1dInput);
+
+  // Create an entity with inputs component
+  const inputEntity = world.createEntity();
+  world.addComponent(inputEntity, inputsId, { inputManager: inputsManager });
 
-  inputsManager.setActiveGroup(gameInputGroup);
+  // Add input systems
+  world.addSystem(createUpdateInputEcsSystem(time));
+  world.addSystem(createResetInputsEcsSystem());
 
   const keyboardInputSource = new KeyboardInputSource(inputsManager);
-  const mouseInputSource = new MouseInputSource(inputsManager, game);
+  const mouseInputSource = new MouseInputSource(inputsManager, game.container);
 
   keyboardInputSource.axis2dBindings.add(
     new KeyboardAxis2dBinding(
@@ -234,32 +247,65 @@ function createAdventurerControllableInputs() {
 }
 
 function buildShipEntities(
-  world: World,
+  world: EcsWorld,
   shipSprite: Sprite,
   stateMachine: FiniteStateMachine<AnimationInputs, AnimationClip>,
 ) {
   const animationInputs = new AnimationInputs();
 
-  world.buildAndAddEntity([
-    new PositionComponent(-500, -150),
-    new SpriteComponent(shipSprite),
-    new ScaleComponent(0.5, 0.5),
-    new SpriteAnimationComponent(stateMachine, animationInputs),
-  ]);
+  const entity = world.createEntity();
+  world.addComponent(entity, positionId, {
+    local: new Vector2(-500, -150),
+    world: new Vector2(-500, -150),
+  });
+  world.addComponent(entity, spriteId, {
+    sprite: shipSprite,
+    enabled: true,
+  });
+  world.addComponent(entity, scaleId, {
+    local: new Vector2(0.5, 0.5),
+    world: new Vector2(0.5, 0.5),
+  });
+  world.addComponent(entity, spriteAnimationId, {
+    animationFrameIndex: 0,
+    playbackSpeed: 1,
+    frameDurationMilliseconds: 33.3333,
+    lastFrameChangeTimeInSeconds: 0,
+    animationInputs,
+    stateMachine,
+  });
 }
 
 function buildAdventurerControllableEntities(
-  world: World,
+  world: EcsWorld,
   adventurerSprite: Sprite,
   stateMachine: FiniteStateMachine<AnimationInputs, AnimationClip>,
   animationInputs: AnimationInputs,
 ) {
-  world.buildAndAddEntity([
-    new PositionComponent(400, 0),
-    new SpriteComponent(adventurerSprite),
-    new ScaleComponent(0.3, 0.6),
-    new SpriteAnimationComponent(stateMachine, animationInputs, 33.3333, 0.3),
-    new ControlAdventurerComponent(),
-    new FlipComponent(),
-  ]);
+  const entity = world.createEntity();
+  world.addComponent(entity, positionId, {
+    local: new Vector2(400, 0),
+    world: new Vector2(400, 0),
+  });
+  world.addComponent(entity, spriteId, {
+    sprite: adventurerSprite,
+    enabled: true,
+  });
+  world.addComponent(entity, scaleId, {
+    local: new Vector2(0.3, 0.6),
+    world: new Vector2(0.3, 0.6),
+  });
+  world.addComponent(entity, spriteAnimationId, {
+    animationFrameIndex: 0,
+    playbackSpeed: 0.3,
+    frameDurationMilliseconds: 33.3333,
+    lastFrameChangeTimeInSeconds: 0,
+    animationInputs,
+    stateMachine,
+  });
+  world.addTag(entity, controlAdventurerId);
+  world.addComponent(entity, flipId, {
+    flipX: false,
+    flipY: false,
+  });
 }

demo/src/control-adventurer-component.ts

@@ -1,3 +1,3 @@
-import { Component } from '../../src';
+import { createTagId } from '../../src/new-ecs/ecs-component';
 
-export class ControlAdventurerComponent extends Component {}
+export const controlAdventurerId = createTagId('control-adventurer');

demo/src/control-adventurer-system.ts

@@ -1,69 +1,47 @@
 import {
-  Entity,
-  FlipComponent,
-  PositionComponent,
-  SpriteAnimationComponent,
-  System,
+  FlipEcsComponent,
+  flipId,
+  PositionEcsComponent,
+  positionId,
+  SpriteAnimationEcsComponent,
+  spriteAnimationId,
   TriggerAction,
 } from '../../src';
-import { ControlAdventurerComponent } from './control-adventurer-component';
-
-export class ControlAdventurerSystem extends System {
-  private readonly _attackTriggerInput: TriggerAction;
-  private readonly _runRTriggerInput: TriggerAction;
-  private readonly _runLTriggerInput: TriggerAction;
-  private readonly _jumpTriggerInput: TriggerAction;
-  private readonly _takeDamageTriggerInput: TriggerAction;
-
-  constructor(
-    attackTriggerInput: TriggerAction,
-    runRTriggerInput: TriggerAction,
-    runLTriggerInput: TriggerAction,
-    jumpTriggerInput: TriggerAction,
-    takeDamageTriggerInput: TriggerAction,
-  ) {
-    super(
-      [
-        ControlAdventurerComponent,
-        SpriteAnimationComponent,
-        FlipComponent,
-        PositionComponent,
-      ],
-      'ControlAdventurerSystem',
-    );
-
-    this._attackTriggerInput = attackTriggerInput;
-    this._runRTriggerInput = runRTriggerInput;
-    this._runLTriggerInput = runLTriggerInput;
-    this._jumpTriggerInput = jumpTriggerInput;
-    this._takeDamageTriggerInput = takeDamageTriggerInput;
-  }
-
-  public run(entity: Entity): void {
-    const spriteAnimationComponent = entity.getComponentRequired(
-      SpriteAnimationComponent,
-    );
-
-    const flipComponent = entity.getComponentRequired(FlipComponent);
+import { EcsSystem } from '../../src/new-ecs';
+import { controlAdventurerId } from './control-adventurer-component';
+
+export const createControlAdventurerEcsSystem = (
+  attackTriggerInput: TriggerAction,
+  runRTriggerInput: TriggerAction,
+  runLTriggerInput: TriggerAction,
+  jumpTriggerInput: TriggerAction,
+  takeDamageTriggerInput: TriggerAction,
+): EcsSystem<
+  [SpriteAnimationEcsComponent, FlipEcsComponent, PositionEcsComponent]
+> => ({
+  query: [spriteAnimationId, flipId, positionId],
+  tags: [controlAdventurerId],
+  run: (result) => {
+    const [spriteAnimationComponent, flipComponent] = result.components;
 
     const animationInputs = spriteAnimationComponent.animationInputs;
 
-    if (this._jumpTriggerInput.isTriggered) {
+    if (jumpTriggerInput.isTriggered) {
       console.log('Jumping!');
 
       animationInputs.setTrigger('jump');
 
       return;
     }
 
-    if (this._runLTriggerInput.isTriggered) {
+    if (runLTriggerInput.isTriggered) {
       animationInputs.setToggle('run', true);
       flipComponent.flipX = true;
 
       return;
     }
 
-    if (this._runRTriggerInput.isTriggered) {
+    if (runRTriggerInput.isTriggered) {
       animationInputs.setToggle('run', true);
       flipComponent.flipX = false;
 
@@ -72,13 +50,13 @@ export class ControlAdventurerSystem extends System {
 
     animationInputs.setToggle('run', false);
 
-    if (this._attackTriggerInput.isTriggered) {
+    if (attackTriggerInput.isTriggered) {
       animationInputs.setText('attack', 'attack is being set');
 
       return;
     }
 
-    if (this._takeDamageTriggerInput.isTriggered) {
+    if (takeDamageTriggerInput.isTriggered) {
       const health = animationInputs.getNumber('health');
 
       if (!health) {
@@ -87,5 +65,5 @@ export class ControlAdventurerSystem extends System {
 
       health.value = Math.max(0, health.value - 50);
     }
-  }
-}
+  },
+});