@polygonjs/polygonjs/dist/src/engine/functions/_SetPlayerInput.js

node-based WebGL 3D engine https://polygonjs.com

"use strict";
import { ref } from "../../core/reactivity/CoreReactivity";
import { ObjectNamedFunction0, ObjectNamedFunction1 } from "./_Base";
function _createInputData() {
  return {
    forward: ref(false),
    backward: ref(false),
    left: ref(false),
    right: ref(false),
    run: ref(false),
    jump: ref(false)
  };
}
class InputDataHandler {
  constructor() {
    this._playerInputData = _createInputData();
    this._callbackByEventType = {
      keydown: (code) => this._onKeydownCallback(code),
      keyup: (code) => this._onKeyupCallback(code)
    };
    this._onEvent = {
      start: {
        forward: this._onForwardStart.bind(this),
        backward: this._onBackwardStart.bind(this),
        left: this._onLeftStart.bind(this),
        right: this._onRightStart.bind(this),
        jump: this._onJumpStart.bind(this),
        run: this._onRunStart.bind(this)
      },
      end: {
        forward: this._onForwardEnd.bind(this),
        backward: this._onBackwardEnd.bind(this),
        left: this._onLeftEnd.bind(this),
        right: this._onRightEnd.bind(this),
        jump: this._onJumpEnd.bind(this),
        run: this._onRunEnd.bind(this)
      }
    };
    this._eventByArrowKeyOnKeydown = {
      ArrowUp: this._onEvent.start.forward,
      ArrowDown: this._onEvent.start.backward,
      ArrowLeft: this._onEvent.start.left,
      ArrowRight: this._onEvent.start.right
    };
    this._eventByWASNKeyOnKeydown = {
      KeyW: this._onEvent.start.forward,
      KeyS: this._onEvent.start.backward,
      KeyA: this._onEvent.start.left,
      KeyD: this._onEvent.start.right
    };
    this._eventByArrowKeyOnKeyup = {
      ArrowUp: this._onEvent.end.forward,
      ArrowDown: this._onEvent.end.backward,
      ArrowLeft: this._onEvent.end.left,
      ArrowRight: this._onEvent.end.right
    };
    this._eventByWASNKeyOnKeyup = {
      KeyW: this._onEvent.end.forward,
      KeyS: this._onEvent.end.backward,
      KeyA: this._onEvent.end.left,
      KeyD: this._onEvent.end.right
    };
    this._runJumpEventByKeyOnkeydown = {
      ShiftLeft: this._onEvent.start.run,
      ShiftRight: this._onEvent.start.run,
      Space: this._onEvent.start.jump
    };
    this._runJumpEventByKeyOnkeyup = {
      ShiftLeft: this._onEvent.end.run,
      ShiftRight: this._onEvent.end.run,
      Space: this._onEvent.end.jump
    };
  }
  // public useWASDkeys = true;
  // public useArrowkeys = true;
  callback(eventType) {
    return this._callbackByEventType[eventType];
  }
  _onKeydownCallback(keyCode) {
    const jumpRunKeyCallback = this._runJumpEventByKeyOnkeydown[keyCode];
    if (jumpRunKeyCallback) {
      return jumpRunKeyCallback;
    }
    const wasdKeyCallback = this._eventByWASNKeyOnKeydown[keyCode];
    if (wasdKeyCallback) {
      return wasdKeyCallback;
    }
    const arrowKeyCallback = this._eventByArrowKeyOnKeydown[keyCode];
    if (arrowKeyCallback) {
      return arrowKeyCallback;
    }
  }
  _onKeyupCallback(keyCode) {
    const jumpRunKeyCallback = this._runJumpEventByKeyOnkeyup[keyCode];
    if (jumpRunKeyCallback) {
      return jumpRunKeyCallback;
    }
    const wasdKeyCallback = this._eventByWASNKeyOnKeyup[keyCode];
    if (wasdKeyCallback) {
      return wasdKeyCallback;
    }
    const arrowKeyCallback = this._eventByArrowKeyOnKeyup[keyCode];
    if (arrowKeyCallback) {
      return arrowKeyCallback;
    }
  }
  _onForwardStart() {
    this._playerInputData.forward.value = true;
  }
  _onBackwardStart() {
    this._playerInputData.backward.value = true;
  }
  _onLeftStart() {
    this._playerInputData.left.value = true;
  }
  _onRightStart() {
    this._playerInputData.right.value = true;
  }
  _onJumpStart() {
    this._playerInputData.jump.value = true;
  }
  _onRunStart() {
    this._playerInputData.run.value = true;
  }
  _onForwardEnd() {
    this._playerInputData.forward.value = false;
  }
  _onBackwardEnd() {
    this._playerInputData.backward.value = false;
  }
  _onLeftEnd() {
    this._playerInputData.left.value = false;
  }
  _onRightEnd() {
    this._playerInputData.right.value = false;
  }
  _onJumpEnd() {
    this._playerInputData.jump.value = false;
  }
  _onRunEnd() {
    this._playerInputData.run.value = false;
  }
}
const _inputDataByObject3D = /* @__PURE__ */ new WeakMap();
function _findOrCreateHandler(object3D) {
  let inputData = _inputDataByObject3D.get(object3D);
  if (inputData) {
    return inputData;
  }
  inputData = new InputDataHandler();
  _inputDataByObject3D.set(object3D, inputData);
  return inputData;
}
export class setPlayerInput extends ObjectNamedFunction1 {
  static type() {
    return "setPlayerInput";
  }
  func(object3D, stopEventsPropagation) {
    const events = this.scene.eventsDispatcher.keyboardEventsController.currentEvents();
    if (events.length == 0) {
      return;
    }
    const handler = _findOrCreateHandler(object3D);
    for (let event of events) {
      if (event.ctrlKey) {
        return;
      }
      const callbackMethod = handler.callback(event.type);
      if (!callbackMethod) {
        return;
      }
      const callback = callbackMethod(event.code);
      if (callback) {
        callback();
        if (stopEventsPropagation == true) {
          event.stopImmediatePropagation();
          event.stopPropagation();
          event.preventDefault();
        }
      }
    }
  }
}
export class getPlayerInputDataLeft extends ObjectNamedFunction0 {
  static type() {
    return "getPlayerInputDataLeft";
  }
  func(object3D) {
    return _findOrCreateHandler(object3D)._playerInputData.left.value;
  }
}
export class getPlayerInputDataRight extends ObjectNamedFunction0 {
  static type() {
    return "getPlayerInputDataRight";
  }
  func(object3D) {
    return _findOrCreateHandler(object3D)._playerInputData.right.value;
  }
}
export class getPlayerInputDataForward extends ObjectNamedFunction0 {
  static type() {
    return "getPlayerInputDataForward";
  }
  func(object3D) {
    return _findOrCreateHandler(object3D)._playerInputData.forward.value;
  }
}
export class getPlayerInputDataBackward extends ObjectNamedFunction0 {
  static type() {
    return "getPlayerInputDataBackward";
  }
  func(object3D) {
    return _findOrCreateHandler(object3D)._playerInputData.backward.value;
  }
}
export class getPlayerInputDataRun extends ObjectNamedFunction0 {
  static type() {
    return "getPlayerInputDataRun";
  }
  func(object3D) {
    return _findOrCreateHandler(object3D)._playerInputData.run.value;
  }
}
export class getPlayerInputDataJump extends ObjectNamedFunction0 {
  static type() {
    return "getPlayerInputDataJump";
  }
  func(object3D) {
    return _findOrCreateHandler(object3D)._playerInputData.jump.value;
  }
}