Finished off the Keyboard Manager, tided up the classes and removed un-needed functions.

Author: photonstorm

v3/src/checksum.js

@@ -1,4 +1,4 @@
 var CHECKSUM = {
-build: '7940ae30-f782-11e6-8cec-3b8d56169a63'
+build: '79e0cfa0-f84f-11e6-aabb-e9b6cbc3e561'
 };
 module.exports = CHECKSUM;

v3/src/input/keyboard/KeyboardManager.js

@@ -1,10 +1,24 @@
 var EventDispatcher = require('../../events/EventDispatcher');
 var Event = require('./events');
-var KeyCodes = require('./KeyCodes');
-var Key = require('./Key');
-var ProcessKeyDown = require('./ops/ProcessKeyDown');
-var ProcessKeyUp = require('./ops/ProcessKeyUp');
-
+var KeyCodes = require('./keys/KeyCodes');
+var Key = require('./keys/Key');
+var ProcessKeyDown = require('./keys/ProcessKeyDown');
+var ProcessKeyUp = require('./keys/ProcessKeyUp');
+
+/**
+* The Keyboard class monitors keyboard input and dispatches keyboard events.
+*
+* _Note_: many keyboards are unable to process certain combinations of keys due to hardware limitations known as ghosting.
+* See http://www.html5gamedevs.com/topic/4876-impossible-to-use-more-than-2-keyboard-input-buttons-at-the-same-time/ for more details.
+*
+* Also please be aware that certain browser extensions can disable or override Phaser keyboard handling.
+* For example the Chrome extension vimium is known to disable Phaser from using the D key. And there are others.
+* So please check your extensions before opening Phaser issues.
+*
+* @class Phaser.Keyboard
+* @constructor
+* @param {Phaser.Game} game - A reference to the currently running game.
+*/
 var KeyboardManager = function (inputManager)
 {
     this.manager = inputManager;
@@ -74,6 +88,47 @@ KeyboardManager.prototype = {
         this.target.removeEventListener('keyup', this.keyHandler);
     },
 
+    /**
+    * Creates and returns an object containing 4 hotkeys for Up, Down, Left and Right.
+    *
+    * @method Phaser.Keyboard#createCursorKeys
+    * @return {object} An object containing properties: `up`, `down`, `left` and `right` of {@link Phaser.Key} objects.
+    */
+    createCursorKeys: function ()
+    {
+        return this.addKeys({
+            up: KeyCodes.UP,
+            down: KeyCodes.DOWN,
+            left: KeyCodes.LEFT,
+            right: KeyCodes.RIGHT
+        });
+    },
+
+    /**
+    * A practical way to create an object containing user selected hotkeys.
+    *
+    * For example,
+    *
+    *     addKeys( { 'up': Phaser.KeyCode.W, 'down': Phaser.KeyCode.S, 'left': Phaser.KeyCode.A, 'right': Phaser.KeyCode.D } );
+    *
+    * would return an object containing properties (`up`, `down`, `left` and `right`) referring to {@link Phaser.Key} object.
+    *
+    * @method Phaser.Keyboard#addKeys
+    * @param {object} keys - A key mapping object, i.e. `{ 'up': Phaser.KeyCode.W, 'down': Phaser.KeyCode.S }` or `{ 'up': 52, 'down': 53 }`.
+    * @return {object} An object containing the properties mapped to {@link Phaser.Key} values.
+    */
+    addKeys: function (keys)
+    {
+        var output = {};
+
+        for (var key in keys)
+        {
+            output[key] = this.addKey(keys[key]);
+        }
+
+        return output;
+    },
+
     /**
     * If you need more fine-grained control over a Key you can create a new Phaser.Key object via this method.
     * The Key object can then be polled, have events attached to it, etc.
@@ -87,8 +142,6 @@ KeyboardManager.prototype = {
         if (!this.keys[keycode])
         {
             this.keys[keycode] = new Key(this, keycode, name);
-
-            // this.addKeyCapture(keycode);
         }
 
         return this.keys[keycode];
@@ -105,8 +158,6 @@ KeyboardManager.prototype = {
         if (this.keys[keycode])
         {
             this.keys[keycode] = undefined;
-
-            // this.removeKeyCapture(keycode);
         }
     },
 
@@ -116,11 +167,18 @@ KeyboardManager.prototype = {
 
     update: function ()
     {
-        //  Process the event queue, dispatching all of the events that have stored up
+        if (!this.enabled)
+        {
+            return;
+        }
+
+        //  Clears the queue array, and also means we don't work on array data that could potentially
+        //  be modified during the processing phase
+        var queue = this.queue.splice(0, this.queue.length);
 
-        var queue = this.queue;
         var keys = this.keys;
 
+        //  Process the event queue, dispatching all of the events that have stored up
         for (var i = 0; i < queue.length; i++)
         {
             var event = queue[i];
@@ -129,6 +187,11 @@ KeyboardManager.prototype = {
             {
                 this.events.dispatch(new Event.KEY_DOWN_EVENT(event));
 
+                if (Event._DOWN[event.keyCode])
+                {
+                    this.events.dispatch(new Event._DOWN[event.keyCode](event));
+                }
+
                 if (keys[event.keyCode])
                 {
                     ProcessKeyDown(keys[event.keyCode], event);
@@ -138,14 +201,17 @@ KeyboardManager.prototype = {
             {
                 this.events.dispatch(new Event.KEY_UP_EVENT(event));
 
+                if (Event._UP[event.keyCode])
+                {
+                    this.events.dispatch(new Event._UP[event.keyCode](event));
+                }
+
                 if (keys[event.keyCode])
                 {
                     ProcessKeyUp(keys[event.keyCode], event);
                 }
             }
         }
-
-        queue.length = 0;
     }
 
 };

v3/src/input/keyboard/events/index.js

@@ -1,4 +1,43 @@
-module.exports = {
+var Event = require('../../../events/Event');
+var KeyCodes = require('./../keys/KeyCodes');
+
+var events = {
     KEY_DOWN_EVENT: require('./KeyDownEvent'),
-    KEY_UP_EVENT: require('./KeyUpEvent')
+    KEY_UP_EVENT: require('./KeyUpEvent'),
+    _UP: [],
+    _DOWN: []
 };
+
+function createKeyEvent (type)
+{
+    var KeyEvent = function (keyboardEvent)
+    {
+        Event.call(this, type);
+
+        this.data = keyboardEvent;
+    };
+
+    KeyEvent.prototype = Object.create(Event.prototype);
+    KeyEvent.prototype.constructor = KeyEvent;
+
+    return KeyEvent;
+}
+
+//  Inject the KeyCode events
+
+for (var code in KeyCodes)
+{
+    //  The Key Down Event Types
+
+    var downType = 'KEY_DOWN_' + code;
+    var upType = 'KEY_UP_' + code;
+
+    events._DOWN[KeyCodes[code]] = createKeyEvent(downType);
+    events._UP[KeyCodes[code]] = createKeyEvent(upType);
+
+    //  More friendly aliases to the main events
+    events[downType] = events._DOWN[KeyCodes[code]];
+    events[upType] = events._UP[KeyCodes[code]];
+}
+
+module.exports = events;

v3/src/input/keyboard/index.js

@@ -2,8 +2,14 @@
 
 module.exports = {
 
-    Key: require('./Key'),
     KeyboardManager: require('./KeyboardManager'),
-    KeyCodes: require('./KeyCodes')
+
+    Key: require('./keys/Key'),
+    KeyCodes: require('./keys/KeyCodes'),
+
+    JustDown: require('./keys/JustDown'),
+    JustUp: require('./keys/JustUp'),
+    DownDuration: require('./keys/DownDuration'),
+    UpDuration: require('./keys/UpDuration')
 
 };

…src/input/keyboard/state/DownDuration.js …/src/input/keyboard/keys/DownDuration.jsv3/src/input/keyboard/state/DownDuration.js renamed to v3/src/input/keyboard/keys/DownDuration.js v3/src/input/keyboard/state/DownDuration.js renamed to v3/src/input/keyboard/keys/DownDuration.js

@@ -1,28 +1,18 @@
 //  A generic Key object which can be passed to the Process functions (and so on)
 
-//  keycode can be either numeric or a string
+//  keycode must be an integer
 
-var Key = function (keycode, name)
+var Key = function (keyCode)
 {
-    if (typeof keycode === 'string')
-    {
-        keycode = keycode.toUpperCase().charCodeAt(0);
-    }
-
-    if (name === undefined || name === '')
-    {
-        name = String.fromCharCode(keycode);
-    }
-
     /**
-    * @property {number} keyCode - The keycode of this key.
+    * @property {integer} keyCode - The keycode of this key.
     */
-    this.keyCode = keycode;
+    this.keyCode = keyCode;
 
     /**
-    * @property {string} name - A string representation of this Key (worked out via String.fromCharCode if possible, or set in the arguments)
+    * @property {KeyboardEvent} originalEvent - The original DOM event.
     */
-    this.name = name;
+    this.originalEvent = undefined;
 
     /**
     * @property {boolean} preventDefault - Should this Key prevent event propagation?
@@ -66,6 +56,12 @@ var Key = function (keycode, name)
     */
     this.shiftKey = false;
 
+    /**
+    * @property {integer} location - The location of the modifier key. 0 for standard (or unknown), 1 for left, 2 for right, 3 for numpad.
+    * @default
+    */
+    this.location = 0;
+
     /**
     * @property {number} timeDown - The timestamp when the key was last pressed down. This is based on Game.time.now.
     */

v3/src/input/keyboard/state/JustDown.js v3/src/input/keyboard/keys/JustDown.jsv3/src/input/keyboard/state/JustDown.js renamed to v3/src/input/keyboard/keys/JustDown.js

@@ -2,24 +2,30 @@ module.exports = {
     BACKSPACE: 8,
     TAB: 9,
     ENTER: 13,
+
     SHIFT: 16,
     CTRL: 17,
     ALT: 18,
+
     PAUSE: 19,
     CAPS_LOCK: 20,
     ESC: 27,
     SPACE: 32,
+
     PAGE_UP: 33,
     PAGE_DOWN: 34,
     END: 35,
     HOME: 36,
+
     LEFT: 37,
     UP: 38,
     RIGHT: 39,
     DOWN: 40,
+
     PRINT_SCREEN: 42,
     INSERT: 45,
     DELETE: 46,
+
     ZERO: 48,
     ONE: 49,
     TWO: 50,
@@ -30,6 +36,7 @@ module.exports = {
     SEVEN: 55,
     EIGHT: 56,
     NINE: 57,
+
     A: 65,
     B: 66,
     C: 67,
@@ -56,6 +63,7 @@ module.exports = {
     X: 88,
     Y: 89,
     Z: 90,
+
     F1: 112,
     F2: 113,
     F3: 114,
@@ -68,6 +76,7 @@ module.exports = {
     F10: 121,
     F11: 122,
     F12: 123,
+
     SEMICOLON: 186,
     PLUS: 187,
     COMMA: 188,

v3/src/input/keyboard/state/JustUp.js v3/src/input/keyboard/keys/JustUp.jsv3/src/input/keyboard/state/JustUp.js renamed to v3/src/input/keyboard/keys/JustUp.js

@@ -1,6 +1,8 @@
 
 var ProcessKeyDown = function (key, event)
 {
+    key.originalEvent = event;
+
     if (key.preventDefault)
     {
         event.preventDefault();
@@ -14,12 +16,14 @@ var ProcessKeyDown = function (key, event)
     key.altKey = event.altKey;
     key.ctrlKey = event.ctrlKey;
     key.shiftKey = event.shiftKey;
+    key.location = event.location;
 
     key.isDown = true;
     key.isUp = false;
     key.timeDown = event.timeStamp;
     key.duration = 0;
     key.repeats++;
+
     key._justDown = true;
     key._justUp = false;