Standard Controls

move, jump, shoot at the cursor, and rebind any of it.

▶ Run in browser

Tags: input actions rebinding keyboard mouse controller touch

The controls nearly every game has, written the way SimVX spells them: a movement action on WASD or the left stick, jump on Space or pad A, shoot on a left click (at the cursor) or pad X, and a rebind screen with two tables: the pad’s controls (which physical button Controller.A is) and the actions (which names jump answers to). Each cell listens for the next control the player presses and binds that; its listener claims the press, so choosing Space for jump does not also jump.

What it demonstrates

• Actions in input_context typed by their bindings: Axis2D.WASD and Controller.LEFT_STICK make move a Vec2, buttons make jump and shoot a bool.

• @on_input("jump") fires once per press; a handler hears a release only when it asks with edge="release".

• InputListener: a cell adds one and binds what it hears in one line, InputMap.rebind(target, heard). Cancelling is the cell’s own choice (Esc, or whatever the player has made pad Back).

• Two tables, one map. A device row rebinds an engine entry, InputMap.rebind(Controller.A, heard), and every action using Controller.A follows; InputMap.swap turns a pad with A and B the wrong way round. An action row binds the press by the engine entry the map has for it, so it follows the device table, a chord with what was held for it, and the raw control when the player has left nothing naming it.

• Mapping an unrecognised controller. A flight stick no controller database knows has only numbered controls. “Map a controller” walks the standard names in turn with the same one line; a press on an unrecognised controller maps the name on that device alone, so the game’s actions, which name Controller.A, play on it, and the mapping is saved with the rest of the player’s rebinds, filed under the device.

• Input.label printing a control, raw or named, the way the hardware counts or names it.

• InputContext(hides=InputContext.ALL) on the rebind screen, so the game stands still while it is open.

• “Reset to defaults” calls InputMap.clear_rebinds(): the player’s changes are one override layer over the bindings the game declared, so dropping it is the whole of a reset, device mappings included.

Controls: WASD / left stick / drawn stick - Move SPACE / pad A - Jump Left click / pad X - Shoot at the cursor TAB / pad Start / Controls - Open the rebind screen (Esc, Tab or Start closes it) ESC / pad Back - Cancel a rebind, or close the screen

Run: simvx examples run features_input_standard_controls Headless self-check: simvx examples run features_input_standard_controls –test

Source

# /// simvx
# tags = ["input", "actions", "rebinding", "keyboard", "mouse", "controller", "touch"]
# web = { width = 960, height = 540, responsive = true }
# ///
"""Standard Controls: move, jump, shoot at the cursor, and rebind any of it.

The controls nearly every game has, written the way SimVX spells them: a
movement action on WASD or the left stick, jump on Space or pad A, shoot on a
left click (at the cursor) or pad X, and a rebind screen with two tables:
the pad's controls (which physical button ``Controller.A`` is) and the actions
(which names ``jump`` answers to). Each cell listens for the next control the
player presses and binds that; its listener claims the press, so choosing
Space for jump does not also jump.

## What it demonstrates
- Actions in ``input_context`` typed by their bindings: ``Axis2D.WASD`` and
  ``Controller.LEFT_STICK`` make ``move`` a ``Vec2``, buttons make ``jump`` and
  ``shoot`` a bool.
- ``@on_input("jump")`` fires once per press; a handler hears a release only
  when it asks with ``edge="release"``.
- ``InputListener``: a cell adds one and binds what it hears in one line,
  ``InputMap.rebind(target, heard)``. Cancelling is the cell's own choice
  (Esc, or whatever the player has made pad Back).
- **Two tables, one map.** A device row rebinds an engine entry,
  ``InputMap.rebind(Controller.A, heard)``, and every action using
  ``Controller.A`` follows; ``InputMap.swap`` turns a pad with A and B the wrong
  way round. An action row binds the press by the engine entry the map has
  for it, so it follows the device table, a chord with what was held for it,
  and the raw control when the player has left nothing naming it.
- **Mapping an unrecognised controller.** A flight stick no controller
  database knows has only numbered controls. "Map a controller" walks the
  standard names in turn with the same one line; a press on an unrecognised
  controller maps the name on that device alone, so the game's actions, which
  name ``Controller.A``, play on it, and the mapping is saved with the rest of
  the player's rebinds, filed under the device.
- ``Input.label`` printing a control, raw or named, the way the hardware
  counts or names it.
- ``InputContext(hides=InputContext.ALL)`` on the rebind screen, so the game
  stands still while it is open.
- "Reset to defaults" calls ``InputMap.clear_rebinds()``: the player's changes
  are one override layer over the bindings the game declared, so dropping it
  is the whole of a reset, device mappings included.

Controls:
  WASD / left stick / drawn stick  - Move
  SPACE / pad A                    - Jump
  Left click / pad X               - Shoot at the cursor
  TAB / pad Start / Controls       - Open the rebind screen (Esc, Tab or Start closes it)
  ESC / pad Back                   - Cancel a rebind, or close the screen

Run: simvx examples run features_input_standard_controls
Headless self-check: simvx examples run features_input_standard_controls --test
"""

from simvx.core import (
    Anchor,
    Axis2D,
    BindingRole,
    CanvasLayer,
    Colour,
    ControlInput,
    Controller,
    DeviceType,
    Input,
    InputContext,
    InputListener,
    InputMap,
    Key,
    Label,
    Mouse,
    Node2D,
    Panel,
    Vec2,
    on_input,
)
from simvx.core.ui import Button, HBoxContainer, TouchController, VBoxContainer
from simvx.graphics import App

SPEED = 240.0
JUMP_SPEED = 420.0
GRAVITY = 1400.0
BULLET_SPEED = 600.0

#: What each column of the rebind screen listens to: the keyboard and mouse
#: column, and the pad column. A source's slot is its position in the
#: action's list below, so the columns line up with it.
DESK = (DeviceType.KEYBOARD, DeviceType.MOUSE)
PAD = (DeviceType.CONTROLLER,)

#: The pad's engine entries the device table shows: the ones this game binds,
#: and Back, which cancels a rebind.
PAD_ENTRIES = (Controller.A, Controller.B, Controller.X, Controller.Y, Controller.START, Controller.BACK)

#: What mapping a controller walks through: the buttons above, then the stick
#: the game moves with, one axis at a time.
MAPPED_NAMES = (*PAD_ENTRIES, Controller.LEFT_X, Controller.LEFT_Y)


def cancels(raw) -> bool:
    """Whether the press *raw* cancels a rebind: Esc, or whatever the pad's Back is now."""
    return raw is Key.ESCAPE or raw == InputMap.resolve(Controller.BACK)


class Player(Node2D):
    """A disc that walks on the ground plane and hops off it."""

    dynamic = True

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.height = 0.0  # how far above its shadow the disc is
        self.lift = 0.0

    def jump(self) -> None:
        if self.height == 0.0:
            self.lift = JUMP_SPEED

    def on_fixed_update(self, dt: float) -> None:
        if self.height > 0.0 or self.lift > 0.0:
            self.height = max(0.0, self.height + self.lift * dt)
            self.lift -= GRAVITY * dt
            if self.height == 0.0:
                self.lift = 0.0

    def on_draw(self, renderer) -> None:
        renderer.circle((0, 0), 18, fill=(1.0, 1.0, 1.0, 0.12))  # the shadow
        renderer.circle((0, -self.height), 18, fill=(0.4, 0.8, 1.0, 1.0))


class Bullet(Node2D):
    """A shot flying in a straight line until it leaves the screen."""

    dynamic = True

    def __init__(self, velocity: Vec2, **kwargs):
        super().__init__(**kwargs)
        self.velocity = velocity

    def on_update(self, dt: float) -> None:
        self.position += self.velocity * dt
        width, height = self.viewport_size
        if not (-20 <= self.position.x <= width + 20 and -20 <= self.position.y <= height + 20):
            self.destroy()

    def on_draw(self, renderer) -> None:
        renderer.circle((0, 0), 5, fill=(1.0, 0.8, 0.3, 1.0))


def bound(action: str, slot: int, role: BindingRole):
    """What the player sees bound in one row: the whole source, or one direction of it."""
    source = InputMap.get_sources(action)[slot]
    return source if role is BindingRole.WHOLE else getattr(source, role.value)


class RebindButton(Button):
    """One cell of the rebind screen: press it, then press the control it should be.

    *target* is an action's name, whose *slot* and *role* the cell rebinds, or
    an engine entry such as ``Controller.A``, which the cell points at a raw
    control.
    """

    def __init__(self, target, devices, *, slot: int = 0, role=BindingRole.WHOLE, **kwargs):
        super().__init__(**kwargs)
        self.target, self.devices, self.slot, self.role = target, devices, slot, BindingRole(role)
        self.listener: InputListener | None = None
        self.pressed.connect(self.listen)

    def on_ready(self) -> None:
        self.refresh()

    def refresh(self) -> None:
        if self.listener is not None:
            self.text = "press..."
        elif isinstance(self.target, str):
            self.text = Input.label(bound(self.target, self.slot, self.role))
        else:
            raw = InputMap.resolve(self.target)
            self.text = Input.label(raw) if raw is not None else "unbound"

    def listen(self) -> None:
        if self.listener is not None:  # a second click cancels
            self.listener.destroy()
            self.listener = None
        else:
            self.listener = self.add_child(InputListener(devices=self.devices))
            self.listener.heard.connect(self.captured)
        self.refresh()

    def captured(self, heard: ControlInput) -> None:
        self.listener = None
        if not cancels(heard.control):
            InputMap.rebind(self.target, heard, slot=self.slot, role=self.role)
        self.screen.refresh()

    @property
    def screen(self) -> RebindScreen:
        node = self.parent
        while not isinstance(node, RebindScreen):
            node = node.parent
        return node


class MappingWalk(Node2D):
    """Map a controller: ask for each standard name in turn and map the press onto that device.

    A mapping screen for a controller no database recognised, a flight stick
    say, walks every name the game needs; the listener hands back the raw
    control, and pinning it to the device the press came from maps it there
    alone. Esc stops the walk, keeping what was mapped so far.
    """

    def __init__(self, status: Label, **kwargs):
        super().__init__(**kwargs)
        self.status = status
        self.remaining = list(MAPPED_NAMES)
        self.mapped: dict[object, object] = {}

    def on_ready(self) -> None:
        self.ask()

    def ask(self) -> None:
        if not self.remaining:
            self.status.text = f"Mapped {len(self.mapped)} controls"
            self.destroy()
            return
        name = self.remaining[0]
        verb = "Push the stick along" if name in (Controller.LEFT_X, Controller.LEFT_Y) else "Press"
        self.status.text = f"{verb} {Input.label(name)} on the controller to map (Esc stops)"
        listener = self.add_child(InputListener(devices=(DeviceType.KEYBOARD, *PAD)))
        listener.heard.connect(self.heard)

    def heard(self, heard: ControlInput) -> None:
        if heard.control is Key.ESCAPE:
            self.status.text = f"Stopped; mapped {len(self.mapped)} controls"
            self.destroy()
            return
        if heard.device_id not in Input.controllers:
            self.ask()  # a key that is not Esc: ask again
            return
        name = self.remaining.pop(0)
        self.mapped[name] = InputMap.rebind(name, heard).binding
        self.ask()


class RebindScreen(CanvasLayer):
    """The pad's controls and the actions' bindings, one cell per thing a player can rebind."""

    #: Everything the game binds is hidden while the screen is open; "close" is its own.
    input_context = InputContext(
        {"close": [Key.TAB, Key.ESCAPE, Controller.START, Controller.BACK]},
        name="rebind screen",
        hides=InputContext.ALL,
    )

    def __init__(self, drawn_pad: TouchController | None = None, **kwargs):
        super().__init__(**kwargs)
        #: The on-screen pad, put away while the screen is open so it neither
        #: covers the tables nor takes a click meant for them.
        self.drawn_pad = drawn_pad

    def on_exit_tree(self) -> None:
        if self.drawn_pad is not None:
            self.drawn_pad.visible = True

    ACTION_ROWS = (
        ("Jump", "jump", BindingRole.WHOLE),
        ("Shoot", "shoot", BindingRole.WHOLE),
        ("Move up", "move", BindingRole.UP),
        ("Move down", "move", BindingRole.DOWN),
        ("Move left", "move", BindingRole.LEFT),
        ("Move right", "move", BindingRole.RIGHT),
    )

    def on_ready(self) -> None:
        if self.drawn_pad is not None:
            self.drawn_pad.visible = False
        panel = self.add_child(Panel(name="Panel", anchor=Anchor.FULL_RECT, inset=24))
        panel.bg_colour = Colour.hex("#1A1A2E")
        page = panel.add_child(VBoxContainer(name="Page", anchor=Anchor.FULL_RECT, inset=(18, 12)))
        page.separation = 8.0
        page.add_child(Label("Pick a cell, then press the control it should be (Esc or Back cancels)"))
        tables = page.add_child(HBoxContainer(name="Tables"))
        tables.separation = 24.0
        self.cells: dict[object, RebindButton] = {}

        # The device table: which raw button each of the pad's controls is.
        pad = tables.add_child(VBoxContainer(name="Pad"))
        pad.separation = 6.0
        pad.add_child(Label("Pad controls"))
        for control in PAD_ENTRIES:
            row = pad.add_child(HBoxContainer(name=f"Pad {control}"))
            row.add_child(Label(Input.label(control))).size = Vec2(70, 28)
            cell = row.add_child(RebindButton(control, PAD, name=f"entry {control}"))
            cell.size = Vec2(130, 28)
            self.cells[control] = cell
        pad.add_child(Button("Swap A and B", on_press=self.swap_ab, name="Swap")).size = Vec2(200, 28)
        pad.add_child(Button("Map a controller", on_press=self.map_controller, name="Map")).size = Vec2(200, 28)
        self.status = page.add_child(Label("", name="Status"))
        self.walk: MappingWalk | None = None

        # The action table: which names each action answers to, keyboard and pad.
        actions = tables.add_child(VBoxContainer(name="Actions"))
        actions.separation = 6.0
        actions.add_child(Label("Actions"))
        for title, action, role in self.ACTION_ROWS:
            row = actions.add_child(HBoxContainer(name=f"Row {title}"))
            row.separation = 8.0
            row.add_child(Label(title)).size = Vec2(110, 28)
            for slot, devices in enumerate((DESK, PAD)):
                if role is not BindingRole.WHOLE and slot == 1:
                    # The pad half of move is a whole stick: it reads, it is not rebound here.
                    row.add_child(Label(Input.label(bound(action, 1, BindingRole.WHOLE)))).size = Vec2(130, 28)
                    continue
                cell = row.add_child(
                    RebindButton(action, devices, slot=slot, role=role, name=f"{action} {role} {slot}")
                )
                cell.size = Vec2(130, 28)
                self.cells[(action, slot, role)] = cell

        footer = page.add_child(HBoxContainer(name="Footer"))
        footer.add_child(Button("Reset to defaults", on_press=self.reset, name="Reset")).size = Vec2(180, 30)
        footer.add_child(Button("Close", on_press=self.destroy, name="Close")).size = Vec2(120, 30)

    def refresh(self) -> None:
        for cell in self.cells.values():
            cell.refresh()

    def map_controller(self) -> None:
        if self.walk is None or self.walk.tree is None:
            self.walk = self.add_child(MappingWalk(self.status, name="MappingWalk"))

    def swap_ab(self) -> None:
        InputMap.swap(Controller.A, Controller.B)
        self.refresh()

    def reset(self) -> None:
        InputMap.clear_rebinds()
        self.refresh()

    @on_input("close")
    def close(self, event) -> None:
        self.destroy()


class Game(Node2D):
    """Walk, hop and shoot at the cursor; open the rebind screen with Tab."""

    input_context = {
        "move": [Axis2D.WASD, Controller.LEFT_STICK],
        "jump": [Key.SPACE, Controller.A],
        "shoot": [Mouse.LEFT, Controller.X],
        "controls": [Key.TAB, Controller.START],
    }

    def on_ready(self) -> None:
        width, height = self.viewport_size
        self.player = self.add_child(Player(name="Player", position=(width / 2, height / 2)))
        self.screen: RebindScreen | None = None
        hud = self.add_child(CanvasLayer(name="HUD"))
        hud.add_child(
            Button(
                "Controls",
                on_press=self.open_controls,
                name="Controls",
                anchor=Anchor.TOP_RIGHT,
                inset=12,
                size=(128, 32),
            )
        )
        self.drawn_pad = self.add_child(TouchController())

    def on_update(self, dt: float) -> None:
        self.player.position += Input.value("move") * SPEED * dt

    @on_input("jump")
    def jump(self, event) -> None:
        self.player.jump()

    @on_input("shoot")
    def shoot(self, event) -> None:
        aim = Input.mouse_position - self.player.position
        if aim.length() > 0:
            self.add_child(Bullet(aim.normalized() * BULLET_SPEED, position=self.player.position))

    @on_input("controls")
    def open_controls(self, event=None) -> None:
        if self.screen is None or self.screen.tree is None:
            self.screen = self.add_child(RebindScreen(self.drawn_pad, name="RebindScreen"))


def _selftest() -> bool:
    """Headless: play, rebind through the listener, and play on the new bindings.

    Every input goes through the real router, as a window would deliver it:
    keys and clicks through the simulator, the pad through a simulated device.
    """
    from simvx.core.testing import InputSimulator, SceneRunner

    runner = SceneRunner(screen_size=(960, 540)).load(Game(name="Game"))
    game, sim = runner.tree.root, InputSimulator(runner.tree)

    def step(count: int = 1) -> None:
        runner.advance_frames(count, draw=True)

    imap = runner.tree.input_map  # outside the tree's own code, InputMap is the process-wide one
    step()
    ok = True

    def check(label: str, passed: bool, detail: object = "") -> None:
        nonlocal ok
        ok = ok and passed
        print(f"{'ok  ' if passed else 'FAIL'} {label}: {detail}")

    def hold(key, frames: int = 10) -> None:
        sim.press_key(key)
        step(frames)
        sim.release_key(key)
        step()

    def jumped(action) -> bool:
        """Whether *action* made the player leave the ground, letting the hop finish after."""
        game.player.height = game.player.lift = 0.0
        action()
        step(2)
        up = game.player.height > 0.0
        step(60)
        return up

    def click(widget) -> None:
        sim.click(tuple(widget.to_global(widget.size / 2)))
        step()

    def cell(target, slot: int = 0, role=BindingRole.WHOLE) -> RebindButton:
        cells = game.screen.cells
        return cells[target] if not isinstance(target, str) else cells[(target, slot, BindingRole(role))]

    start = Vec2(game.player.position)
    hold(Key.D)
    check("D moves the player right", game.player.position.x > start.x + 20, game.player.position)
    check("Space jumps", jumped(lambda: sim.tap_key(Key.SPACE)))
    check("pad A jumps", jumped(lambda: sim.tap_controller(Controller.A)))

    # A click where the drawn stick is: the pad answers fingers only, so the
    # click is the game's, and the pad takes no focus from it.
    stick = game.drawn_pad.find("LeftStick")
    target = stick.to_global(stick.size / 2)
    sim.click((float(target.x), float(target.y)))
    step()
    bullets = [c for c in game.children if isinstance(c, Bullet)]
    aim = (Vec2(target) - game.player.position).normalized()
    check(
        "a click shoots at the cursor, even where the pad is drawn",
        len(bullets) == 1 and bullets[0].velocity.normalized().dot(aim) > 0.99,
        bullets[0].velocity if bullets else "no bullet",
    )

    # The rebind screen: Tab opens it (nothing has focus, so Tab is the game's),
    # and the game stands still behind it.
    sim.tap_key(Key.TAB)
    step()
    check("Tab opens the rebind screen", game.screen is not None and game.screen.tree is not None)
    before = Vec2(game.player.position)
    hold(Key.D)
    check("the game stands still behind the screen", game.player.position.x == before.x, game.player.position)

    # Keyboard column: click the jump cell, press J. J binds and does not jump.
    click(cell("jump", 0))
    step()
    check("clicking a cell listens", cell("jump", 0).listener is not None, cell("jump", 0).text)
    game.player.height = game.player.lift = 0.0
    sim.tap_key(Key.J)
    step(2)
    check("the heard key does not also jump", game.player.height == 0.0, game.player.height)
    check("J is bound to jump", imap.get_sources("jump")[0].control is Key.J, imap.get_sources("jump"))
    check("the cell reads the new binding", cell("jump", 0).text == "J", cell("jump", 0).text)

    # Pad column: the press is bound by the entry naming it, Controller.Y, and the
    # keyboard's slot is left alone.
    click(cell("jump", 1))
    step()
    sim.tap_controller(Controller.Y)
    step()
    check(
        "pad Y is bound to jump's pad slot, by name",
        [s.control for s in imap.get_sources("jump")] == [Key.J, Controller.Y],
        imap.get_sources("jump"),
    )

    # The device table: Controller.Y is now the physical button the pad calls X,
    # and jump, which names Controller.Y, follows it.
    check("the device table reads the raw button", cell(Controller.Y).text == "Button 4", cell(Controller.Y).text)
    click(cell(Controller.Y))
    step()
    sim.tap_controller(Controller.X)
    step()
    check(
        "Controller.Y is pad button 2 now",
        imap.resolve(Controller.Y) is Controller.button(2),
        imap.resolve(Controller.Y),
    )
    check("its cell says so", cell(Controller.Y).text == "Button 3", cell(Controller.Y).text)
    check(
        "nothing names pad button 3 any more",
        imap.aliases(Controller.button(3)) == (),
        imap.aliases(Controller.button(3)),
    )

    # A backwards pad: one press of Swap turns A and B round.
    click(game.screen.find("Swap"))
    check(
        "Swap A and B",
        imap.resolve(Controller.A) is Controller.button(1) and imap.resolve(Controller.B) is Controller.button(0),
        (imap.resolve(Controller.A), imap.resolve(Controller.B)),
    )

    # One direction of move, through its role.
    click(cell("move", 0, BindingRole.RIGHT))
    step()
    sim.tap_key(Key.L)
    step()
    right = imap.get_sources("move")[0].right
    check("L is move right", right.control is Key.L, right)

    # Esc cancels: shoot keeps its click.
    click(cell("shoot", 0))
    step()
    sim.tap_key(Key.ESCAPE)
    step()
    check("Esc cancels a rebind", imap.get_sources("shoot")[0].control is Mouse.LEFT, imap.get_sources("shoot"))
    check("and leaves the screen open", game.screen.tree is not None)

    step()  # the first Esc's release, which a tap sends on the next frame
    sim.tap_key(Key.ESCAPE)
    step()
    check("Esc closes the screen", game.screen.tree is None)

    # Play on the new bindings.
    check("J jumps now", jumped(lambda: sim.tap_key(Key.J)))
    check("Space does not", not jumped(lambda: sim.tap_key(Key.SPACE)))
    check("the button the pad calls X jumps now", jumped(lambda: sim.tap_controller(Controller.X)))
    check("the one it calls Y does not", not jumped(lambda: sim.tap_controller(Controller.Y)))
    start = Vec2(game.player.position)
    hold(Key.L)
    check("L moves right", game.player.position.x > start.x + 20, game.player.position)

    # A flight stick no controller database knows: numbered controls only, so
    # the game's actions, which name Controller.X and the left stick, hear
    # nothing from it until the player maps it.
    def stick(buttons=None, axes=None):
        return sim.set_controller(
            7, recognised=False, name="Flight Stick", guid="flight-stick", buttons=buttons or {}, axes=axes or {}
        )

    flight = stick()
    check("the stick is not recognised", not flight.recognised, flight)
    sim.tap_key(Key.TAB)
    step()
    click(game.screen.find("Map"))
    step()
    raw_buttons = dict(zip(PAD_ENTRIES, (5, 6, 7, 8, 9, 10), strict=True))
    for name in MAPPED_NAMES:
        if name in raw_buttons:
            stick(buttons={raw_buttons[name]: True})
            step()
            stick(buttons={raw_buttons[name]: False})
        else:
            axis = 0 if name is Controller.LEFT_X else 1
            stick(axes={axis: 0.9})
            step()
            stick(axes={axis: 0.0})
        step()
    check(
        "the walk mapped every name",
        game.screen.status.text == f"Mapped {len(MAPPED_NAMES)} controls",
        game.screen.status.text,
    )
    check(
        "Controller.X is the stick's button 7 there alone",
        imap.resolve(Controller.X.on(flight)) == Controller.button(7).on(flight)
        and imap.resolve(Controller.X) is Controller.button(2),
        imap.resolve(Controller.X.on(flight)),
    )
    check(
        "and the stick's button 7 is called X",
        imap.aliases(Controller.button(7).on(flight)) == (Controller.X,),
        imap.aliases(Controller.button(7).on(flight)),
    )
    check(
        "the mapping is saved under the device",
        "flight-stick" in imap.export().get("devices", {}),
        sorted(imap.export().get("devices", {})),
    )
    sim.tap_key(Key.ESCAPE)
    step()

    # Jump's pad slot names Controller.Y, which the stick maps to its button 8.
    def press_stick(index):
        stick(buttons={index: True})
        step()
        stick(buttons={index: False})

    check("Esc closed the screen", game.screen.tree is None)

    check("the stick's mapped Y jumps", jumped(lambda: press_stick(raw_buttons[Controller.Y])))
    start = Vec2(game.player.position)
    stick(axes={0: 0.9})
    step(10)
    stick(axes={0: 0.0})
    step()
    check("the stick's mapped axis moves the player", game.player.position.x > start.x + 20, game.player.position)

    # Reset to defaults drops every rebind: the declared bindings are back,
    # the pad's A and B are the right way round, and the stick's mapping is gone.
    sim.tap_key(Key.TAB)
    step()
    click(game.screen.find("Reset"))
    check(
        "Reset restores jump's declared bindings",
        [s.control for s in imap.get_sources("jump")] == [Key.SPACE, Controller.A],
        imap.get_sources("jump"),
    )
    check(
        "and the pad's entries",
        imap.resolve(Controller.A) is Controller.button(0) and imap.resolve(Controller.Y) is Controller.button(3),
        (imap.resolve(Controller.A), imap.resolve(Controller.Y)),
    )
    check("and nothing is left to save", not imap.export().get("devices"), imap.export())
    check("the cells read the defaults", cell("jump", 0).text == "Space", cell("jump", 0).text)
    sim.tap_key(Key.ESCAPE)
    step()
    check("Space jumps again", jumped(lambda: sim.tap_key(Key.SPACE)))
    check("J does not", not jumped(lambda: sim.tap_key(Key.J)))

    print("SELFTEST:", "PASS" if ok else "FAIL")
    return ok


if __name__ == "__main__":
    import sys

    if "--test" in sys.argv:
        sys.exit(0 if _selftest() else 1)
    App(title="Standard Controls", width=960, height=540).run(Game())