Scylla Input

IMPORTANT:

• This asset requires Scylla Core.
• This asset works with Unity's Input System. Unity's legacy input manager is not supported!

Scylla Input is a layer that sits between Unity's Input System and your game. It hands you the features that many projects ends up building from scratch: stack-based input contexts so a menu, a debug console, or a pause screen can take over input and give it back, an input buffer so a dash still fires when the player hit it a frame early, a runtime rebind screen that actually saves, control-scheme detection that knows whether a keyboard or a gamepad is in use, and button prompts that switch to the matching glyph the moment the player activates a controller.

None of that is hard to write (but tedious nevertheless). It's just always there, the same work on every project, quietly eating the month while the game itself barely moves. As a Scylla module, Scylla Input shares one lifecycle, event bus, configuration system, and logger with the rest of the framework, so your game subscribes to input instead of reinventing the layer underneath it.

What's in the box

• Input Actions editor: Scylla's own window for .inputactions assets, editing Unity's file in place so anything you author still works with PlayerInput and Unity's generated wrapper. Maps, actions and bindings sit in one tree, next to panels for control schemes, contexts, glyphs and the controls-screen layout. The binding matrix shows every action against every control scheme at once, and it reads your contexts before calling anything a conflict, so two actions that can never be live together stop getting flagged. A sidecar asset holds what the .inputactions format has no room for: notes, display names, which actions players may not rebind, and per-scheme icon sets. It also generates a C# constants file, so a renamed action breaks the build instead of failing silently at runtime, and exports a whole setup as a bundle that lands in another project intact. Twelve genre presets come with it, from 2D platformer to 4X strategy.

• Input contexts: A stack of named contexts so menus, dialogs, pause screens, cutscenes, etc. can take over input and then quietly hand it back. Each one has a priority and can block whatever sits below it, action maps switch on and off on their own, and you start with a sensible default set: Gameplay, Menu, Console, Global. Contexts that can never be active at the same time can share keys without setting off false conflict warnings.

• Runtime rebinding: A full rebind workflow for player settings screens, with conflict detection, modifier-aware capture (Ctrl+1, Ctrl+Shift+1, and a plain 1 stay separate the whole way through), and a UI-agnostic manager that handles the data model, batch operations, and auto-resolve. Includes a finished rebind screen as a demo: a row per action, a column per control scheme, click to rebind, red on conflict, saved the instant you accept.

• Binding persistence: Bindings save themselves. Pick readable JSON profiles on disk, PlayerPrefs when you want zero fuss, or your own backend through the storage interface. Multiple profiles, auto-load on startup, auto-save after a rebind, and reset-to-defaults for one action or all of them.

• Input buffering: Let's say a jump pressed 50 ms before the player actually lands still counts. Every action gets its own window (a combo move can stay open longer than a footstep), buffers expire on their own, and gameplay code pulls them when it's ready. This is the jump-buffering and combo-window behavior action- and fighting games live or die on.

• Control-scheme detection: Keyboard, mouse, and gamepad: it tracks whichever one the player touched last and switches automatically. Activity thresholds for the stick, triggers, and mouse keep a bumped controller from stealing focus, a cooldown stops it flip-flopping, and it tells Xbox, PlayStation, Nintendo, Steam, and generic pads apart so your face-button labels stay honest.

• Button-prompt hints: Ask for an action, get back the right glyph for whatever the player is holding right now. Icon sets map bindings to sprites and labels, the active scheme picks the matching set, and the cache clears itself on every rebind and device switch so your UI never has to think about it.

• Action management: Works straight off Unity's Input Action Assets. Register one or more, read floats, vectors, or whatever value type an action carries, and hook performed, started, and cancelled through plain C# callbacks or typed events. It sorts out modifier overlap on its own, so a Shift+Backquote action doesn't accidentally trip the plain Backquote one. There's also a platform-agnostic key enum so your game code can name keys without dragging in the Input System namespace.

• Config and tooling: A configuration asset with the settings grouped the way you'd expect (scheme detection, buffering, storage, rebinding, logging), a companion asset for your context definitions, and a JSON overlay so any value can be overridden at runtime or swapped per build. On the editor side you get custom inspectors, a runtime view of the active context and its action maps, a setup wizard, and validation badges that catch a broken setup before you ever hit Play.

• Events for everything that matters: Devices connecting and disconnecting, input switching on and off, actions firing, contexts pushed and popped, bindings loaded and saved, rebinds starting and finishing, buffers filling and draining, scheme changes, hint changes. All typed, all on the Scylla event bus, so the rest of your game listens instead of polling.

Holds up in production

• Fully event-driven, so it reacts to events instead of scanning every binding every frame.
• Buffering is off until you ask for it and costs nothing while it's off. Per-action windows keep it lean when it's on.
• Modifier combos stay distinct from registration through conflict detection to the actual dispatch at runtime, not just at the surface.
• Controllers can be plugged in and pulled out mid-game; the module tracks the change and falls back cleanly.
• It survives domain reloads, including with Enter Play Mode options turned on, without leaving stale state behind.
• The hint cache clears itself on rebind and scheme switch, so your UI never has to.
• It sits on top of Unity's Input System instead of replacing it. Anything you author in the Input Actions Editor behaves exactly as Unity intends.
• Written for Unity 6.3 and up on current APIs, with no deprecated calls and no shims for old versions hanging around.
• Covered by an EditMode test suite across contexts, buffering, rebinding, schemes, hints, and storage, and kept warning-free as a matter of habit.

Links

Official Site & Documentation

API Documentation

Discord