@caperjs/core 0.1.0

package/src/plugins/input/interfaces.ts

@@ -0,0 +1,37 @@
+import { ActionContext, ActionMap, UserActions, UserButtons } from '../actions';
+import { IKeyboardControlScheme, KeyboardControls } from './keyboard';
+import { ITouchControlScheme, TouchControls } from './touch';
+import { AbstractControlScheme, ControlsActionMap, KeyboardControlsMap, TouchControlsMap } from './types';
+
+export interface ControlsAction {
+  context: ActionContext[] | '*' | (string & {});
+  input: string | string[];
+}
+
+export interface IGamepadControlScheme extends AbstractControlScheme<'buttonDown' | 'buttonUp' | 'axis'> {
+  buttonDown?: ControlsActionMap;
+  buttonUp?: ControlsActionMap;
+  axis?: ControlsActionMap;
+}
+
+export interface ControlScheme {
+  keyboard?: IKeyboardControlScheme;
+  touch?: ITouchControlScheme;
+  gamepad?: IGamepadControlScheme;
+}
+
+export interface IControls {
+  readonly keyboard: KeyboardControls;
+  readonly touch: TouchControls;
+
+  isActionActive(action: string): boolean;
+
+  initialize(scheme: UserControls, actions: ActionMap): void;
+
+  destroy(): void;
+}
+
+export interface UserControls<U extends UserActions = UserActions, B extends UserButtons = UserButtons> {
+  keyboard: Partial<KeyboardControlsMap<U>>;
+  touch: Partial<TouchControlsMap<U, B>>;
+}

package/src/plugins/input/keyboard/KeyboardContols.ts

@@ -0,0 +1,182 @@
+import { Application } from '../../../core/Application';
+import { WithSignals } from '../../../mixins';
+import { bindAllMethods } from '../../../utils';
+import type { Action } from '../../actions';
+import { normalizeKey, type KeyboardEventDetail } from '../../KeyboardPlugin';
+import { AbstractControls } from '../AbstractControls';
+import type { ControlsActionMap, KeyboardControlsMap, KeyboardControlsScheme } from '../types';
+
+export class KeyboardControls extends WithSignals(AbstractControls) {
+  protected scheme: Partial<KeyboardControlsMap>;
+  private _keyDownMap: Partial<KeyboardControlsScheme>;
+  private _keyUpMap: Partial<KeyboardControlsScheme>;
+  private _keyCombinations: string[][] = [];
+  private _singleDownKeys: Set<string> = new Set();
+  private _keyCombinationsMap: Map<string[], Action> = new Map();
+  private _activeDownKeys: Map<string, Action> = new Map();
+  private _activeUpKeys: Map<string, Action> = new Map();
+
+  constructor() {
+    super();
+    bindAllMethods(this);
+  }
+
+  get app() {
+    return Application.getInstance();
+  }
+
+  isActionActive(action: Action): boolean {
+    const controlsAction = this.scheme['down']?.[action] ?? null;
+    if (!controlsAction) {
+      return false;
+    }
+    if (Array.isArray(controlsAction)) {
+      return (
+        this._keyCombinationsMap.has(controlsAction) || controlsAction.some((key) => this._singleDownKeys.has(key))
+      );
+    } else {
+      return this._singleDownKeys.has(controlsAction);
+    }
+  }
+
+  public initialize(scheme: Partial<KeyboardControlsMap>): void {
+    super.initialize(scheme as Partial<ControlsActionMap>);
+    this._keyDownMap = scheme.down || {};
+    this._keyUpMap = scheme.up || {};
+    this._sortActions();
+  }
+
+  public connect() {
+    this.addSignalConnection(
+      this.app.signal.onActionContextChanged.connect(this._handleContextChanged),
+      this.app.keyboard.onKeyDown().connect(this._handleKeyDown),
+      this.app.keyboard.onKeyUp().connect(this._handleKeyUp),
+    );
+
+    this._handleContextChanged();
+    this.app.ticker.add(this._update);
+  }
+
+  private _sortActions() {
+    const actions = this.app.actionsPlugin.getActions();
+    this._keyCombinations = [];
+    this._keyCombinationsMap.clear();
+    this._activeDownKeys.clear();
+    this._activeUpKeys.clear();
+    let keys = Object.keys(this._keyDownMap);
+
+    keys.forEach((key) => {
+      const item = this._keyDownMap[key];
+      const action = actions[key];
+      if (
+        action.context !== '*' &&
+        action.context !== this.app.actionContext &&
+        !action.context.includes(this.app.actionContext)
+      ) {
+        return;
+      }
+      let input = item;
+      if (input) {
+        if (!Array.isArray(input)) {
+          input = [input];
+        }
+        input.forEach((inputString: string) => {
+          if (inputString.includes('+')) {
+            const combo = inputString.split('+');
+            this._keyCombinations.push(combo);
+            this._keyCombinationsMap.set(combo, key as Action);
+          } else {
+            this._activeDownKeys.set(inputString, key as Action);
+          }
+        });
+      }
+    });
+
+    // sort them from the largest to smallest
+    this._keyCombinations.sort((a, b) => b.length - a.length);
+
+    keys = Object.keys(this._keyUpMap);
+    keys.forEach((key) => {
+      const item = this._keyUpMap[key];
+      let input = item;
+      if (input) {
+        if (!Array.isArray(input)) {
+          input = [input];
+        }
+        input.forEach((inputString: string) => {
+          this._activeUpKeys.set(inputString, key as Action);
+        });
+      }
+    });
+
+    //Logger.log('keyDownMap', this._keyDownMap, 'activeDownKeys', this._activeDownKeys);
+    //Logger.log('keyUpMap', this._keyUpMap, 'activeUpKeys', this._activeUpKeys);
+  }
+
+  private _handleContextChanged() {
+    this._getPossibleActions();
+  }
+
+  private _getPossibleActions() {
+    this._sortActions();
+  }
+
+  private _handleKeyDown(detail: KeyboardEventDetail): void {
+    const key = normalizeKey(detail.event.key);
+    this._singleDownKeys.add(key);
+  }
+
+  private _handleKeyUp(detail: KeyboardEventDetail): void {
+    const key = normalizeKey(detail.event.key);
+    this._singleDownKeys.delete(key);
+
+    const action = this._activeUpKeys.get(key);
+    if (action) {
+      this.app.action(action, { combination: false, inputState: 'up', key });
+    }
+  }
+
+  private _update() {
+    if (!this.app.keyboard) {
+      return;
+    }
+    const keysDown = this.app.keyboard.keysDown;
+    if (keysDown.size === 0) {
+      return;
+    }
+    const eliminated = new Set<string>();
+    // this._keyCombinations is already sorted from largest to smallest
+    for (let i = 0; i < this._keyCombinations.length; i++) {
+      const combination = this._keyCombinations[i];
+      // check if all of the keys in the combination are down
+      if (combination.some((key) => eliminated.has(key))) {
+        continue;
+      }
+      if (combination.every((key) => keysDown.has(key))) {
+        combination.forEach((key) => eliminated.add(key));
+        // send the action
+        const action = this._keyCombinationsMap.get(combination);
+        if (action) {
+          this.app.action(action, {
+            key: combination,
+            combination: true,
+            inputState: 'down',
+          });
+        }
+      }
+    }
+
+    // order doesn't matter here
+    this._singleDownKeys.forEach((key) => {
+      if (eliminated.has(key)) {
+        return;
+      }
+      if (keysDown.has(key)) {
+        const action = this._activeDownKeys.get(key);
+        if (action) {
+          this.app.action(action, { key, combination: false, inputState: 'down' });
+        }
+      }
+    });
+  }
+}

package/src/plugins/input/keyboard/index.ts

@@ -0,0 +1,2 @@
+export * from './interfaces';
+export * from './KeyboardContols';

package/src/plugins/input/keyboard/interfaces.ts

@@ -0,0 +1,21 @@
+import { KeyboardKey } from '../../../utils';
+import { Action, ActionContext } from '../../actions';
+import { AbstractControlScheme, ControlsActionMap } from '../types';
+
+// Define a type for single keyboard input
+type KeyboardInput = (string & {}) | KeyboardKey | `${KeyboardKey}+${KeyboardKey}` | `${KeyboardKey}*`;
+
+export interface KeyboardControlsAction {
+  context: ActionContext[] | '*';
+  input: KeyboardInput | KeyboardInput[];
+}
+
+export type KeyboardControlsActionMap = {
+  [actionName: Action | string]: KeyboardControlsAction;
+};
+
+export interface IKeyboardControlScheme extends AbstractControlScheme<'down' | 'up'> {
+  down?: KeyboardControlsActionMap;
+  up?: KeyboardControlsActionMap;
+  [key: string]: ControlsActionMap | undefined;
+}

package/src/plugins/input/methods.ts

@@ -0,0 +1,9 @@
+import { UserActions, UserButtons } from '../actions';
+import { UserControls } from './interfaces';
+export function defineControls<U extends UserActions = UserActions, B extends UserButtons = UserButtons>(
+  actions: U,
+  buttons: B,
+  controls?: UserControls<U, B>,
+): UserControls<U, B> {
+  return controls || ([] as unknown as UserControls<U, B>);
+}

package/src/plugins/input/touch/TouchControls.ts

@@ -0,0 +1,237 @@
+import { bindAllMethods } from '../../../utils';
+import type { ControlsActionMap, JoystickControlsScheme, TouchControlsMap, TouchControlsScheme } from '../types';
+
+import { JoystickDirection } from '..';
+import { Application } from '../../../core/Application';
+import { WithSignals } from '../../../mixins';
+import { type IButton, type IJoystick } from '../../../ui';
+import type { Action } from '../../actions';
+import { AbstractControls } from '../AbstractControls';
+
+export class TouchControls extends WithSignals(AbstractControls) {
+  protected scheme: Partial<TouchControlsMap>;
+  private _buttons: Set<IButton> = new Set();
+  private _joystickMap: Partial<JoystickControlsScheme>;
+  private _buttonDownMap: Partial<TouchControlsScheme>;
+  private _buttonUpMap: Partial<TouchControlsScheme>;
+  private _combinations: string[][] = [];
+  private _singleDownButtons: Set<string> = new Set();
+  private _activeJoystickDirections: Map<JoystickDirection, Action> = new Map();
+  private _activeButtonDownIds: Map<string, Action> = new Map();
+  private _activeButtonUpIds: Map<string, Action> = new Map();
+  private _combinationsMap: Map<string[], Action> = new Map();
+
+  constructor() {
+    super();
+    bindAllMethods(this);
+  }
+
+  private _joystick: IJoystick;
+
+  get joystick(): IJoystick {
+    return this._joystick;
+  }
+
+  set joystick(value: IJoystick) {
+    this._joystick = value;
+  }
+
+  get app() {
+    return Application.getInstance();
+  }
+
+  addButton(button: IButton) {
+    if (!button || this._buttons.has(button)) {
+      return;
+    }
+    this.addSignalConnection(
+      button.onDown.connect(() => this._handleButtonDown(button)),
+      button.onUp.connect(() => this._handleButtonUp(button)),
+      button.onUpOutside.connect(() => this._handleButtonUp(button)),
+      button.onDestroy.connect(() => this.removeButton(button)),
+    );
+    this._buttons.add(button);
+  }
+
+  removeButton(button: IButton) {
+    if (!button || !this._buttons.has(button)) {
+      return;
+    }
+    button.onDown.disconnect(() => this._handleButtonDown(button));
+    button.onUp.disconnect(() => this._handleButtonUp(button));
+    button.onUpOutside.disconnect(() => this._handleButtonUp(button));
+    button.onDestroy.disconnect(() => this.removeButton(button));
+    this._buttons.delete(button);
+  }
+
+  public initialize(scheme: Partial<TouchControlsMap>): void {
+    super.initialize(scheme as Partial<ControlsActionMap>);
+    this._buttonDownMap = scheme.down || {};
+    this._buttonUpMap = scheme.up || {};
+    this._joystickMap = scheme.joystick || {};
+    this.app.signal.onActionContextChanged.connect(this._sortActions);
+    this._sortActions();
+  }
+
+  public connect() {
+    this.app.ticker.add(this._update);
+  }
+
+  isActionActive(action: Action): boolean {
+    const buttonAction = this.scheme['down']?.[action] ?? null;
+    if (buttonAction) {
+      if (Array.isArray(buttonAction)) {
+        return this._combinationsMap.has(buttonAction);
+      } else {
+        return this._singleDownButtons.has(buttonAction);
+      }
+    } else {
+      const joystickAction = this.scheme['joystick']?.[action] ?? null;
+      if (this._joystick && joystickAction) {
+        if (Array.isArray(joystickAction)) {
+          return joystickAction.includes(this._joystick.direction);
+        } else {
+          return joystickAction === this._joystick?.direction;
+        }
+      }
+    }
+    return false;
+  }
+
+  private _sortActions() {
+    const actions = this.app.actionsPlugin.getActions();
+    this._combinations = [];
+    this._combinationsMap.clear();
+    this._activeJoystickDirections.clear();
+    this._activeButtonDownIds.clear();
+    this._activeButtonUpIds.clear();
+
+    let buttons = Object.keys(this._buttonDownMap);
+    buttons.forEach((key) => {
+      const item = this._buttonDownMap[key];
+      const action = actions[key];
+      if (
+        action.context !== '*' &&
+        action.context !== this.app.actionContext &&
+        !action.context.includes(this.app.actionContext)
+      ) {
+        return;
+      }
+      let input = item;
+      if (input) {
+        if (!Array.isArray(input)) {
+          input = [input];
+        }
+        input.forEach((inputString) => {
+          if (inputString.includes('+')) {
+            const combo = inputString.split('+');
+            this._combinations.push(combo);
+            this._combinationsMap.set(combo, key as Action);
+          } else {
+            this._activeButtonDownIds.set(inputString, key as Action);
+          }
+        });
+      }
+    });
+
+    // sort them from the largest to smallest
+    this._combinations.sort((a, b) => b.length - a.length);
+
+    buttons = Object.keys(this._buttonUpMap);
+    buttons.forEach((key) => {
+      const item = this._buttonUpMap[key];
+      const action = actions[key];
+      if (
+        action.context !== '*' &&
+        action.context !== this.app.actionContext &&
+        !action.context.includes(this.app.actionContext)
+      ) {
+        return;
+      }
+      this._activeButtonUpIds.set(item as string, key as Action);
+    });
+
+    const joystickActions = Object.keys(this._joystickMap);
+    joystickActions.forEach((key) => {
+      const item = this._joystickMap[key];
+      let input = item;
+      if (input) {
+        if (!Array.isArray(input)) {
+          input = [input];
+        }
+        input.forEach((inputString) => {
+          this._activeJoystickDirections.set(inputString as JoystickDirection, key as Action);
+        });
+      }
+    });
+  }
+
+  private _handleButtonDown(button: IButton): void {
+    this._singleDownButtons.add(button.id!);
+  }
+
+  private _handleButtonUp(button: IButton): void {
+    this._singleDownButtons.delete(button.id!);
+    const action = this._activeButtonUpIds.get(button.id!);
+    if (action) {
+      this.app.action(action, {
+        combination: false,
+        inputState: 'up',
+        button: button.id!,
+      });
+    }
+  }
+
+  private _update() {
+    const joystickDirection = this._joystick?.direction ?? null;
+    const buttonsDown = this._singleDownButtons;
+    const eliminated = new Set<string>();
+    // this._combinations is already sorted from largest to smallest
+    for (let i = 0; i < this._combinations.length; i++) {
+      const combination = this._combinations[i];
+      // check if all of the keys in the combination are down
+      if (combination.some((key) => eliminated.has(key))) {
+        continue;
+      }
+      if (combination.every((key) => buttonsDown.has(key) || joystickDirection === key)) {
+        combination.forEach((key) => eliminated.add(key));
+        // send the action
+        const action = this._combinationsMap.get(combination);
+        if (action) {
+          this.app.action(action, {
+            button: combination,
+            combination: true,
+            inputState: 'down',
+          });
+        }
+      }
+    }
+
+    // order doesn't matter here
+    this._singleDownButtons.forEach((id) => {
+      if (eliminated.has(id)) {
+        return;
+      }
+      if (buttonsDown.has(id)) {
+        const action = this._activeButtonDownIds.get(id);
+        if (action) {
+          this.app.action(action, {
+            button: id,
+            combination: false,
+            inputState: 'down',
+          });
+        }
+      }
+    });
+
+    // joustick dir
+    if (joystickDirection) {
+      const action = this._activeJoystickDirections.get(joystickDirection);
+      if (action) {
+        this.app.action(action, {
+          inputState: 'joystick',
+        });
+      }
+    }
+  }
+}

package/src/plugins/input/touch/constants.ts

@@ -0,0 +1,34 @@
+export enum JoystickDirection {
+  None = 'none',
+  Left = 'left',
+  Top = 'top',
+  Bottom = 'bottom',
+  Right = 'right',
+  TopLeft = 'top_left',
+  TopRight = 'top_right',
+  BottomLeft = 'bottom_left',
+  BottomRight = 'bottom_right',
+}
+export type JoystickDirectionType =
+  | JoystickDirection.None
+  | JoystickDirection.Left
+  | JoystickDirection.Top
+  | JoystickDirection.Bottom
+  | JoystickDirection.Right
+  | JoystickDirection.TopLeft
+  | JoystickDirection.TopRight
+  | JoystickDirection.BottomLeft
+  | JoystickDirection.BottomRight;
+
+// export a type of all the JoystickDirections
+export const JOYSTICK_DIRECTIONS: JoystickDirectionType[] = [
+  JoystickDirection.None,
+  JoystickDirection.Left,
+  JoystickDirection.Top,
+  JoystickDirection.Bottom,
+  JoystickDirection.Right,
+  JoystickDirection.TopLeft,
+  JoystickDirection.TopRight,
+  JoystickDirection.BottomLeft,
+  JoystickDirection.BottomRight,
+];

package/src/plugins/input/touch/index.ts

@@ -0,0 +1,3 @@
+export * from './constants';
+export * from './interfaces';
+export * from './TouchControls';

package/src/plugins/input/touch/interfaces.ts

@@ -0,0 +1,15 @@
+import { type ActionContext } from '../../actions';
+import { type AbstractControlScheme } from '../types';
+import { JoystickDirection } from './constants';
+
+type JoystickCombination = `${JoystickDirection}+${JoystickDirection}`;
+type JoystickHold = `${JoystickDirection}*`;
+export type JoystickInput = (string & {}) | JoystickDirection | JoystickCombination | JoystickHold;
+
+export interface TouchControlsAction {
+  context: ActionContext[] | '*';
+  input: JoystickInput | JoystickInput[];
+  [key: string]: JoystickInput | JoystickInput[] | undefined;
+}
+
+export interface ITouchControlScheme extends AbstractControlScheme<'down' | 'up' | 'joystick'> {}

package/src/plugins/input/types.ts

@@ -0,0 +1,41 @@
+import { JoystickInput } from '../..';
+import { KeyboardKey } from '../../utils';
+import { Action, ExtractButtonId, UserActions, UserButtons } from '../actions';
+import { ControlsAction } from './interfaces';
+
+export type KeyboardSchemaKey = KeyboardKey;
+export type ControlsActionMap = {
+  [actionName: Action | string]: ControlsAction;
+};
+
+export type AbstractControlScheme<T extends string = string> = {
+  [name in T]?: ControlsActionMap;
+};
+
+type KeyCombination = `${KeyboardSchemaKey}+${KeyboardSchemaKey}`;
+
+export type KeyboardControlsScheme<U extends UserActions = UserActions> = {
+  [key in keyof U]: KeyboardSchemaKey | KeyCombination | (KeyboardSchemaKey | KeyCombination)[];
+};
+
+export type KeyboardControlsMap<U extends UserActions = UserActions> = {
+  down?: Partial<KeyboardControlsScheme<U>>;
+  up?: Partial<KeyboardControlsScheme<U>>;
+};
+
+export type TouchControlsScheme<U extends UserActions = UserActions, B extends UserButtons = UserButtons> = {
+  [key in keyof U]:
+    | ExtractButtonId<B>
+    | `${ExtractButtonId<B>}+${ExtractButtonId<B>}`
+    | (ExtractButtonId<B> | `${ExtractButtonId<B>}+${ExtractButtonId<B>}`)[];
+};
+
+export type JoystickControlsScheme<U extends UserActions = UserActions> = {
+  [key in keyof U]: JoystickInput | JoystickInput[];
+};
+
+export type TouchControlsMap<U extends UserActions = UserActions, B extends UserButtons = UserButtons> = {
+  joystick?: Partial<JoystickControlsScheme<U>>;
+  up?: Partial<TouchControlsScheme<U, B>>;
+  down?: Partial<TouchControlsScheme<U, B>>;
+};

package/src/plugins/input/utils.ts

@@ -0,0 +1,10 @@
+export interface ControlsStructure {
+  keyboard?: {
+    down?: Record<string, { context: string[] | '*'; input: string | string[] }>;
+    up?: Record<string, { context: string[] | '*'; input: string | string[] }>;
+  };
+  touch?: {
+    down?: Record<string, { context: string[] | '*'; input: string }>;
+    joystick?: Record<string, { context: string[] | '*'; input: string[] }>;
+  };
+}

package/src/plugins/spine/SpinePlugin.ts

@@ -0,0 +1,14 @@
+import { extensions } from 'pixi.js';
+import { Plugin } from '../Plugin';
+import { Spine, spineLoaderExtension, SpinePipe, spineTextureAtlasLoader } from './pixi-spine';
+
+export class SpinePlugin extends Plugin {
+  public readonly id = 'SpinePlugin';
+
+  public async initialize() {
+    extensions.add(spineTextureAtlasLoader);
+    extensions.add(spineLoaderExtension);
+    extensions.add(SpinePipe);
+    (window as any).Spine = Spine;
+  }
+}