bittyBIG Easy Input System Documentation

Easy Input System

The bittyBIG Easy Input System gives Stencyl one unified input layer for keyboard, mouse, gamepads, touch, mobile gestures, device motion, and virtual controls. Build named Actions once, assign Input Sources to them, then choose an Action Map per Input Slot.

Core Concepts Blocks & Events

Project Setup in Stencyl

1. Install and enable the extension

Open Settings → Extensions.
Install bittyBIG Easy Input System.
Enable it for the project.

2. Use the Easy Input palette

The extension initializes its input backends automatically. You do not need to create a separate manager Actor just to begin using the public blocks.

Create an Action Map, make it active while defining Actions, then assign the map to one or more Input Slots.

Recommended workflow: define gameplay in Actions first. Use raw input reporters/events only when you genuinely need the underlying device data.

Core Concepts

Input Source — A typed description of an input that can be assigned to an Action. Sources can be digital/button, analog/scalar, or vector.

Device Source — Identifies an entire input device rather than a single input. Device Sources include Keyboard, Mouse, Virtual Controls, and a controller at a specific physical Port. Use Set to assign a device exclusively to an Input Slot, Add to share it with another slot, or Remove to stop routing it to a slot without changing its other assignments.

Action — A gameplay-facing name such as Jump, Shoot, Move, Aim, or Pause. Game logic should usually read Actions instead of physical devices.

Action Map — A named collection of Action definitions and their bindings.

Active Action Map — The map currently being edited by Set Action and Digital Vector setup blocks. This is separate from the map an Input Slot is using.

Input Slot — A player/input routing destination that can receive one or more devices. Entire Device Sources and individual Input Sources can be assigned, shared, or rerouted between slots. Each Input Slot can use its own Action Map.

Digital Input — On/off input with Down, Pressed, and Released state.

Analog Input — One numeric value, such as a trigger, stick axis, mouse delta, or Motion axis.

Vector Input — Two numeric components, X and Y, such as a stick, mouse movement, Motion pair, or Digital Vector.

Digital Vector — Four digital directions combined into a Vector Action. Each direction can contain more than one digital input.

Combination Inputs — Multiple digital Input Sources that must all be held together for the Action to be Down.

Raw Input — Physical/device-level values and lifecycle events. Useful for drawing, custom touch logic, diagnostics, or behavior that the Action layer does not model.

Gesture Input — Higher-level interpretation of touch or device movement. One-shot gestures pulse Pressed/Released; Hold and Drag remain Down until they end.

Physical / Virtual Input → Input Source → Action Map → Input Slot → Action → Gameplay

Platform Notes

Area	Current behavior
Keyboard / Mouse	OpenFL/Stencyl keyboard and mouse input. Mouse position is reported in stage coordinates; movement/wheel values are accumulated per frame.
Gamepads	Normalized digital buttons, analog sticks/triggers, vectors, connection events, controller Name/ID, and up to the system’s configured Input Slots. Deadzones are currently global rather than per Input Slot.
Touch	Uses OpenFL multi-touch IDs and stage coordinates. Virtual controls consume their owned touches before raw Touch events and gesture recognition, preventing duplicate input.
Android Motion	Acceleration uses the raw accelerometer stream. Motion uses Android linear acceleration with gravity removed and normalized to g. Orientation uses TYPE_ROTATION_VECTOR. Gyro uses raw TYPE_GYROSCOPE radians/second.
Other Motion targets	The OpenFL accelerometer path remains available where supported. The native iOS Core Motion Gyro/Orientation bridge is intentionally not implemented in this version; hooks/comments are retained for later work.

Blocks & Events

This reference mirrors the current Easy Input event menu and Stencyl palette. Each entry shows the block or event, what it does, and what each visible part means.

How to read the blocks

Dropdown — chooses a mode, state, input, property, or operation.

Text field — usually a name such as an Action, Action Map, Digital Vector, or virtual control.

Number/value field — supplies a slot, position, size, threshold, or other numeric value.

Input Source reporter — describes a digital, analog, or vector input and can be plugged into compatible Action/Vector blocks.

Attached event reporter — data from that exact event callback; its meaning is listed directly in the event's Parts line.

Events

Any Input

Add Event → Extensions → bittyBIG Easy Input System

When Any Input is

Runs when any digital input is pressed or released, including physical mobile device buttons.

Parts: Phase — Pressed or Released. Input Name — normalized digital input name. Input Source — reusable digital source for this exact input. Input Slot — slot/port that produced it. Device Name / Device ID — originating device information.

When Any Input is Input Name Input Source Input Slot Device Name Device ID

Code

scripts.BittyInputBlocks.registerInputEventListener(${eventRef});
// condition: inputPhase == #0

Touch

Add Event → Extensions → bittyBIG Easy Input System

When a Touch

Runs for each touch point that begins, moves, or ends.

Parts: Phase — Begins, Moves, or Ends. Touch ID — finger identifier. X / Y — current touch position. Delta X / Delta Y — movement since the previous touch update. Pressure — touch pressure when the platform supplies it.

When a Touch Touch ID X Y Delta X Delta Y Pressure

Code

scripts.BittyInputBlocks.registerTouchEventListener(${eventRef});
// condition: touchPhase == #0

Any Touch Gesture

Add Event → Extensions → bittyBIG Easy Input System

When Any Touch Gesture

Runs when any finger/screen gesture is recognized. Hold and Drag report both Pressed and Released phases.

Parts: Gesture Name — recognized gesture. Input Source — digital source for that gesture. Gesture Phase — Pressed, plus Released for Hold and Drag. Touch ID — originating touch, or -1 for multi-touch gestures. X / Y — current gesture position. Delta X / Delta Y — total movement from the gesture start.

When Any Touch Gesture Gesture Name Input Source Gesture Phase Touch ID X Y Delta X Delta Y

Code

scripts.BittyInputBlocks.registerTouchGestureEventListener(${eventRef});

Any Device Gesture

Add Event → Extensions → bittyBIG Easy Input System

When Any Device Gesture

Runs when any physical device gesture is recognized.

Parts: Gesture Name — recognized physical-device gesture. Input Source — digital source representing that gesture.

When Any Device Gesture Gesture Name Input Source

Code

scripts.BittyInputBlocks.registerDeviceGestureEventListener(${eventRef});

Controller

Add Event → Extensions → bittyBIG Easy Input System

When a Controller

Runs once for each controller port that changes connection state. Use the Current Controller getters inside this event.

Parts: Connection — Connects or Disconnects. Input Slot — assigned controller slot. Device Name / Device ID — controller identity.

When a Controller Input Slot Device Name Device ID

Code

scripts.BittyInputBlocks.registerControllerEventListener(${eventRef});
// condition: controllerConnected == #0

Analog Input

Add Event → Extensions → bittyBIG Easy Input System

When an Analog Input Changes

Runs when a controller analog input or Analog Virtual Joystick axis changes enough to pass the system's analog event threshold.

Parts: Input Name — analog axis/trigger name. Analog Source — reusable analog source for that input. Analog Value — new numeric value. Input Slot — originating slot. Device Name / Device ID — originating controller or virtual device.

When an Analog Input Changes Input Name Analog Source Analog Value Input Slot Device Name Device ID

Code

scripts.BittyInputBlocks.registerAnalogEventListener(${eventRef});

Action

Add Event → Extensions → bittyBIG Easy Input System

When Action is for

Runs when the selected mapped Action is pressed or released. Choose Any for every Input Slot, or Input Slot to filter by the supplied slot number.

Parts: Action — mapped gameplay Action name. Phase — Pressed or Released. Scope — Any Input Slot or one specific Input Slot. Input Slot — used only when the scope is set to Input Slot.

When Action is for

Code

scripts.BittyInputBlocks.registerActionEventListener(${eventRef}, this);
// condition: action == #0 && actionPhase == #1 && (#2 == "Any" || controllerPort == Std.int(#3))

Input Logic

State

Input Logic → State

Input Source State

Returns whether a digital Input Source is down, was pressed this frame, or was released this frame in Input Slot 0.

Parts: Input Source — digital source to test. State — Down, Pressed, or Released.

Input Input Source is

Code

scripts.BittyInputBlocks.getInputSourceState(~,~)

Input Source State by Slot

Returns whether a digital Input Source is down, was pressed this frame, or was released this frame for the selected Input Slot.

Parts: Input Source — digital source to test. State — Down, Pressed, or Released. Input Slot — slot whose state should be checked.

Input Input Source is for Input Slot

Code

scripts.BittyInputBlocks.getInputSourceState(~,~,~)

Actions

Input Logic → Actions

Action is for Input Slot

Returns whether a Button Action is down, pressed, or released for the selected Input Slot.

Parts: Action — mapped gameplay Action name. State — Down, Pressed, or Released. Input Slot — slot whose Action state should be checked.

Action is for Input Slot

Code

scripts.BittyInputBlocks.getActionState(~,~,~)

Get Value of Action for Input Slot

Returns the Analog, Vector X, or Vector Y value of an Action for the selected Input Slot.

Parts: Value Type — Analog, Vector X, or Vector Y. Action — mapped Action name. Input Slot — slot whose value should be read.

Get Value of Action for Input Slot

Code

scripts.BittyInputBlocks.getActionValue(~,~,~)

Set Action to

Assigns a digital, analog, or vector Input Source to an Action in the active Action Map.

Parts: Action — gameplay-facing Action name. Input Source — digital, analog, or vector source to bind. The binding is added to the active Action Map.

Set Action to Input Source

Code

scripts.BittyInputBlocks.setAction(~,~);

Digital Vector

Returns a named Digital Vector as a vector Input Source.

Parts: Name — Digital Vector defined in the active Action Map. Output — vector Input Source.

Digital Vector

Code

scripts.BittyInputBlocks.inputSourceDigitalVector(~)

Combination Inputs

Combines digital Input Sources. Every contained input must be held at the same time. Combination blocks can be nested to require more than two inputs.

Parts: Left / Right Input Source — digital sources that must both be held. Nest the block to require additional inputs.

Input Source + Input Source

Code

scripts.BittyInputBlocks.combineInputs(~,~)

Action Maps

Input Logic → Action Maps

Action Map Operation

Creates, selects, or clears a named Action Map.

Parts: Operation — Create, Set Active, or Clear. Action Map — map name the operation applies to.

Action Map

Code

scripts.BittyInputBlocks.actionMapOperation(~,~);

Set Input Slot Action Map to

Assigns an existing Action Map to an Input Slot. Each Input Slot can use a different Action Map.

Parts: Input Slot — player/input slot number. Action Map — existing map assigned to that slot.

Set Input Slot Action Map to

Code

scripts.BittyInputBlocks.setInputSlotActionMap(~,~);

Get Action Map for Input Slot

Returns the Action Map assigned to an Input Slot.

Parts: Input Slot — slot to inspect. Output — currently assigned Action Map name.

Get Action Map for Input Slot

Code

scripts.BittyInputBlocks.getInputSlotActionMap(~)

Get Active Action Map

Returns the name of the Action Map currently being defined.

Parts: Output — Action Map currently selected for editing by Set Action and Digital Vector blocks.

Get Active Action Map

Code

scripts.BittyInputBlocks.getActiveActionMap()

Digital Vectors

Input Logic → Digital Vectors

Create Digital Vector

Creates or resets a named Digital Vector in the active Action Map.

Parts: Name — Digital Vector to create or reset in the active Action Map.

Create Digital Vector

Code

scripts.BittyInputBlocks.createDigitalVector(~);

Create Digital Vector Up Down Left Right

Convenience block that creates or replaces a Digital Vector and assigns one digital Input Source to each direction.

Parts: Name — vector name. Up / Down / Left / Right — digital Input Source assigned to each direction.

Create Digital Vector Up Input Source Down Input Source Left Input Source Right Input Source

Code

scripts.BittyInputBlocks.createDigitalVectorDirections(~,~,~,~,~);

Add to of Digital Vector

Adds a digital Input Source to one direction, or adds a WASD, Arrows, or D-Pad vector source to All directions.

Parts: Input Source — source to add. Direction — Up, Down, Left, Right, or All. Digital Vector — target vector name.

Add Input Source to of Digital Vector

Code

scripts.BittyInputBlocks.addDigitalVectorInput(~,~,~);

Clear Digital Vector

Removes a custom Digital Vector from the active Action Map.

Parts: Name — custom Digital Vector to remove from the active Action Map.

Clear Digital Vector

Code

scripts.BittyInputBlocks.clearDigitalVector(~);

Kb & M

Inputs

Kb & M → Inputs

Keyboard

Returns a keyboard letter or number Input Source.

Parts: Key — keyboard letter or number. Output — digital Input Source.

Keyboard

Code

scripts.BittyInputBlocks.inputSourceKeyboard(~)

Keyboard Common / Symbol

Returns a common keyboard or punctuation Input Source.

Parts: Key — common, navigation, modifier, arrow, or symbol key. WASD and Arrows return built-in Digital Vector sources; other choices return digital Input Sources.

Keyboard Common / Symbol

Code

scripts.BittyInputBlocks.inputSourceKeyboard(~)

Keyboard Function Key

Returns a keyboard function-key Input Source.

Parts: Key — F1 through F12. Output — digital Input Source.

Keyboard Function Key

Code

scripts.BittyInputBlocks.inputSourceKeyboard(~)

Mouse

Returns a mouse button Input Source.

Parts: Button — Left, Right, or Middle mouse button. Output — digital Input Source.

Mouse

Code

scripts.BittyInputBlocks.inputSourceMouse(~)

Mouse Analog

Returns a mouse analog Input Source.

Parts: Value — Move Delta X, Move Delta Y, or Wheel. Output — analog Input Source.

Mouse Analog

Code

scripts.BittyInputBlocks.inputSourceMouseAnalog(~)

Mouse Vector

Returns a mouse vector Input Source.

Parts: Vector — mouse movement vector. Output — vector Input Source.

Mouse Vector

Code

scripts.BittyInputBlocks.inputSourceMouseVector(~)

Mouse

Kb & M → Mouse

Get Mouse

Returns the selected mouse position component in stage coordinates.

Parts: Axis — X or Y. Output — current mouse position in stage coordinates.

Get Mouse

Code

scripts.BittyInputBlocks.getMouseValue(~)

Get Mouse Delta

Returns the selected mouse movement component accumulated for the current frame.

Parts: Axis — X or Y. Output — mouse movement accumulated this frame.

Get Mouse Delta

Code

scripts.BittyInputBlocks.getMouseDelta(~)

Get Mouse Wheel

Returns mouse wheel movement accumulated for the current frame. Returns 0 when the wheel did not move.

Parts: Output — mouse-wheel movement accumulated this frame.

Get Mouse Wheel

Code

scripts.BittyInputBlocks.getMouseWheel()

Gamepads

Inputs

Gamepads → Inputs

Controller

Returns a controller button Input Source.

Parts: Button — normalized controller button name. Output — digital Input Source.

Controller

Code

scripts.BittyInputBlocks.inputSourceController(~)

Controller Analog

Returns a controller analog Input Source.

Parts: Axis / Trigger — normalized analog controller input. Output — analog Input Source.

Controller Analog

Code

scripts.BittyInputBlocks.inputSourceControllerAnalog(~)

Controller Vector

Returns a controller vector Input Source.

Parts: Vector — Left Stick, Right Stick, or D-Pad. Output — vector Input Source.

Controller Vector

Code

scripts.BittyInputBlocks.inputSourceControllerVector(~)

Properties

Gamepads → Properties

Controller is connected at Port

Returns true if a controller is currently assigned to the selected controller port.

Parts: Port — controller/Input Slot number to test. Output — true when a controller is assigned there.

Controller is connected at Port

Code

scripts.BittyInputBlocks.isControllerConnected(~)

Get for Controller Port

Returns a controller analog value or deadzone. Deadzones are currently global, so Controller Port is ignored for deadzone values.

Parts: Value — analog axis/trigger or deadzone to read. Controller Port — controller slot for analog values; deadzone choices are currently global.

Get for Controller Port

Code

scripts.BittyInputBlocks.getControllerNumber(~,~)

Set Deadzone to

Sets the global stick or trigger deadzone. Values are clamped from 0.02 to 1 and applied to every controller port.

Parts: Type — Stick or Trigger deadzone. Value — global deadzone amount applied to all controller ports.

Set Deadzone to

Code

scripts.BittyInputBlocks.setDeadzone(~,~);

Get Connected Controller Count

Returns the number of currently connected controllers.

Parts: Output — number of controllers currently connected.

Get Connected Controller Count

Code

scripts.BittyInputBlocks.getConnectedControllerCount()

Get Controller for Port

Returns the connected controller Name or ID for the selected port.

Parts: Value — Name or ID. Port — controller/Input Slot to inspect.

Get Controller for Port

Code

scripts.BittyInputBlocks.getControllerText(~,~)

Mobile

Inputs

Mobile → Inputs

Mobile Input

Returns a physical mobile device-button Input Source.

Parts: Button — physical mobile device button such as Back or Volume. Output — digital Input Source.

Mobile Input

Code

scripts.BittyInputBlocks.inputSourceMobile(~)

Touch

Returns a Touch Input Source. Choose Any to use any unconsumed touch; choose ID to use the supplied Touch ID.

Parts: Mode — Any touch or one specific Touch ID. Touch ID — used only when ID is selected. Output — digital Touch Input Source.

Touch

Code

scripts.BittyInputBlocks.inputSourceTouch(~,~)

Touch Gesture

Returns the selected touch gesture as a digital Input Source.

Parts: Gesture — Tap, Hold, Drag, Swipe, Slide, Pinch, Rotate, and related touch gestures. Output — digital Input Source.

Touch Gesture

Code

scripts.BittyInputBlocks.inputSourceTouchGesture(~)

Device Gesture

Returns the selected physical device gesture as a digital Input Source.

Parts: Gesture — physical movement/orientation gesture such as Move, Shake, Tilt, Rotate, or Flip. Output — digital Input Source.

Device Gesture

Code

scripts.BittyInputBlocks.inputSourceDeviceGesture(~)

Motion Analog

Returns a device-motion analog Input Source.

Parts: Axis — X, Y, or Z from gravity-free Motion. Output — analog Input Source.

Motion Analog

Code

scripts.BittyInputBlocks.inputSourceMotionAnalog(~)

Motion Vector

Returns the selected pair of device Motion axes as a 2D vector Input Source.

Parts: Axes — X/Y, X/Z, or Y/Z pair from gravity-free Motion. Output — 2D vector Input Source.

Motion Vector

Code

scripts.BittyInputBlocks.inputSourceMotionVector(~)

Gestures

Mobile → Gestures

Set Touch Gesture to

Changes a touch-gesture recognition threshold or timing value.

Parts: Setting — touch gesture threshold/timing property. Value — new numeric setting.

Set Touch Gesture to

Code

scripts.BittyInputBlocks.setTouchGestureSetting(~,~);

Set Device Gesture to

Changes a physical-device gesture recognition threshold or timing value.

Parts: Setting — device gesture threshold/timing property. Value — new numeric setting.

Set Device Gesture to

Code

scripts.BittyInputBlocks.setDeviceGestureSetting(~,~);

Touch

Mobile → Touch

Get Touch Count

Returns the number of currently active touch points.

Parts: Output — number of currently active touches.

Get Touch Count

Code

scripts.BittyInputBlocks.getTouchCount()

Get Touch for Touch ID

Returns the selected value for the specified touch ID.

Parts: Value — X, Y, Delta X, Delta Y, or Pressure. Touch ID — touch point to inspect.

Get Touch for Touch ID

Code

scripts.BittyInputBlocks.getTouchValue(~,~)

Device Motion

Mobile → Device Motion

Device Motion Value

Returns the selected X, Y, or Z value from Acceleration, Gyro, Motion, or Rotation.

Parts: Axis — X, Y, or Z. Source — Acceleration, Gyro, Motion, or Rotation. Output — current numeric sensor value.

Get of

Code

scripts.BittyInputBlocks.getDeviceMotionValue(~,~)

Orientation Value

Returns the selected current device orientation value.

Parts: Component — Pitch, Roll, or Yaw. Output — current device orientation in degrees.

Get of Orientation

Code

scripts.BittyInputBlocks.getOrientationValue(~)

Set Device Motion Threshold

Sets the selected Motion or Rotation threshold.

Parts: Type — Motion or Rotation. Value — threshold used before those processed values are reported.

Set Threshold to

Code

scripts.BittyInputBlocks.setDeviceMotionThreshold(~,~);

Get Device Motion Threshold

Returns the selected Motion or Rotation threshold.

Parts: Type — Motion or Rotation. Output — current threshold.

Get Threshold

Code

scripts.BittyInputBlocks.getDeviceMotionThreshold(~)

Virtual Controls

Inputs

Virtual Controls → Inputs

Virtual Input

Returns a named Virtual Button or Digital Virtual Joystick direction Input Source, such as Jump or Joystick Up.

Parts: Name — registered Virtual Button name or digital joystick direction name. Output — digital Input Source.

Virtual Input

Code

scripts.BittyInputBlocks.inputSourceVirtual(~)

Virtual Joystick Analog

Returns an Analog Virtual Joystick axis Input Source such as JoystickX or JoystickY.

Parts: Name / Axis — registered Analog Virtual Joystick axis. Output — analog Input Source.

Virtual Joystick Analog

Code

scripts.BittyInputBlocks.inputSourceVirtualJoystickAnalog(~)

Virtual Joystick Vector

Returns a named Virtual Joystick as a vector Input Source.

Parts: Name — registered Virtual Joystick. Output — vector Input Source.

Virtual Joystick Vector

Code

scripts.BittyInputBlocks.inputSourceVirtualJoystickVector(~)

Virtual Buttons

Virtual Controls → Virtual Buttons

Create Virtual Button at X Y named

Creates a Slot 0 Virtual Button without assigning an Action.

Parts: X / Y — center position. Width / Height — control size. Radius — rounded-corner radius when applicable. Shape — Rectangle, Rounded, or Circle. Name — virtual input name.

Create Virtual Button at X Y named

Code

scripts.BittyInputBlocks.createVirtualButton(~,~,~);

Register as Virtual Button named

Registers an actor as a named Virtual Button. Registering the control does not assign it to an Action.

Parts: Actor — actor used as the touchable control. Name — virtual input name.

Code

scripts.BittyInputBlocks.registerVirtualButton(~,~);

Set of Virtual Button to

Changes one property of a generated Virtual Button.

Parts: Property — X, Y, Width, Height, Radius, Color, Opacity, Visible, or Enabled. Virtual Button — control name. Value — replacement property value.

Set of Virtual Button to Input Source

Code

scripts.BittyInputBlocks.setVirtualButtonProperty(~,~,~);

Set Shape of Virtual Button to

Sets the shape of a generated Virtual Button.

Parts: Virtual Button — control name. Shape — Rectangle, Rounded, or Circle.

Set Shape of Virtual Button to

Code

scripts.BittyInputBlocks.setVirtualButtonShape(~,~);

Remove Virtual Button

Releases held input, removes touch ownership, unregisters the control, and removes its generated display.

Parts: Virtual Button — control name to unregister and remove.

Remove Virtual Button

Code

scripts.BittyInputBlocks.removeVirtualButton(~);

Virtual Joysticks

Virtual Controls → Virtual Joysticks

Create Virtual Joystick at X Y Radius named

Creates a Slot 0 Virtual Joystick centered at X/Y. Digital exposes Name Up/Down/Left/Right; Analog exposes NameX/NameY. Assign Actions separately.

Parts: Mode — Digital or Analog. X / Y — joystick center. Radius — base radius. Name — virtual joystick name.

Create Virtual Joystick at X Y Radius named

Code

scripts.BittyInputBlocks.createVirtualJoystick(~,~,~,~,~);

Register as Virtual Joystick named

Registers an actor as a named Digital or Analog Virtual Joystick. Analog registration exposes <Name>X and <Name>Y analog inputs. Registering the control does not assign it to an Action.

Parts: Actor — actor used as joystick area. Mode — Digital or Analog. Name — virtual joystick name.

Code

scripts.BittyInputBlocks.registerVirtualJoystick(~,~,~);

Set of Virtual Joystick to

Changes one property of a generated Virtual Joystick.

Parts: Property — position, size, deadzone/visual, visibility, or enabled state. Virtual Joystick — control name. Value — replacement property value.

Set of Virtual Joystick to Input Source

Code

scripts.BittyInputBlocks.setVirtualJoystickProperty(~,~,~);

Remove Virtual Joystick

Releases held input, removes touch ownership, unregisters the control, and removes its generated display.

Parts: Virtual Joystick — control name to unregister and remove.

Remove Virtual Joystick

Code

scripts.BittyInputBlocks.removeVirtualJoystick(~);

FAQs

Should I read physical inputs directly or use Actions?

Use Actions for normal gameplay. Physical Input Sources should generally be assigned to Actions, so keyboard, controllers, touch gestures, and virtual controls can share the same gameplay logic. Use raw reporters/events when the raw lifecycle or sensor value is itself important.

What is the difference between Pressed, Down, and Released?

Pressed is the frame an input begins. Down stays true while it is held. Released is the frame it ends.

What is the difference between Tap, Long Press, Hold, Drag, Slide, and Swipe?

Tap is a quick mostly stationary release. Long Press is a one-shot event after holding mostly still. Hold is the sustained state that begins at that same long-press point. Drag is sustained movement after crossing Drag Minimum Distance. Slide is a directional one-shot recognized while the finger is still down. Swipe is a fast directional one-shot classified on release. Drag can therefore begin before Slide or Swipe.

Why can Tap fire before Double Tap or Triple Tap?

Tap is intentionally immediate. The first qualifying release emits Tap immediately; later qualifying taps can then emit Double Tap and Triple Tap. This avoids delaying ordinary taps while waiting to see whether another tap arrives.

Can Hold and Drag both be Down at once?

Not for the same touch. If a held touch moves far enough to become a Drag, Hold releases first and Drag becomes Down.

Why does Drag often print before Slide or Swipe?

Drag is a sustained state and can begin as soon as its movement threshold is crossed. Slide needs its own distance plus minimum duration, while Swipe is classified at release. The order is intentional.

Do virtual controls also trigger raw Touch and touch gestures?

No. A virtual control consumes the touch it owns before raw Touch/gesture processing, preventing one finger press from becoming both a virtual-control input and a second gesture/raw input.

What is the difference between Acceleration, Motion, Rotation, Orientation, and Gyro?

Acceleration is the raw accelerometer and includes gravity. Motion is movement acceleration; on Android it uses gravity-free linear acceleration. Orientation is the device’s current Pitch/Roll/Yaw. Rotation is the change in orientation between updates. Gyro is raw angular velocity; on Android it is radians per second.

Does Shake use the Gyro?

No. Shake uses strong alternating linear-Motion reversals. Gyro remains a raw angular-velocity reporter.

Are controller deadzones per controller?

Not yet. Stick and Trigger deadzones are global in this version. The controller-port field is ignored when the selected reporter is Stick Deadzone or Trigger Deadzone.

Release Notes

Version 1.0 — Current documented build

Unified keyboard, mouse, gamepad, touch, mobile-device, gesture, Action Map, Digital Vector, and virtual-control APIs. Includes sustained Hold/Drag, repeatable Pinch/Rotate touch gestures, physical device gestures, Android linear Motion/orientation, and raw Android Gyro reporters.

Documentation generated from the audited extension build represented by the current conversation changes.