Keybinds & Toggles

onKeyDown / onKeyUp / onMouseDown / onMouseUp — 28 fixed key binds that drive socket control, building actions, and one-press toggles, all gated behind a single guard clause.

Banshee's manual is upfront about one thing: "Keybinds are fixed and cannot be changed. These may vary depending on your Keyboard Layout" — which is why the switch below is keyed on e.code (the physical key position, e.g. BracketLeft) rather than e.key (the character it produces). On a US QWERTY layout BracketLeft is [; on the AZERTY layout the manual was written for, the same physical key produces è — hence the manual lists keys like è, ò, à, and ù for what this page calls BracketLeft, Slash, Quote, and Backslash.

The shared guard clause

Every key handler opens with the same two checks: bail on key-repeat or when you're not actually in the world, and skip entirely while focus is inside a text input — so typing in chat or a settings field never accidentally fires a bot toggle:

script.js — onKeyDown guard

onKeyDown(e) {
    if (e.repeat || !game.world.inWorld) return;
    if (document.activeElement.tagName.toLowerCase() !== "input" && document.activeElement.tagName.toLowerCase() !== "textarea") {
        switch (e.code) {
            // … 28 cases
        }
    }
}

Full key reference

Cross-referenced against BansheeFunctions.txt [28] — manual quotes are paraphrased to fit the table; standout ones get their own code excerpt below.

`e.code`	Manual symbol	Name	What it does
`BracketLeft`	`è`	Leave Party	Sends `LeaveParty` for your main player ("the party must have at least 2 players")
`BracketRight`	`+`	Join Alt	"Join a random Socket's party" — every alt without a gold stash (`!sockets[i].gs`) rejoins via its cached `psk`
`KeyJ`	`J`	Join Alts	"The first three Sockets join your party" — loops `sockets[1]`–`sockets[3]` specifically
`KeyH`	`H`	Leave Alts	"All Sockets leave their parties"
`KeyM`	`M`	Equip Pet	"Your player and your Sockets equip their pet… allows Pressure Bug into enemy bases" — equips whichever pet `this.petToSpawn` currently points at
`KeyN`	`N`	Revive Pet	Toggles `autorevivepets` for player + sockets
`KeyV`	`V`	Sell Pet	"Your player and your Sockets sell their pet" — `DeleteBuilding` on each pet's `uid`
`KeyX`	`X`	Upgrade All	"Your player auto upgrades all buildings, except the Gold Stash" — flips `upgradeall` and seeds `upgradeTicks = 9`
`KeyG`	`G`	Auto Follow	"Your player auto follows enemy players" — toggles `autofollow`
`KeyK`	`K`	Clear Chat	Toggles `clearchat` (removes `hud-chat-message` nodes every tick)
`KeyL`	`L`	Send Alt	"Send a Socket into the server" — `new Alt()`, see multibox lifecycle
`KeyQ`	`Q`	Switch Weapon	"Your player and your Sockets equip their next weapon" — walks the fixed order `Pickaxe → Spear → Bow → Bomb` and equips the next one each socket actually owns
`KeyR`	`R`	Upgrade On Alt	"Select a Building and upgrade it on a Socket. The Socket needs to have resources" — relays `UpgradeBuilding` for the selected (or "upgrade all of this type/tier") building to every socket
`KeyY`	`Y`	Sell On Alt	"Select a Building and sell it on a Socket. The Socket needs to have sell perms" — same selection logic as `R` but sends `DeleteBuilding`; explicitly excludes `GoldStash`
`KeyZ`	`Z`	Auto Bow	"Your player and your Sockets auto attack" — toggles `autobow`, see Auto Bow
`Minus`	`-`	Place Gold Stash	Opens the placement overlay for a new `GoldStash` (`startPlacing`)
`Backquote`	`	Show Player Info	Toggles `showrss`; on disable, walks `window.pEntities` restoring every nameplate's original `name` from `oldName` so the overlay leaves no trace
`Slash`	`ò` *	Mouse Move	"Your Sockets automatically move to your mouse. Disabled by default" — toggles `mousemove`; turning it off also zeroes every socket's movement packet so they don't keep walking
`KeyP`	`P`	Position Lock	"Your Sockets automatically stick to a set position by your mouse" — toggles `positionlock`, see multibox tick loop
`Semicolon`	—	WASD Movement	"Your Sockets copy your movement with the WASD keys" — toggles `wasd` (gates the `KeyW/A/S/D` handlers below)
`Quote`	`à`	Switch Pet	"Your player and your Sockets can switch between equipping a CARL or a Woody" — flips `petToSpawn` between `"PetCARL"`/`"PetMiner"` for the next `M` press
`KeyW` / `KeyA` / `KeyS` / `KeyD`	—	WASD relay	Active only when `wasd` is on and `mousemove` is off — relays directional input packets to every live socket on key-down, and zeroes them on key-up (in `onKeyUp`)
`Period`	`.`	Attack On Alt	"The nearest Socket to your mouse starts attacking. The Socket heals to full health for the most damage… useful for Multibox raiding"
`Comma`	`,`	Heal Spam	"Your player and your Sockets cast all their Heal Spells on your mouse position. Useful for blocking the vision of enemy players" — `CastSpell HealTowersSpell` at `mousePs`
`IntlBackslash`	`<`	Hit On Alt	"The nearest Socket to your mouse hits one time… alternate this on multiple Sockets and bypass the cooldown that makes towers attack you… called L Key"
`KeyI`	`I`	Show Wall Ranges	"Shows the range where you can't place Harvesters near enemy bases… have a 7x7 grid diameter" — proxies a click onto the game's own walkthrough button (`hud-FPS-restart-walkthrough[8]`) to flip its built-in grid overlay
`KeyU`	`U`	Join Delay	"Delays Sockets from joining the server… up to 15 seconds… can bypass Auto Refiller" — toggles `joindelay`, which makes new alts wait at the opcode-5 stage instead of completing their handshake immediately
`AltRight`	Alt Gr	Send Delayed Alts	"Send the Sockets you've delayed from joining the server" — releases every alt that's been waiting at the `opcode5Ids` gate, all at once
`Backslash`	`ù`	Session Switcher	"Toggles the menu to switch Sessions in game… you can then also switch to other VPS IPs" — only available while `user.connectedToId` is set; toggles `sesswitcher`

* manual lists this physical key as ò on AZERTY; e.code is layout-independent

Multibox raiding: Attack/Hit On Alt

. (Period) and < (IntlBackslash) are the two key binds the manual flags explicitly for PvP/raiding, and they both work the same way: find whichever cached "nearest alt" is closest to your cursor (this.nearestAlts, refreshed every tick by the Auto Aim distance scan) and fire a single, debounced action on it — rather than spamming every socket at once, which would trip the game's per-tower hit-rate limit:

script.js — Period: full-heal-then-attack on the nearest alt

case "Period":
    for (let i in this.nearestAlts) {
        const oldSocket = this.nearestAlts[i];
        if (oldSocket && !oldSocket.mouseDownHit) {
            oldSocket.mouseDownHit = 1;
            oldSocket.sendPacket(9, { name: "EquipItem", itemName: "HealthPotion", tier: 1 });
            oldSocket.timeout1Ticks = 1;
            oldSocket.timeout2Ticks = 1;
            oldSocket.timeout3Ticks = 1;
        }
    }
    break;

Setting the three timeoutNTicks counters to 1 hands control to the Alt's own onEntityUpdate — which counts each one up and, on expiry, fires mouseDown (after 2 ticks), mouseUp (after 140 ticks), and clears mouseDownHit (after 142 ticks). In other words, this key bind doesn't attack directly — it loads a tiny three-stage timer onto the chosen alt that equips a health potion, waits, swings, waits again, then resets — so a player can tap . across several alts in sequence and chain full-health attacks without the game's tower-aggro cooldown ever catching up to any single one of them.

script.js — IntlBackslash: a single debounced hit, cooldown-bypass

case "IntlBackslash":
    for (let i in this.nearestAlts) {
        const nearestAlt = this.nearestAlts[i];
        if (nearestAlt && !nearestAlt.hasHit) {
            nearestAlt.hasHit = true;
            nearestAlt.hitTicks = 0;
            nearestAlt.sendPacket(3, { mouseDown: nearestAlt.aimingYaw });
        }
    }
    break;

Here the debounce is hasHit/hitTicks: the tick loop counts to 5 and then fires mouseUp, clearing the flag. The manual spells out exactly why this matters: "You can hit a tower five times in one minute. With multiple towers, this number is divided… this alternating strategy[ is] called L Key" — i.e. round-robin single hits across many alts adds up to far more total damage per minute than the game's per-character rate limit would allow any one of them alone.

Join Delay — staging a wave of alts

U and Alt Gr work as a pair to implement the manual's "send several Sockets at once in an instant… can bypass Auto Refiller" trick. With joindelay on, a freshly-spawned alt completes its anti-bot handshake (opcode 5, see multibox — routing the WebSocket) but is held at the gate — its wid/answer pair sits in opcode5Ids and it's marked unverified. Alt Gr then walks every held alt and releases them all in the same instant:

script.js — AltRight: release every delayed Alt at once

case "AltRight":
    if (!this.scripts.joindelay || Object.keys(sockets).length !== Object.keys(opcode5Ids).length) return;
    Object.values(sockets).find((ee) => {
        if (opcode5Ids[ee.wid] && !ee.verified) {
            const altData = opcode5Ids[ee.wid];
            ee.sendPacket(4, { displayName: altData[0], extra: altData[1] });
            ee.verified = true;
        }
    });
    break;

The guard Object.keys(sockets).length !== Object.keys(opcode5Ids).length is a readiness check — it refuses to fire until every currently-open socket has actually finished its anti-bot exchange and has an entry in opcode5Ids, so a half-loaded alt can't be released into the world without its display name and challenge answer ready to send.

Mouse buttons — scatter & attack relay

onMouseDown/onMouseUp aren't documented as standalone key binds in the manual, but they're load-bearing: right-click is the live trigger for the "scatter" evasive-movement behavior referenced throughout the multibox tick loop (held down → every alt scrambles; released → they resume normal pathing), and left-click is a blanket attack relay that fires mouseDown/mouseUp on every live socket using its own current aimingYaw:

script.js — onMouseDown / onMouseUp

onMouseDown(e) {
    if (e.button === 2) {
        this.scatter = true;
        for (let i in sockets) {
            if (sockets[i].myPlayer) sockets[i].scatter = true;
        }
    }
    if (!e.button) {
        for (let i in sockets) {
            if (sockets[i].myPlayer) sockets[i].sendPacket(3, { mouseDown: sockets[i].aimingYaw });
        }
    }
}

See also: The toggle system for how these flags persist between sessions, and Multibox (Sockets / Alts) for the Alt internals every one of these key binds ultimately drives.