Add control via keyboard (#6)

* Correct angle documentation

* Correct body component doc

* Add a config module with px 2 meters

* Create component to map input

* Add components for mappable actions

* Add component for elastic manipulation

* Add node to modify physics

* Add controllable node

* Add dasher node

* Add control mapper system

* Add component to limit velocity

* Add node for limiting velocity

* Add systems to move and dash

* Use meters in physics systems

* Correct documentation in render system

* Add elastic manipulation system

* Update factories to use new components

* Update main app to use new systems

* Ignore dist dir

* Also ignore cache

* Ignore personal configuration files

* Add system to reduce velocity

* Add changelog

1 files changed, 118 insertions, 0 deletions

diff --git a/lib/systems/control_mapper.js b/lib/systems/control_mapper.js
new file mode 100644
index 0000000..e91ecc6
--- /dev/null
+++ b/lib/systems/control_mapper.js
@@ -0,0 +1,118 @@
+import { System } from '@serpentity/serpentity';
+
+import ControllableNode from '../nodes/controllable';
+
+/* global window */
+
+const internals = {
+  keyboardState: {
+  }
+};
+
+/**
+ * Updates control status based on the controller map
+ *
+ * @extends {external:Serpentity.System}
+ * @class ControlMapperSystem
+ * @param {object} config a configuration object to extend.
+ */
+export default class ControlMapperSystem extends System {
+
+  constructor(config = {}) {
+
+    super();
+
+    /**
+     * The node collection of controllable entities
+     *
+     * @property {external:Serpentity.NodeCollection} controllables
+     * @instance
+     * @memberof RenderSystem
+     */
+    this.controllables = null;
+
+    this._initializeKeyboard();
+  }
+
+  /**
+   * Initializes system when added. Requests controllable nodes.
+   *
+   * @function added
+   * @memberof RenderSystem
+   * @instance
+   * @param {external:Serpentity.Engine} engine the serpentity engine to
+   * which we are getting added
+   */
+  added(engine) {
+
+    this.controllables = engine.getNodes(ControllableNode);
+  }
+
+  /**
+   * Clears system resources when removed.
+   *
+   * @function removed
+   * @instance
+   * @memberof RenderSystem
+   */
+  removed() {
+
+    this.controllables = null;
+  }
+
+  /**
+   * Runs on every update of the loop. Maps the actions given the current state of the inputs
+   *
+   * @function update
+   * @instance
+   * @param {Number} currentFrameDuration the duration of the current
+   * frame
+   * @memberof RenderSystem
+   */
+  update(currentFrameDuration) {
+
+    for (const controllable of this.controllables) {
+      for (const map of controllable.controlMap.map) {
+        if (map.source.type === 'keyboard') {
+          this._setValue(controllable.entity, map.target, !!internals.keyboardState[map.source.index]);
+        }
+      }
+    }
+  }
+
+  // Listens to keyboard to update internal map
+
+  _initializeKeyboard() {
+
+    window.addEventListener('keydown', (event) => {
+
+      internals.keyboardState[event.keyCode] = true;
+    });
+
+    window.addEventListener('keyup', (event) => {
+
+      internals.keyboardState[event.keyCode] = false;
+    });
+  }
+
+  // Sets the value to a target
+
+  _setValue(entity, target, value) {
+
+    const component = entity.getComponent(target.component);
+
+    if (component) {
+      const keyFragments = target.property.split('.');
+      let currentObject = component;
+      for (const keyFragment of keyFragments.slice(0, keyFragments.length - 1)) {
+        currentObject = currentObject[keyFragment] = currentObject[keyFragment] || {};
+      }
+
+
+      const finalValue = !!target.value ? target.value(value) : value;
+      const finalProperty = keyFragments.pop();
+      currentObject[finalProperty] += finalValue;
+    }
+  }
+};
+