Phaser.Input is the Input Manager for all types of Input across Phaser, including mouse, keyboard, touch and MSPointer.
The Input manager is updated automatically by the core game loop.
Name | Type | Description |
---|---|---|
game | Phaser.Game | Current game instance. |
The maximum number of pointers that can be added. This excludes the mouse pointer.
The most recently active Pointer object.
When you've limited max pointers to 1 this will accurately be either the first finger touched or mouse.
A Circle object centered on the x/y screen coordinates of the Input.
Default size of 44px (Apples recommended "finger tip" size) but can be changed to anything.
The number of milliseconds between taps of the same Pointer for it to be considered a double tap / click.
When enabled, input (eg. Keyboard, Mouse, Touch) will be processed - as long as the individual sources are enabled themselves.
When not enabled, all input sources are ignored. To disable just one type of input; for example, the Mouse, use input.mouse.enabled = false
.
A reference to the currently running game.
The Gamepad Input manager.
The canvas to which single pixels are drawn in order to perform pixel-perfect hit detection.
The context of the pixel perfect hit canvas.
The number of milliseconds that the Pointer has to be pressed down for it to fire a onHold event.
A list of interactive objects. The InputHandler components add and remove themselves from this list.
The number of milliseconds below which the Pointer is considered justPressed.
The number of milliseconds below which the Pointer is considered justReleased .
The Keyboard Input manager.
The maximum number of Pointers allowed to be active at any one time. A value of -1 is only limited by the total number of pointers. For lots of games it's useful to set this to 1.
You can tell all Pointers to ignore any Game Object with a priorityID
lower than this value.
This is useful when stacking UI layers. Set to zero to disable.
The Mouse Input manager.
You should not usually access this manager directly, but instead use Input.mousePointer or Input.activePointer
which normalizes all the input values for you, regardless of browser.
The mouse has its own unique Phaser.Pointer object which you can use if making a desktop specific game.
An array of callbacks that will be fired every time the activePointer receives a move event from the DOM.
To add a callback to this array please use Input.addMoveCallback
.
The MSPointer Input manager.
You should not usually access this manager directly, but instead use Input.activePointer
which normalizes all the input values for you, regardless of browser.
Controls the expected behavior when using a mouse and touch together on a multi-input device.
A Signal that is dispatched each time a pointer is pressed down.
A Signal that is dispatched each time a pointer is held down.
A Signal that is dispatched each time a pointer is tapped.
A Signal that is dispatched each time a pointer is released.
A Pointer object.
A Pointer object.
A Pointer object.
A Pointer object.
A Pointer object.
A Pointer object.
A Pointer object.
A Pointer object.
A Pointer object.
A Pointer object.
An array of non-mouse pointers that have been added to the game.
The properties pointer1..N
are aliases for pointers[0..N-1]
.
True if the Input is currently poll rate locked.
How often should the input pointers be checked for updates? A value of 0 means every single frame (60fps); a value of 1 means every other frame (30fps) and so on.
A point object representing the current position of the Pointer.
The total number of entries that can be recorded into the Pointer objects tracking history.
If the Pointer is tracking one event every 100ms; then a trackLimit of 100 would store the last 10 seconds worth of history.
Sets if the Pointer objects should record a history of x/y coordinates they have passed through.
The history is cleared each time the Pointer is pressed down.
The history is updated at the rate specified in Input.pollRate
The rate in milliseconds at which the Pointer objects should update their tracking history.
If the Input Manager has been reset locked then all calls made to InputManager.reset,
such as from a State change, are ignored.
The scale by which all input coordinates are multiplied; calculated by the ScaleManager. In an un-scaled game the values will be x = 1 and y = 1.
A point object representing the speed of the Pointer. Only really useful in single Pointer games; otherwise see the Pointer objects directly.
The number of milliseconds that the Pointer has to be pressed down and then released to be considered a tap or click.
The total number of active Pointers, not counting the mouse pointer.
The total number of inactive Pointers.
The Touch Input manager.
You should not usually access this manager directly, but instead use Input.activePointer
which normalizes all the input values for you, regardless of browser.
The world X coordinate of the most recently active pointer.
The world Y coordinate of the most recently active pointer.
The X coordinate of the most recently active pointer.
This value takes game scaling into account automatically. See Pointer.screenX/clientX for source values.
The Y coordinate of the most recently active pointer.
This value takes game scaling into account automatically. See Pointer.screenY/clientY for source values.
Adds a callback that is fired every time the activePointer receives a DOM move event such as a mousemove or touchmove.
The callback will be sent 4 parameters:
A reference to the Phaser.Pointer object that moved,
The x position of the pointer,
The y position,
A boolean indicating if the movement was the result of a 'click' event (such as a mouse click or touch down).
It will be called every time the activePointer moves, which in a multi-touch game can be a lot of times, so this is best
to only use if you've limited input to a single pointer (i.e. mouse or touch).
The callback is added to the Phaser.Input.moveCallbacks array and should be removed with Phaser.Input.deleteMoveCallback.
Name | Type | Description |
---|---|---|
callback | function | The callback that will be called each time the activePointer receives a DOM move event. |
context | object | The context in which the callback will be called. |
Add a new Pointer object to the Input Manager.
By default Input creates 3 pointer objects: mousePointer
(not include in part of general pointer pool), pointer1
and pointer2
.
This method adds an additional pointer, up to a maximum of Phaser.Input.MAX_POINTERS (default of 10).
The new Pointer object that was created; null if a new pointer could not be added.
Starts the Input Manager running.
Removes the callback from the Phaser.Input.moveCallbacks array.
Name | Type | Description |
---|---|---|
callback | function | The callback to be removed. |
context | object | The context in which the callback exists. |
Stops all of the Input Managers from running.
This will return the local coordinates of the specified displayObject based on the given Pointer.
Name | Type | Description |
---|---|---|
displayObject | Phaser.Sprite | Phaser.Image | The DisplayObject to get the local coordinates for. |
pointer | Phaser.Pointer | The Pointer to use in the check against the displayObject. |
A point containing the coordinates of the Pointer position relative to the DisplayObject.
Get the first Pointer with the given active state.
Name | Type | Argument | Default | Description |
---|---|---|---|---|
isActive | boolean | <optional> | false | The state the Pointer should be in - active or inactive? |
A Pointer object or null if no Pointer object matches the requested state.
Get the Pointer object whos pointerId
property matches the given value.
The pointerId property is not set until the Pointer has been used at least once, as its populated by the DOM event.
Also it can change every time you press the pointer down if the browser recycles it.
Name | Type | Description |
---|---|---|
pointerId | number | The |
A Pointer object or null if no Pointer object matches the requested identifier.
Get the Pointer object whos identifier
property matches the given identifier value.
The identifier property is not set until the Pointer has been used at least once, as its populated by the DOM event.
Also it can change every time you press the pointer down, and is not fixed once set.
Note: Not all browsers set the identifier property and it's not part of the W3C spec, so you may need getPointerFromId instead.
Name | Type | Description |
---|---|---|
identifier | number | The Pointer.identifier value to search for. |
A Pointer object or null if no Pointer object matches the requested identifier.
Tests if the pointer hits the given object.
Name | Type | Description |
---|---|---|
displayObject | DisplayObject | The displayObject to test for a hit. |
pointer | Phaser.Pointer | The pointer to use for the test. |
localPoint | Phaser.Point | The local translated point. |
Reset all of the Pointers and Input states.
The optional hard
parameter will reset any events or callbacks that may be bound.
Input.reset is called automatically during a State change or if a game loses focus / visibility.
To control control the reset manually set Phaser.InputManager.resetLocked to true
.
Name | Type | Argument | Default | Description |
---|---|---|---|---|
hard | boolean | <optional> | false | A soft reset won't reset any events or callbacks that are bound. A hard reset will. |
Resets the speed and old position properties.
Name | Type | Description |
---|---|---|
x | number | Sets the oldPosition.x value. |
y | number | Sets the oldPosition.y value. |
Adds a callback that is fired every time Pointer.processInteractiveObjects
is called.
The purpose of processInteractiveObjects
is to work out which Game Object the Pointer is going to
interact with. It works by polling all of the valid game objects, and then slowly discounting those
that don't meet the criteria (i.e. they aren't under the Pointer, are disabled, invisible, etc).
Eventually a short-list of 'candidates' is created. These are all of the Game Objects which are valid
for input and overlap with the Pointer. If you need fine-grained control over which of the items is
selected then you can use this callback to do so.
The callback will be sent 3 parameters:
1) A reference to the Phaser.Pointer object that is processing the Items.
2) An array containing all potential interactive candidates. This is an array of InputHandler
objects, not Sprites.
3) The current 'favorite' candidate, based on its priorityID and position in the display list.
Your callback MUST return one of the candidates sent to it.
Name | Type | Description |
---|---|---|
callback | function | The callback that will be called each time |
context | object | The context in which the callback will be called. |
Find the first free Pointer object and start it, passing in the event data.
This is called automatically by Phaser.Touch and Phaser.MSPointer.
Name | Type | Description |
---|---|---|
event | any | The event data from the Touch event. |
The Pointer object that was started or null if no Pointer object is available.
Stops the matching Pointer object, passing in the event data.
Name | Type | Description |
---|---|---|
event | any | The event data from the Touch event. |
The Pointer object that was stopped or null if no Pointer object is available.
Updates the Input Manager. Called by the core Game loop.
Updates the matching Pointer object, passing in the event data.
This is called automatically and should not normally need to be invoked.
Name | Type | Description |
---|---|---|
event | any | The event data from the Touch event. |
The Pointer object that was updated; null if no pointer was updated.
© 2016 Richard Davey, Photon Storm Ltd.
Licensed under the MIT License.
http://phaser.io/docs/2.6.2/Phaser.Input.html