@amxts/core 0.1.0 → 0.2.1

package/as/facade.ts

@@ -5,7 +5,7 @@
 // includes/*.inc as Pawn sees it, and the bridge natives that
 // runtime/src/module.cpp registers by hand for the places where a string
 // crossing as UTF-16 is worth a purpose-built thunk. Both are direct calls —
-// an import whose signature wamrc knows costs 2 ns.
+// an import whose signature wamrc knows is far cheaper than its generic call.
 //
 // The `// @ts-ignore: decorator` lines are AssemblyScript's own idiom, used
 // throughout its standard library: an editor reading this as TypeScript would
@@ -32,7 +32,9 @@ import {
 	set_dhudmessage, show_dhudmessage, CreateHudSyncObj, ShowSyncHudMsg, ClearSyncHud,
 	precache_model, precache_sound, precache_generic, query_client_cvar, register_touch,
 	register_message, get_msg_args, get_msg_argtype, get_msg_arg_int, get_msg_arg_float, get_msg_arg_string,
-	set_msg_arg_int, set_msg_arg_float, set_msg_arg_string
+	set_msg_arg_int, set_msg_arg_float, set_msg_arg_string, get_user_userid,
+	emessage_begin, ewrite_byte, ewrite_short, ewrite_string, emessage_end, elog_message,
+	has_reunion, REU_GetAuthtype, REU_GetProtocol, REU_GetAuthKey, DisableHamForward, EnableHamForward
 } from "./natives";
 // Promise, async/await and AbortSignal, as the globals they are in JavaScript.
 import "./promise";
@@ -61,6 +63,8 @@ import { Vector } from "./vector";
 // @ts-ignore: decorator
 @external("env", "slot")         declare function _slot(fn: i32, shape: i32, key: string, fallback: i32): i32;
 // @ts-ignore: decorator
+@external("env", "slot_on")      declare function _slotOn(slot: i32, on: i32): void;
+// @ts-ignore: decorator
 @external("env", "arg")          declare function _arg(index: i32): i32;
 // @ts-ignore: decorator
 @external("env", "arg_text")     declare function _argText(index: i32, out: i32, max: i32): i32;
@@ -74,6 +78,34 @@ import { Vector } from "./vector";
 @external("env", "argc")         declare function _argc(): i32;
 // @ts-ignore: decorator
 @external("env", "plugin")       declare function _plugin(name: string, version: string, author: string, description: string): void;
+// @ts-ignore: decorator
+@external("env", "stack_frames") declare function _stackFrames(out: usize, max: i32): i32;
+// @ts-ignore: decorator
+@external("env", "stack_text")   declare function _stackText(frames: usize, count: i32, out: usize, max: i32): i32;
+
+/** The most calls an error's `stack` names. */
+const STACK_FRAMES = 32;
+
+/**
+ * An error's `stack`, from the module: the frames of the calls that made the
+ * error - each function's index and where in it the call is - kept when it
+ * is made, and put into words through the plugin's map only when `stack` is
+ * read.
+ */
+class ModuleStack extends ErrorStack {
+	frames(): StaticArray<u32> {
+		const frames = new StaticArray<u32>(STACK_FRAMES * 2);
+		const count = _stackFrames(changetype<usize>(frames), STACK_FRAMES);
+		return StaticArray.slice<u32>(frames, 0, count * 2);
+	}
+
+	text(frames: StaticArray<u32>): string {
+		const length = _stackText(changetype<usize>(frames), frames.length / 2, changetype<usize>(stackText), stackText.length);
+		return String.UTF8.decodeUnsafe(changetype<usize>(stackText), length);
+	}
+}
+const stackText = new StaticArray<u8>(8192);
+__errorStack = new ModuleStack();
 
 // call_indirect checks the type on the module's side, so a handler's shape is
 // fixed at registration and there are exactly two: this one and WideHandler.
@@ -191,14 +223,22 @@ export function ret(value: number): void {
  * unique within the plugin. `fallback` is the answer when the handler returns
  * nothing: `0` for most natives, `1` where the native expects the event handled.
  *
- * Register from the `"cfg"` event, not at the top of the file: a console
+ * Register from the `"pluginsLoaded"` event, not at the top of the file: a console
  * command registered that early (`register_concmd`, `register_srvcmd`) crashes
  * the server when typed.
  */
 export function publicFor(handler: WideHandler, key: string, fallback: number = 0): string {
-	// Must match SLOT_REUSED in runtime/src/module.cpp.
-	const REUSED: i32 = 0x10000;
+	return __switchedPublic(handler, key, null, fallback);
+}
 
+// Must match SLOT_REUSED in runtime/src/module.cpp.
+const SLOT_REUSED: i32 = 0x10000;
+
+/**
+ * @hidden `publicFor`, the public switched by `hook`: switched off, a call
+ * answers `fallback` in the module, without reaching the plugin.
+ */
+export function __switchedPublic(handler: WideHandler, key: string, hook: __Switch | null, fallback: number = 0): string {
 	const slot = _slot(hostIndex(handler, true), SHAPE_WIDE, key, fallback);
 
 	if (slot < 0) {
@@ -206,7 +246,33 @@ export function publicFor(handler: WideHandler, key: string, fallback: number =
 		return "";
 	}
 
-	return (slot & REUSED) ? "" : `__amxts_cb${slot}`;
+	const index = slot & ~SLOT_REUSED;
+	if (hook != null) hook.add((on: bool): void => _slotOn(index, on ? 1 : 0));
+	return (slot & SLOT_REUSED) ? "" : `__amxts_cb${slot}`;
+}
+
+/**
+ * @hidden A registration with AMX Mod X - a hook, or a public it calls - that
+ * is switched off while what it delivers has no listener and back on for the
+ * next one, so that an event nobody listens to does not reach the plugin.
+ * One switched off before it is made is made switched off.
+ */
+export class __Switch {
+	private on: bool = true;
+	private parts: ((on: bool) => void)[] = [];
+
+	/** Switches every registration of it on or off. */
+	set(on: bool): void {
+		if (on == this.on) return;
+		this.on = on;
+		for (let i = 0; i < this.parts.length; i++) this.parts[i](on);
+	}
+
+	/** What switches one registration, once it is made; run at once while the switch is off. */
+	add(part: (on: bool) => void): void {
+		this.parts.push(part);
+		if (!this.on) part(false);
+	}
 }
 
 // AMX Mod X implements a native as a public in some plugin, so this names the
@@ -350,6 +416,18 @@ export function __nativeVector(index: i32): Vector {
 	return new Vector(pawnFloat(cells[0]), pawnFloat(cells[1]), pawnFloat(cells[2]));
 }
 
+/**
+ * @hidden Writes a `Float:v[3]` argument where it lies: a hookchain's vector,
+ * which reapi copies back into the game's once the listener returns.
+ */
+export function __setNativeVector(index: i32, value: Vector): void {
+	const cells = new StaticArray<i32>(3);
+	unchecked(cells[0] = reinterpret<i32>(<f32>value.x));
+	unchecked(cells[1] = reinterpret<i32>(<f32>value.y));
+	unchecked(cells[2] = reinterpret<i32>(<f32>value.z));
+	_setArgArray(index, changetype<usize>(cells), 3);
+}
+
 // @ts-ignore: decorator
 @external("env", "arg_length") declare function _argLength(index: i32): i32;
 
@@ -890,7 +968,7 @@ export function argString(pointer: number): string {
  * zero cell or `max` cells. AMX Mod X, the engine and the game keep text as
  * bytes - get_amxstring takes the low byte of each cell - so a letter outside
  * ASCII is two or three cells, and a cell per UTF-16 unit came out as
- * mojibake one way and a truncated byte the other ("раз" arrived as "@0").
+ * mojibake one way and a truncated byte the other (a Cyrillic word arrived as "@0").
  */
 export function __cellText(pointer: usize, max: i32): string {
 	let length = 0;
@@ -925,7 +1003,7 @@ export function __cellsOf(text: string): StaticArray<i32> {
 	return cells;
 }
 
-/** Reads the text a raw native from `~/natives` wrote into a cell array. `stringToCells` is the other way. */
+/** Reads the text a raw native from `@amxts/core/natives` wrote into a cell array. `stringToCells` is the other way. */
 export function cellsToString(cells: StaticArray<i32>): string {
 	return __cellText(changetype<usize>(cells), cells.length);
 }
@@ -935,10 +1013,10 @@ export function stringToCells(text: string, cells: StaticArray<i32>): void {
 	__writeCellText(text, cells);
 }
 
-// The natives in ~/natives take addresses, because that is what Pawn pushes: a
+// The natives in @amxts/core/natives take addresses, because that is what Pawn pushes: a
 // string has to be in memory this plugin owns before its address means anything.
 /**
- * Passes a string to a raw native from `~/natives` without declaring a
+ * Passes a string to a raw native from `@amxts/core/natives` without declaring a
  * buffer for it:
  *
  *   cfg_set_base_dir(cells("myplugin"));
@@ -1107,6 +1185,25 @@ export type Team = "TERRORIST" | "CT" | "SPECTATOR" | "UNASSIGNED";
 
 const TEAM_NAMES: Team[] = ["UNASSIGNED", "TERRORIST", "CT", "SPECTATOR"];
 
+/** The way a player's game proves who he is, as Reunion tells it, e.g. `"steam"` or `"revEmu"`; `"unknown"` on a server without Reunion. */
+export type AuthType =
+	| "unknown" | "steam" | "steamEmu" | "revEmu" | "revEmu2013" | "oldRevEmu"
+	| "sc2009" | "avsmp" | "sxei" | "sse3" | "dproto" | "hltv";
+
+// Reunion's client_auth_type, by its number: CA_TYPE_NONE is "unknown".
+const AUTH_TYPES: AuthType[] = [
+	"unknown", "dproto", "steam", "steamEmu", "revEmu", "oldRevEmu",
+	"hltv", "sc2009", "avsmp", "sxei", "revEmu2013", "sse3",
+];
+
+// Reunion's natives exist only when reapi finds Reunion: asked once, as reapi is.
+let reunionHere: i32 = -1;
+
+function hasReunion(): bool {
+	if (reunionHere < 0) reunionHere = __hasReapi() && has_reunion() ? 1 : 0;
+	return reunionHere == 1;
+}
+
 /** A weapon a player can hold, by its class name, e.g. `"weapon_ak47"` or `"weapon_knife"`. */
 export type WeaponName =
 	| "weapon_p228" | "weapon_scout" | "weapon_hegrenade" | "weapon_xm1014" | "weapon_c4"
@@ -1138,21 +1235,9 @@ const WEAPON_IDS = [
 	"weapon_sg552", "weapon_ak47", "weapon_knife", "weapon_p90"
 ];
 
-/**
- * The filter of `Player.all`; every field is optional, e.g.
- * `Player.all({ alive: true, team: "CT" })`.
- */
-export interface PlayerFilter {
-	/** Only living players. */
-	alive?: boolean;
-	/** Only dead players. */
-	dead?: boolean;
-	/** Only players of this team, e.g. `"CT"`. */
-	team?: Team;
-	/** Only bots. */
-	bots?: boolean;
-	/** Only people, no bots. */
-	humans?: boolean;
+/** @hidden Every weapon's class name: what Ham Sandwich hooks a weapon's event on for "every weapon". */
+export function __weaponClassnames(): string[] {
+	return WEAPON_IDS.filter((name) => name.length > 0);
 }
 
 /** An AMX Mod X module a plugin can check for, one of `"reapi"`, `"cstrike"`, `"fun"`, `"hamsandwich"`, `"engine"`, `"fakemeta"`. */
@@ -1178,6 +1263,30 @@ export function hasModule(name: ModuleName): boolean {
 	return loaded;
 }
 
+// The backend the hood picks for a game event, an action or a field of
+// ReGameDLL's own, asked once rather than on every call: 1 reapi, 0 the
+// stock modules, -1 not asked yet.
+let reapiHere: i32 = -1;
+
+/** @hidden Whether the server has reapi: the hood's choice of backend, made once. */
+export function __hasReapi(): bool {
+	if (reapiHere < 0) reapiHere = hasModule("reapi") ? 1 : 0;
+	return reapiHere == 1;
+}
+
+const saidOnce = new Set<string>();
+
+/**
+ * @hidden A line in the console the first time it is said: what this server
+ * cannot do, where a plugin asks for it - not on every call, which a field
+ * read in a frame listener makes every frame.
+ */
+export function __sayOnce(text: string): void {
+	if (saidOnce.has(text)) return;
+	saidOnce.add(text);
+	console.warn(text);
+}
+
 /** Tells everyone's scoreboard a player's frags and deaths - what cs_set_user_deaths sends. */
 function sendScoreInfo(id: number, frags: number, deaths: number, team: number) {
 	message_begin(MSG_ALL, get_user_msgid("ScoreInfo"), [0, 0, 0], 0);
@@ -1195,6 +1304,38 @@ export interface KillOptions {
 	keepFrags?: boolean;
 }
 
+// ---------------------------------------------------------------- bots
+
+import { dllfunc, engfunc, global_get, set_pev } from "./natives";
+import { DLLFunc_ClientConnect, DLLFunc_ClientPutInServer, EngFunc_CreateFakeClient, EngFunc_RunPlayerMove, glb_frametime, pev_health } from "./constants";
+import { BUTTON, Button } from "./flags";
+
+/** How long the server's current frame lasts, in seconds. */
+function frameTime(): f64 {
+	const time = new Ref<f64>(0.0);
+	global_get(glb_frametime, time);
+	return time.value;
+}
+
+/**
+ * One move of a bot, `bot.move({ ... })`: the speeds are units a second, as
+ * a player's keys give them - `250` runs with a knife, `-250` backs away.
+ */
+export interface MoveOptions {
+	/** Forward, or back when negative. */
+	forward?: number;
+	/** To the right, or to the left when negative. */
+	side?: number;
+	/** Up, or down when negative: swimming and climbing a ladder. */
+	up?: number;
+	/** The buttons held during the move: `["jump", "duck"]`. */
+	buttons?: Button[];
+	/** The direction the bot looks in, `[pitch, yaw, roll]` or a Vector; where it looks now when left out. */
+	angles?: number[];
+	/** The move's length in milliseconds, `1` to `255`; the server frame's time when left out. */
+	msec?: number;
+}
+
 // Plugins add fields of their own to this class, shared by every plugin and by
 // Pawn, with `interface Player { spawnProtected: boolean }` in a
 // `declare module "~/facade"` block (docs/en/3.game/02.players.md) - not written
@@ -1202,12 +1343,12 @@ export interface KillOptions {
 // plugin's. The build turns each into a getter and a setter over the module's
 // store and adds them here (scripts/player-fields.ts).
 /**
- * A connecting player, in `"connect"`, `"authorized"` and `"putinserver"`: name,
+ * A connecting player, in `"connect"`, `"authorized"` and `"putInServer"`: name,
  * address, SteamID and team, but no health or weapons yet. Every Player is a
  * Client too.
  *
  * ```ts
- * server.addEventListener("putinserver", (event) => {
+ * server.addEventListener("putInServer", (event) => {
  * 	print(event.player, `Welcome, ${event.player.name}!`);
  * });
  * ```
@@ -1219,13 +1360,19 @@ export interface Client {
 	readonly name: string;
 	/** The player's IP address without the port, e.g. `"192.168.0.10"`. */
 	readonly ip: string;
-	/** The player's SteamID, e.g. `"STEAM_0:1:12345"`. A bot has `"BOT"`, HLTV has `"HLTV"`; until Steam confirms the player it is `"STEAM_ID_PENDING"` (wait for the `"authorized"` event), and on a LAN server `"STEAM_ID_LAN"`. */
-	readonly authid: string;
+	/** The player's SteamID, e.g. `"STEAM_0:1:12345"`. A bot has `"BOT"`, HLTV has `"HLTV"`; until Steam confirms the player it is `"STEAM_ID_PENDING"` (wait for the `"authorized"` event), and on a LAN server `"STEAM_ID_LAN"`. With Reunion a game without Steam gets one made from its key (`authKey`): `"STEAM_..."` or `"VALVE_..."`, as the server's Reunion settings say. */
+	readonly steamId: string;
+	/** The way the player's game proved who he is, as Reunion tells it: one of `"steam"` (a Steam game), `"steamEmu"`, `"revEmu"`, `"revEmu2013"`, `"oldRevEmu"`, `"sc2009"`, `"avsmp"`, `"sxei"`, `"sse3"` (a game without Steam, by the emulator it proved itself with), `"dproto"`, `"hltv"`, or `"unknown"` on a server without Reunion. */
+	readonly authType: AuthType;
+	/** The network protocol of the player's game: `48` for today's game, `47` for an old one Reunion lets in. `0` on a server without Reunion. */
+	readonly protocol: number;
+	/** The key the player's game proved itself with, as Reunion read it: what his SteamID is made from. `""` on a server without Reunion. */
+	readonly authKey: string;
 	/** `true` for a bot. */
 	readonly isBot: boolean;
 	/** `true` while the player is on the server. */
 	readonly isConnected: boolean;
-	/** The player's admin rights, from the letters in `users.ini`: `client.access.includes("Cvar")`. */
+	/** The player's admin rights, from the letters in `users.ini`: `client.access.includes("cvar")`. */
 	readonly access: Access[];
 	/** The player's team, one of `"TERRORIST"`, `"CT"`, `"SPECTATOR"` or `"UNASSIGNED"` (until the player joins a team). Setting it moves the player, as `player.team` does. */
 	team: Team;
@@ -1241,6 +1388,8 @@ export interface Client {
 	readonly signal: AbortSignal;
 	/** Runs a command in the player's console, as if he had typed it: `client.command("stop")`. */
 	command(text: string): void;
+	/** Kicks the player off the server, with the reason he is shown: `client.kick("Spam")`. */
+	kick(reason?: string): void;
 	/** Joins a side as the game joins a player who picks it in the team menu: `client.joinTeam("CT")`. `false` if the game refused. */
 	joinTeam(team: Team): boolean;
 	/** Asks the player's game for one of its cvars: `await client.queryCvar("fps_max")`, the value as text, or `null` when his game has none. */
@@ -1251,7 +1400,7 @@ export interface Client {
  * A player in the game: everything a Client has, plus health, armor, frags,
  * weapons and the screen.
  *
- * An event about a player gives one as `event.player`; `Player.all()`
+ * An event about a player gives one as `event.player`; `server.players`
  * lists everyone on the server.
  */
 export class Player extends PlayerFields implements Client {
@@ -1259,30 +1408,6 @@ export class Player extends PlayerFields implements Client {
 		super(id);
 	}
 
-	/**
-	 * The players on the server: `Player.all({ alive: true })`.
-	 *
-	 * Every field narrows: `{ bots: true }` is bots only, `{ humans: true }`
-	 * people only. Without a filter, everyone connected, never an HLTV proxy.
-	 *
-	 * Pawn: `get_players`
-	 */
-	static all(filter: PlayerFilter = {}): Player[] {
-		let flags = "h";
-		if (filter.alive) flags += "a";
-		if (filter.dead) flags += "b";
-		if (filter.humans) flags += "c";
-		if (filter.bots) flags += "d";
-
-		const team = filter.team;
-		if (team != null) flags += "e";
-
-		const ids = playerIds(flags, team ?? "");
-		const list: Player[] = [];
-		for (let i = 0; i < ids.length; i++) list.push(new Player(ids[i]));
-		return list;
-	}
-
 	/**
 	 * The player's name.
 	 *
@@ -1324,12 +1449,12 @@ export class Player extends PlayerFields implements Client {
 	 * Pawn: `cs_get_user_deaths`, `cs_set_user_deaths`
 	 */
 	get deaths(): number {
-		return hasModule("reapi") ? get_member(this.id, m_iDeaths) : cs_get_user_deaths(this.id);
+		return __hasReapi() ? get_member(this.id, m_iDeaths) : cs_get_user_deaths(this.id);
 	}
 
 	/** The deaths on the scoreboard; setting them tells the scoreboard too. */
 	set deaths(value: number) {
-		if (hasModule("reapi")) {
+		if (__hasReapi()) {
 			set_member(this.id, m_iDeaths, value);
 			sendScoreInfo(this.id, this.frags, value, get_member(this.id, m_iTeam));
 			return;
@@ -1344,7 +1469,7 @@ export class Player extends PlayerFields implements Client {
 	 * Pawn: `cs_get_user_team`, `rg_set_user_team`
 	 */
 	get team(): Team {
-		const index = hasModule("reapi") ? get_member(this.id, m_iTeam) : cs_get_user_team(this.id);
+		const index = __hasReapi() ? get_member(this.id, m_iTeam) : cs_get_user_team(this.id);
 		return index >= 0 && index < TEAM_NAMES.length ? TEAM_NAMES[index] : "UNASSIGNED";
 	}
 
@@ -1355,7 +1480,7 @@ export class Player extends PlayerFields implements Client {
 	 */
 	set team(value: Team) {
 		const index = teamCell(value);
-		if (hasModule("reapi")) {
+		if (__hasReapi()) {
 			rg_set_user_team(this.id, index, MODEL_AUTO, true, false);
 			return;
 		}
@@ -1368,16 +1493,23 @@ export class Player extends PlayerFields implements Client {
 	 * Joins a side the way the game joins a player who picks it in the team
 	 * menu, appearance picked for him: `player.joinTeam("CT")`. A player who
 	 * has just arrived is in the game after it and can spawn, which
-	 * `player.team = ...` does not do for him. `false` if the game refused.
+	 * `player.team = ...` does not do for him. A living player sent to the
+	 * spectators dies quietly: no death, no frag. `false` if the game refused.
 	 *
 	 * Pawn: `rg_join_team`
 	 */
 	joinTeam(team: Team): boolean {
 		if (team == "UNASSIGNED") return false;
-		if (hasModule("reapi")) return rg_join_team(this.id, teamCell(team)) != 0;
+		if (__hasReapi()) return rg_join_team(this.id, teamCell(team)) != 0;
 
 		// Without reapi, what the player would type: the team menu's slot, then
-		// the appearance menu's automatic pick.
+		// the appearance menu's automatic pick. The menu takes a living player
+		// to the spectators only in the freeze time, so he dies quietly first,
+		// as rg_join_team has him: no death, no frag.
+		if (team == "SPECTATOR" && this.isAlive) {
+			this.deadFlag = "dead";
+			set_pev(this.id, pev_health, 0);
+		}
 		engclient_cmd(this.id, "jointeam", team == "TERRORIST" ? "1" : team == "CT" ? "2" : "6");
 		if (team != "SPECTATOR") engclient_cmd(this.id, "joinclass", "5");
 		return this.team == team;
@@ -1395,14 +1527,42 @@ export class Player extends PlayerFields implements Client {
 	}
 
 	/**
-	 * The player's SteamID, e.g. `"STEAM_0:1:12345"`. A bot has `"BOT"`, HLTV has `"HLTV"`; until Steam confirms the player it is `"STEAM_ID_PENDING"` (wait for the `"authorized"` event), and on a LAN server `"STEAM_ID_LAN"`.
+	 * The player's SteamID, e.g. `"STEAM_0:1:12345"`. A bot has `"BOT"`, HLTV has `"HLTV"`; until Steam confirms the player it is `"STEAM_ID_PENDING"` (wait for the `"authorized"` event), and on a LAN server `"STEAM_ID_LAN"`. With Reunion a game without Steam gets one made from its key (`authKey`): `"STEAM_..."` or `"VALVE_..."`, as the server's Reunion settings say.
 	 *
 	 * Pawn: `get_user_authid`
 	 */
-	get authid(): string {
+	get steamId(): string {
 		return get_user_authid(this.id);
 	}
 
+	/**
+	 * The way the player's game proved who he is, as Reunion tells it: one of `"steam"` (a Steam game), `"steamEmu"`, `"revEmu"`, `"revEmu2013"`, `"oldRevEmu"`, `"sc2009"`, `"avsmp"`, `"sxei"`, `"sse3"` (a game without Steam, by the emulator it proved itself with), `"dproto"`, `"hltv"`, or `"unknown"` on a server without Reunion.
+	 *
+	 * Pawn: `REU_GetAuthtype`
+	 */
+	get authType(): AuthType {
+		const type = hasReunion() ? REU_GetAuthtype(this.id) : 0;
+		return type > 0 && type < AUTH_TYPES.length ? AUTH_TYPES[type] : "unknown";
+	}
+
+	/**
+	 * The network protocol of the player's game: `48` for today's game, `47` for an old one Reunion lets in. `0` on a server without Reunion.
+	 *
+	 * Pawn: `REU_GetProtocol`
+	 */
+	get protocol(): number {
+		return hasReunion() ? REU_GetProtocol(this.id) : 0;
+	}
+
+	/**
+	 * The key the player's game proved itself with, as Reunion read it: what his SteamID is made from. `""` on a server without Reunion.
+	 *
+	 * Pawn: `REU_GetAuthKey`
+	 */
+	get authKey(): string {
+		return hasReunion() ? REU_GetAuthKey(this.id) : "";
+	}
+
 	/**
 	 * `true` while the player is alive.
 	 *
@@ -1523,7 +1683,7 @@ export class Player extends PlayerFields implements Client {
 	 * Pawn: `rg_give_item`, `give_item`
 	 */
 	give(item: ItemName): boolean {
-		if (hasModule("reapi")) return rg_give_item(this.id, item) > 0;
+		if (__hasReapi()) return rg_give_item(this.id, item) > 0;
 		return give_item(this.id, item) > 0;
 	}
 
@@ -1534,7 +1694,7 @@ export class Player extends PlayerFields implements Client {
 	 * Pawn: `rg_remove_all_items`, `strip_user_weapons`
 	 */
 	removeAllItems(removeSuit: boolean = false): void {
-		if (hasModule("reapi")) {
+		if (__hasReapi()) {
 			rg_remove_all_items(this.id, removeSuit);
 			return;
 		}
@@ -1549,7 +1709,7 @@ export class Player extends PlayerFields implements Client {
 	setAmmo(weapon: WeaponName, amount: number): void {
 		const id = WEAPON_IDS.indexOf(weapon);
 		if (id <= 0) return;
-		if (hasModule("reapi")) rg_set_user_bpammo(this.id, id, amount);
+		if (__hasReapi()) rg_set_user_bpammo(this.id, id, amount);
 		else cs_set_user_bpammo(this.id, id, amount);
 	}
 
@@ -1562,7 +1722,7 @@ export class Player extends PlayerFields implements Client {
 	getAmmo(weapon: WeaponName): number {
 		const id = WEAPON_IDS.indexOf(weapon);
 		if (id <= 0) return 0;
-		return hasModule("reapi") ? rg_get_user_bpammo(this.id, id) : cs_get_user_bpammo(this.id, id);
+		return __hasReapi() ? rg_get_user_bpammo(this.id, id) : cs_get_user_bpammo(this.id, id);
 	}
 
 	/**
@@ -1571,7 +1731,7 @@ export class Player extends PlayerFields implements Client {
 	 * Pawn: `rg_round_respawn`
 	 */
 	respawn(): void {
-		if (hasModule("reapi")) rg_round_respawn(this.id);
+		if (__hasReapi()) rg_round_respawn(this.id);
 		else ExecuteHamB(Ham_CS_RoundRespawn, this.id);
 	}
 
@@ -1587,7 +1747,7 @@ export class Player extends PlayerFields implements Client {
 
 	/**
 	 * The player's admin rights, from the letters in `users.ini`:
-	 * `player.access.includes("Cvar")`.
+	 * `player.access.includes("cvar")`.
 	 *
 	 * Pawn: `get_user_flags`
 	 */
@@ -1602,7 +1762,7 @@ export class Player extends PlayerFields implements Client {
 	 * Pawn: `rg_switch_weapon`
 	 */
 	switchWeapon(weapon: WeaponName): boolean {
-		if (hasModule("reapi")) {
+		if (__hasReapi()) {
 			const entity = rg_find_weapon_bpack_by_name(this.id, weapon);
 			return entity > 0 && rg_switch_weapon(this.id, entity) != 0;
 		}
@@ -1620,7 +1780,7 @@ export class Player extends PlayerFields implements Client {
 	 * Pawn: `rg_reset_maxspeed`
 	 */
 	resetMaxSpeed(): void {
-		if (hasModule("reapi")) rg_reset_maxspeed(this.id);
+		if (__hasReapi()) rg_reset_maxspeed(this.id);
 		else ExecuteHamB(Ham_CS_Player_ResetMaxSpeed, this.id);
 	}
 
@@ -1635,6 +1795,34 @@ export class Player extends PlayerFields implements Client {
 		new Call(NATIVE_client_cmd).num(this.id).str("%s").str(text).run();
 	}
 
+	/**
+	 * Kicks the player off the server, with the reason he is shown:
+	 * `player.kick("Spam")`; without one, the game's own.
+	 *
+	 * Pawn: `server_cmd("kick #%d")`
+	 */
+	kick(reason: string = ""): void {
+		const said = reason.replaceAll("\"", "'");
+		server.command(said.length > 0 ? `kick #${get_user_userid(this.id)} "${said}"` : `kick #${get_user_userid(this.id)}`);
+	}
+
+	/**
+	 * Moves a bot `server.addBot` made, as a player's keys and mouse would for
+	 * one frame: `bot.move({ forward: 250, buttons: ["jump"] })`. A bot does
+	 * nothing by itself, so it is moved every frame - in the `"frame"` event -
+	 * or it stands still. A player who is not a bot is refused with an error.
+	 *
+	 * Pawn: `engfunc(EngFunc_RunPlayerMove, ...)`
+	 */
+	move(options: MoveOptions = {}): void {
+		if (!this.isBot) throw new Error(`move: ${this.name} is not a bot - only a bot is moved by a plugin`);
+
+		const angles: number[] = options.angles ?? this.viewAngle;
+		const buttons = BUTTON.maskOf<Button>(options.buttons ?? []);
+		const msec = options.msec ?? frameTime() * 1000;
+		engfunc(EngFunc_RunPlayerMove, this.id, angles, options.forward ?? 0, options.side ?? 0, options.up ?? 0, buttons, 0, <i32>Math.round(Math.min(Math.max(msec, 1), 255)));
+	}
+
 	/**
 	 * Asks the player's game for one of its cvars: `await
 	 * player.queryCvar("fps_max")` is the value as text, e.g. `"100"`, or
@@ -1732,8 +1920,8 @@ export function readText(fill: (out: number, max: number) => number, max: number
 
 /**
  * The ids of the players on the server, as an array. `flags`: `"a"` living,
- * `"b"` dead, `"c"` no bots, `"h"` no HLTV, `"e"` only `team`. `Player.all` does the
- * same with readable options.
+ * `"b"` dead, `"c"` no bots, `"h"` no HLTV, `"e"` only `team`. `server.players` is
+ * everyone, as players, to filter as an array.
  *
  * Pawn: `get_players`
  */
@@ -1748,7 +1936,8 @@ export function playerIds(flags: string = "", team: string = ""): number[] {
 	return ids;
 }
 
-// Server's event name is typed like a DOM one - `K extends keyof ServerEventMap` -
+// Server's event name is typed like a DOM one - `K extends keyof ServerEventMap`,
+// and a message's `K extends keyof ServerMessageMap` -
 // so an editor completes it, refuses a misspelled one, and hands the listener
 // the event's own type. The compiler reads the same signature through a patch
 // (runtime/patches): the name has to be written out as a string literal,
@@ -1757,23 +1946,184 @@ export function playerIds(flags: string = "", team: string = ""): number[] {
 
 // ---------------------------------------------------------------- commands
 
-/** A command's handler: gets the player who typed it and the words after the command's name. */
-export type CommandHandler = (player: Player, args: string[]) => void;
+// A command is added by its usage - "/kick <target> [reason]" - and its words
+// are read by code the build writes for that call (scripts/typed-commands.ts):
+// a parser over __CommandWords, which reads each word as the argument's type
+// says and answers the one who typed it with the usage when a word is wrong.
+// The editor's signatures of addCommand and addServerCommand are in amxts.d.ts.
 
 /** The options of a command: who may use it and its description in a listing. */
 export interface CommandOptions {
 	/** The admin right a player needs to use the command; left out, everyone may. */
 	access?: Access;
-	/** The command's description, shown by `amx_help` and the like. */
+	/** The command's description, shown by `amx_help` and in `server.commands`. */
 	description?: string;
 }
 
+/** A command the plugin added, as `server.commands` lists it: what a `/help` shows. */
+export class CommandInfo {
+	constructor(
+		/** The command's usage, as it is typed, e.g. `"/kick <target> [reason]"`. */
+		readonly usage: string,
+		/** The command's description, as its `description` option gave it; `""` without one. */
+		readonly description: string,
+		/** The admin right the command needs; `null` when everyone may use it. */
+		readonly access: Access | null,
+		/** Whether it is a command of the server console rather than a player's. */
+		readonly server: boolean
+	) {}
+}
+
+/** A command's name: the usage's first word - or, for a chat phrase, `"say <phrase>"` whole. */
+function commandName(usage: string): string {
+	const text = usage.trim();
+	if (text.startsWith("say ")) return text;
+	const space = text.indexOf(" ");
+	return space < 0 ? text : text.substring(0, space);
+}
+
+/** The players a command's word names: `#userid`; else the whole name, in any case; else a part of it. */
+function playersNamed(word: string): Player[] {
+	const players = server.players;
+	if (word.startsWith("#")) {
+		const userid = <i32>Number(word.substring(1));
+		return players.filter((player: Player) => get_user_userid(player.id) == userid);
+	}
+	const lower = word.toLowerCase();
+	const whole = players.filter((player: Player) => player.name.toLowerCase() == lower);
+	return whole.length > 0 ? whole : players.filter((player: Player) => player.name.toLowerCase().includes(lower));
+}
+
+let commonLoaded = false;
+
+/** A line of AMX Mod X's `common.txt` in the player's language: the words of its own admin commands. */
+function commonText(player: Player | null, key: string): string {
+	if (!commonLoaded) commonLoaded = lang.load("common");
+	return lang.translate(player, key);
+}
+
+/**
+ * @hidden The words a command was typed with, as the build's code for one
+ * command reads its arguments (scripts/typed-commands.ts): each by its place,
+ * as its type says. A word that is not what the command takes answers the
+ * one who typed it with the usage, and sets `failed`: the handler does not run.
+ */
+export class __CommandWords {
+	/** Set once a word is wrong: the one who typed it has been told. */
+	failed: bool = false;
+
+	constructor(
+		/** The player who typed it; `null` for the server's console. */
+		readonly player: Player | null,
+		readonly usage: string,
+		readonly words: string[],
+		/** The line from each word on, as typed: what the last text argument takes. */
+		readonly rests: string[]
+	) {}
+
+	get count(): i32 {
+		return this.words.length;
+	}
+
+	/** The word at `at`; `""` when it was not typed. */
+	text(at: i32): string {
+		return at < this.words.length ? this.words[at] : "";
+	}
+
+	/** The rest of the line from the word at `at`. */
+	rest(at: i32): string {
+		return at < this.rests.length ? this.rests[at] : "";
+	}
+
+	/** The word at `at` as a number; a word that is not one fails. */
+	number(at: i32): number {
+		const word = this.text(at);
+		const value = Number(word);
+		if (word.length == 0 || isNaN(value)) this.fail("");
+		return value;
+	}
+
+	/** The word at `at`, one of `names`; another fails. */
+	name(at: i32, names: string[]): string {
+		const word = this.text(at);
+		if (!names.includes(word)) this.fail("");
+		return word;
+	}
+
+	/** The player the word at `at` names - `#userid`, the whole name or a part of it. None, or several, fails. */
+	target(at: i32): Player | null {
+		const found = playersNamed(this.text(at));
+		if (found.length == 1) return found[0];
+		this.fail(found.length == 0
+			? commonText(this.player, "CL_NOT_FOUND")
+			: `${commonText(this.player, "MORE_CL_MATCHT")}: ${found.map<string>((one: Player) => one.name).join(", ")}`);
+		return null;
+	}
+
+	/** Whether at least `count` words were typed; fewer fails. */
+	need(count: i32): bool {
+		if (this.words.length < count) this.fail("");
+		return !this.failed;
+	}
+
+	/** Whether no word is left over after the first `count`; one more fails. */
+	done(count: i32): bool {
+		if (this.words.length > count) this.fail("");
+		return !this.failed;
+	}
+
+	/** Tells the one who typed it what was wrong, and the usage. */
+	private fail(why: string): void {
+		if (this.failed) return;
+		this.failed = true;
+		const usage = `${commonText(this.player, "USAGE")}: ${this.usage}`;
+		const player = this.player;
+		if (player == null) {
+			if (why.length > 0) console.log(why);
+			console.log(usage);
+			return;
+		}
+		if (why.length > 0) print(player, why);
+		print(player, usage);
+	}
+}
+
+/** A chat line's words - one in double quotes is one word - and the line from each word on. */
+function chatWords(player: Player, usage: string, line: string): __CommandWords {
+	const words: string[] = [];
+	const rests: string[] = [];
+	let i = 0;
+	while (i < line.length) {
+		while (i < line.length && line.charAt(i) == " ") i++;
+		if (i >= line.length) break;
+		const quoted = line.charAt(i) == "\"";
+		const close = quoted ? line.indexOf("\"", i + 1) : line.indexOf(" ", i);
+		const end = close < 0 ? line.length : close;
+		const word = line.substring(quoted ? i + 1 : i, end);
+		// A quoted last word is the rest without its quotes.
+		rests.push(quoted && close >= 0 && line.substring(close + 1).trim().length == 0 ? word : line.substring(i).trim());
+		words.push(word);
+		i = end + 1;
+	}
+	return new __CommandWords(player, usage, words, rests);
+}
+
+/** A console command's words, as the engine split them. */
+function consoleWords(player: Player | null, usage: string): __CommandWords {
+	const words: string[] = [];
+	const count = read_argc();
+	for (let i = 1; i < count; i++) words.push(read_argv(i));
+	const rests: string[] = [];
+	for (let i = 0; i < words.length; i++) rests.push(words.slice(i).join(" "));
+	return new __CommandWords(player, usage, words, rests);
+}
+
 // The commands of this plugin, by name. One trampoline serves them all - the
-// host calls it by its table index - and it finds the handler by the name the
+// host calls it by its table index - and it finds the command by the name the
 // player typed.
 const commandNames: string[] = [];
-const commandHandlers: CommandHandler[] = [];
-const commandAccess: string[] = [];
+const commandRuns: ((words: __CommandWords) => void)[] = [];
+const commandInfos: CommandInfo[] = [];
 let chatHooked = false;
 
 function findCommand(name: string): i32 {
@@ -1786,7 +2136,7 @@ function findCommand(name: string): i32 {
 
 /**
  * Converts `users.ini` letters to rights: `accessOf("abc")` is
- * [`"Immunity"`, `"Reservation"`, `"Kick"`]. An unknown letter is skipped.
+ * [`"immunity"`, `"reservation"`, `"kick"`]. An unknown letter is skipped.
  *
  * Pawn: `read_flags`
  */
@@ -1796,23 +2146,20 @@ export function accessOf(letters: string): Access[] {
 
 /** Whether a player holds the admin flag a command asks for. */
 function mayRun(id: i32, at: i32): bool {
-	const access = commandAccess[at];
-	if (access.length == 0) return true;
+	const access = commandInfos[at].access;
+	if (access == null) return true;
 	return (get_user_flags(id) & ACCESS.bitOf(access)) != 0;
 }
 
-/** say /name a b - the chat text split on spaces, the first word the name. */
+/** say /name a b - the chat text, its first word the name; or a phrase added as "say <phrase>", the whole line. */
 function chatCommand(player: number, level: number, cid: number, unused: number): void {
 	const id = <i32>player;
 	const text = read_argv(1).trim();
+	const space = text.indexOf(" ");
 	const slash = text.startsWith("/");
-
-	// "/name a b" - or a phrase added as "say <phrase>", which is the whole line.
-	const words = text.split(" ").filter((word: string) => word.length > 0);
-	const at = slash && words.length > 0 ? findCommand(words[0]) : findCommand("say " + text);
+	const at = slash ? findCommand(space < 0 ? text : text.substring(0, space)) : findCommand("say " + text);
 	if (at < 0 || !mayRun(id, at)) { _outcome(0); return; }
-	if (!slash) words.length = 1;
-	runCommand(at, id, words.slice(1));
+	runCommand(at, id, chatWords(new Player(id), commandInfos[at].usage, slash && space >= 0 ? text.substring(space + 1) : ""));
 }
 
 /** name a b - a console command, its arguments as the engine split them. */
@@ -1820,7 +2167,7 @@ function consoleCommand(player: number, level: number, cid: number, unused: numb
 	const id = <i32>player;
 	const at = findCommand(read_argv(0));
 	if (at < 0 || !mayRun(id, at)) { _outcome(0); return; }
-	runCommand(at, id, commandArgs());
+	runCommand(at, id, consoleWords(new Player(id), commandInfos[at].usage));
 }
 
 /**
@@ -1828,36 +2175,28 @@ function consoleCommand(player: number, level: number, cid: number, unused: numb
  * (see __co_ambient_player); the command is handled, so a chat command is not
  * repeated in chat, as a Pawn command's PLUGIN_HANDLED does.
  */
-function runCommand(at: i32, id: i32, args: string[]): void {
+function runCommand(at: i32, id: i32, words: __CommandWords): void {
 	const ambient = __co_ambient_player;
 	__co_ambient_player = id;
-	commandHandlers[at](new Player(id), args);
+	commandRuns[at](words);
 	__co_ambient_player = ambient;
 	handled();
 }
 
-/** The words after the command's name, as the engine split them. */
-function commandArgs(): string[] {
-	const args: string[] = [];
-	const count = read_argc();
-	for (let i = 1; i < count; i++) args.push(read_argv(i));
-	return args;
-}
-
-/** A server command's handler: gets the words after the command's name. */
-export type ServerCommandHandler = (args: string[]) => void;
-
 // The server commands of this plugin, by name, and the ones still waiting for
 // plugin_init. One trampoline serves them all, as it does the player commands.
 const serverCommandNames: string[] = [];
-const serverCommandHandlers: ServerCommandHandler[] = [];
+const serverCommandRuns: ((words: __CommandWords) => void)[] = [];
+const serverCommandUsages: string[] = [];
 const waitingServerCommands: string[] = [];
 
 // A touch the engine module filters by class, so a touch nobody listens for -
 // and there is one every frame for a player on the ground - never reaches the
-// plugin. One register_touch per pair of classes, its listeners behind it.
+// plugin. One register_touch per pair of classes, its listeners behind it,
+// switched off while it has none.
 class TouchFilter {
 	listeners: TouchListener[] = [];
+	hook: __Switch = new __Switch();
 	constructor(public toucher: string, public touched: string) {}
 }
 
@@ -1867,21 +2206,27 @@ const waitingTouches: TouchFilter[] = [];
 // A Ham Sandwich hook waiting for plugin_init: RegisterHam makes an entity of
 // the class to find its function, which is not for the moment a plugin loads.
 class HamRegistration {
-	constructor(public fn: i32, public classname: string, public handler: WideHandler, public post: bool) {}
+	constructor(public fn: i32, public classname: string, public handler: WideHandler, public post: bool, public hook: __Switch | null) {}
 }
 
 const waitingHams: HamRegistration[] = [];
 
 function registerHam(registration: HamRegistration): void {
-	_ham(registration.fn, registration.classname, hostIndex(registration.handler, true), registration.post ? 1 : 0);
+	const handle = _ham(registration.fn, registration.classname, hostIndex(registration.handler, true), registration.post ? 1 : 0);
+	const hook = registration.hook;
+	if (hook == null || handle == 0) return;
+	hook.add((on: bool): void => {
+		if (on) EnableHamForward(handle);
+		else DisableHamForward(handle);
+	});
 }
 
 /**
  * @hidden The hood of a game event Ham Sandwich delivers (as/hooks.ts):
- * `fn` hooked on the class, a reload taking its slot back.
+ * `fn` hooked on the class, a reload taking its slot back, switched by `hook`.
  */
-export function __ham(fn: i32, classname: string, handler: WideHandler, post: bool): void {
-	const registration = new HamRegistration(fn, classname, handler, post);
+export function __ham(fn: i32, classname: string, handler: WideHandler, post: bool, hook: __Switch | null = null): void {
+	const registration = new HamRegistration(fn, classname, handler, post, hook);
 	if (serverUp) registerHam(registration);
 	else waitingHams.push(registration);
 }
@@ -1891,7 +2236,7 @@ function serverCommand(a: number, b: number, c: number, d: number): void {
 	const at = serverCommandNames.indexOf(read_argv(0).toLowerCase());
 	if (at < 0) { _outcome(0); return; }
 
-	serverCommandHandlers[at](commandArgs());
+	serverCommandRuns[at](consoleWords(null, serverCommandUsages[at]));
 	handled();
 }
 
@@ -2040,6 +2385,12 @@ export interface ShakeOptions {
 	frequency?: number;
 }
 
+/** The options of `player.screen.progressBar`. */
+export interface ProgressBarOptions {
+	/** The bar's fill at the start, in percent; `0`, empty, by default. */
+	startPercent?: number;
+}
+
 /** A status icon's state, one of `"hide"`, `"show"` (lit) or `"flash"`. */
 export type StatusIconState = "hide" | "show" | "flash";
 
@@ -2058,15 +2409,17 @@ function fixed(value: number, units: number): i32 {
  * player.screen.statusIcon("dmg_cold", "show", [0, 160, 255]);
  * ```
  *
- * Times are in seconds.
+ * Times are in seconds. A message listener hears what the screen sends, as
+ * it hears the game's: `"progressBar"` hears `progressBar(seconds)`.
  *
  * Pawn: `ScreenFade`, `ScreenShake`, `StatusIcon`, ...
  */
 export class Screen {
 	constructor(private id: i32) {}
 
+	// Through the engine (emessage_*): AMX Mod X's message hooks do not see a plugin's message_begin.
 	private begin(name: string, reliable: bool = true): void {
-		message_begin(reliable ? MSG_ONE : MSG_ONE_UNRELIABLE, get_user_msgid(name), [0, 0, 0], this.id);
+		emessage_begin(reliable ? MSG_ONE : MSG_ONE_UNRELIABLE, get_user_msgid(name), [0, 0, 0], this.id);
 	}
 
 	/**
@@ -2081,11 +2434,11 @@ export class Screen {
 		if (options.stay) flags |= FFADE_STAYOUT;
 
 		this.begin("ScreenFade");
-		write_short(fixed(options.duration ?? 1.0, 4096.0));
-		write_short(fixed(options.hold ?? 0.0, 4096.0));
-		write_short(flags);
-		for (let i = 0; i < 4; i++) write_byte(i < color.length ? <i32>color[i] : 255);
-		message_end();
+		ewrite_short(fixed(options.duration ?? 1.0, 4096.0));
+		ewrite_short(fixed(options.hold ?? 0.0, 4096.0));
+		ewrite_short(flags);
+		for (let i = 0; i < 4; i++) ewrite_byte(i < color.length ? <i32>color[i] : 255);
+		emessage_end();
 	}
 
 	/**
@@ -2095,10 +2448,10 @@ export class Screen {
 	 */
 	shake(options: ShakeOptions = {}): void {
 		this.begin("ScreenShake");
-		write_short(fixed(options.amplitude ?? 4.0, 4096.0));
-		write_short(fixed(options.duration ?? 1.0, 4096.0));
-		write_short(fixed(options.frequency ?? 5.0, 256.0));
-		message_end();
+		ewrite_short(fixed(options.amplitude ?? 4.0, 4096.0));
+		ewrite_short(fixed(options.duration ?? 1.0, 4096.0));
+		ewrite_short(fixed(options.frequency ?? 5.0, 256.0));
+		emessage_end();
 	}
 
 	/**
@@ -2110,12 +2463,12 @@ export class Screen {
 	statusIcon(sprite: string, state: StatusIconState, color: number[] = [0, 160, 0]): void {
 		const status = state == "show" ? 1 : state == "flash" ? 2 : 0;
 		this.begin("StatusIcon");
-		write_byte(status);
-		write_string(sprite);
+		ewrite_byte(status);
+		ewrite_string(sprite);
 		if (status != 0) {
-			for (let i = 0; i < 3; i++) write_byte(i < color.length ? <i32>color[i] : 0);
+			for (let i = 0; i < 3; i++) ewrite_byte(i < color.length ? <i32>color[i] : 0);
 		}
-		message_end();
+		emessage_end();
 	}
 
 	/**
@@ -2127,8 +2480,8 @@ export class Screen {
 	 */
 	roundTime(seconds: number): void {
 		this.begin("RoundTime", false);
-		write_short(<i32>seconds);
-		message_end();
+		ewrite_short(<i32>seconds);
+		emessage_end();
 	}
 
 	/**
@@ -2139,8 +2492,8 @@ export class Screen {
 	 */
 	hideHud(parts: HideHud[]): void {
 		this.begin("HideWeapon");
-		write_byte(HIDE_HUD.maskOf(parts));
-		message_end();
+		ewrite_byte(HIDE_HUD.maskOf(parts));
+		emessage_end();
 	}
 
 	/**
@@ -2150,8 +2503,8 @@ export class Screen {
 	 */
 	crosshair(shown: boolean): void {
 		this.begin("Crosshair");
-		write_byte(shown ? 1 : 0);
-		message_end();
+		ewrite_byte(shown ? 1 : 0);
+		emessage_end();
 	}
 
 	/**
@@ -2162,21 +2515,28 @@ export class Screen {
 	 */
 	flashlight(on: boolean, battery: number = 100): void {
 		this.begin("Flashlight");
-		write_byte(on ? 1 : 0);
-		write_byte(<i32>battery);
-		message_end();
+		ewrite_byte(on ? 1 : 0);
+		ewrite_byte(<i32>battery);
+		emessage_end();
 	}
 
 	/**
 	 * Shows the progress bar in the middle of the player's screen, filling up
-	 * over `seconds`; `0` hides it.
+	 * over `seconds`; `0` hides it. With `startPercent` it starts part of the
+	 * way full and fills the rest of `seconds`:
+	 *
+	 * ```ts
+	 * player.screen.progressBar(4, { startPercent: 50 });   // half full, full in 2 seconds
+	 * ```
 	 *
-	 * Pawn: `BarTime`, `rg_send_bartime`
+	 * Pawn: `BarTime`, `BarTime2`, `rg_send_bartime`, `rg_send_bartime2`
 	 */
-	progressBar(seconds: number): void {
-		this.begin("BarTime");
-		write_short(fixed(seconds, 1.0));
-		message_end();
+	progressBar(seconds: number, options: ProgressBarOptions = {}): void {
+		const startPercent = options.startPercent ?? 0;
+		this.begin(startPercent == 0 ? "BarTime" : "BarTime2");
+		ewrite_short(fixed(seconds, 1.0));
+		if (startPercent != 0) ewrite_short(fixed(startPercent, 1.0));
+		emessage_end();
 	}
 }
 
@@ -2250,6 +2610,52 @@ function precacheWaiting(event: PluginPrecacheEvent): void {
 	precacheOpen = true;
 	for (let i = 0; i < waitingPrecaches.length; i++) precacheNow(waitingPrecaches[i]);
 	waitingPrecaches.length = 0;
+	runWaiting(waitingAtPrecache);
+}
+
+// The stock hooks a server without reapi hears ReGameDLL's events through
+// (as/hlds.ts), asked for before natives may be called - at a plugin's top
+// level, during plugin_natives: a precache's hook at plugin_precache, before
+// the game's own precaches, and every other at plugin_init, as a command is.
+const waitingAtPrecache: (() => void)[] = [];
+const waitingAtInit: (() => void)[] = [];
+
+function runWaiting(list: (() => void)[]): void {
+	const now = list.slice(0);
+	list.length = 0;
+	for (let i = 0; i < now.length; i++) now[i]();
+}
+
+// @ts-ignore: decorator
+@external("env", "on_cell") declare function _onCell(event: string, fn: i32, shape: i32, arg: i32, value: i32): void;
+
+/**
+ * @hidden A forward the host relays, heard by `fn` (a one-cell handler) only
+ * when its argument `arg` is `value`: the module compares it, so a forward
+ * that comes often crosses into the plugin for that value alone.
+ */
+export function __onCell(event: string, fn: i32, arg: i32, value: i32): void {
+	_onCell(event, fn, 0, arg, value);
+}
+
+// @ts-ignore: decorator
+@external("env", "off") declare function _off(event: string, fn: i32): void;
+
+/** @hidden Takes the handler `fn` of a forward the host relays off again: once its event has no listener left. */
+export function __off(event: string, fn: i32): void {
+	_off(event, fn);
+}
+
+/** @hidden Runs `register` from plugin_init on: now, or when it comes. */
+export function __whenUp(register: () => void): void {
+	if (serverUp) register();
+	else waitingAtInit.push(register);
+}
+
+/** @hidden Runs `register` from plugin_precache on - or plugin_init, after a reload mid-map. */
+export function __whenPrecache(register: () => void): void {
+	if (precacheOpen || serverUp) register();
+	else waitingAtPrecache.push(register);
 }
 addServerListener<PluginPrecacheEvent>(precacheWaiting);
 
@@ -2266,8 +2672,8 @@ const FFADE_STAYOUT = 0x0004;
  * or a text, as the message wrote it.
  *
  * ```ts
- * server.addEventListener("message:TeamScore", (event) => {
- *   console.log(`${event.args.text(0)} ${event.args.number(1)}`);
+ * server.addMessageListener("botProgress", (event) => {
+ *   console.log(`${event.args.length} ${event.args.number(0)}`);
  * });
  * ```
  *
@@ -2315,24 +2721,23 @@ export class MessageArgs {
  * HUD icon - heard on its way, before it leaves:
  *
  * ```ts
- * server.addEventListener("message:TextMsg", (event) => {
+ * server.addMessageListener("text", (event) => {
  *   if (event.text == "#Round_Draw") event.preventDefault();
  * });
  * ```
  *
- * A message the editor knows has typed fields (`event.text`); every one has
- * its arguments in `event.args`. Writing a field changes what the client
- * gets.
+ * A message whose layout is known has a typed field for each argument
+ * (`event.text`), and writing one changes what the client gets; a message
+ * without a known layout is read by place, through `event.args`, which
+ * every message has.
  *
  * Pawn: `register_message`
  */
 export class ClientMessage {
-	/** @hidden What a message's event is told apart by, at compile time. */
-	__message: bool = true;
 	/** @hidden The player it goes to: the message's msg_entity. */
 	__receiver: i32 = 0;
 
-	/** The message's name, e.g. `"TextMsg"`. */
+	/** The game's name of the message, e.g. `"TextMsg"` for `text`. */
 	name: string = "";
 
 	/** The player the message goes to; `null` for a message to everyone. */
@@ -2354,39 +2759,97 @@ export class ClientMessage {
 		handled();
 	}
 
-	/** @hidden An argument by its number, 1 for the first, as a number. */
+	// A field reads an argument by its number, 1 for the first. One the
+	// message did not write - StatusIcon's colour when it hides the icon, a
+	// game text without words to put in - reads as 0 or "", and writing it
+	// does nothing: AMX Mod X reports an argument past the last as an error.
+
+	/** @hidden Whether the message has the argument. */
+	protected __has(arg: i32): bool {
+		return arg <= get_msg_args();
+	}
+
+	/** @hidden An argument as a number. */
 	protected __number(arg: i32): f64 {
-		return this.args.number(arg - 1);
+		return this.__has(arg) ? this.args.number(arg - 1) : 0;
 	}
 
 	/** @hidden */
 	protected __setNumber(arg: i32, value: f64): void {
-		this.args.setNumber(arg - 1, value);
+		if (this.__has(arg)) this.args.setNumber(arg - 1, value);
 	}
 
 	/** @hidden */
 	protected __text(arg: i32): string {
-		return get_msg_arg_string(arg);
+		return this.__has(arg) ? get_msg_arg_string(arg) : "";
 	}
 
 	/** @hidden */
 	protected __setText(arg: i32, value: string): void {
-		set_msg_arg_string(arg, value);
+		if (this.__has(arg)) set_msg_arg_string(arg, value);
+	}
+
+	/** @hidden Every text from the argument on. */
+	protected __texts(arg: i32): string[] {
+		const texts: string[] = [];
+		for (let at = arg; this.__has(at); at++) texts.push(get_msg_arg_string(at));
+		return texts;
+	}
+
+	/** @hidden Writes the texts from the argument on, as many as the message has. */
+	protected __setTexts(arg: i32, value: string[]): void {
+		for (let i = 0; i < value.length && this.__has(arg + i); i++) set_msg_arg_string(arg + i, value[i]);
 	}
 
 	/** @hidden A player's number argument; `0` or past the players is none. */
 	protected __player(arg: i32): Player | null {
-		const id = get_msg_arg_int(arg);
+		const id = <i32>this.__number(arg);
 		return id >= 1 && id <= get_maxplayers() ? new Player(id) : null;
 	}
+
+	/** @hidden Three coordinates from the argument on. */
+	protected __vector(arg: i32): Vector {
+		return new Vector(this.__number(arg), this.__number(arg + 1), this.__number(arg + 2));
+	}
+
+	/** @hidden */
+	protected __setVector(arg: i32, value: number[]): void {
+		for (let i = 0; i < 3; i++) this.__setNumber(arg + i, value[i]);
+	}
+
+	/** @hidden `count` bytes from the argument on: a colour. */
+	protected __bytes(arg: i32, count: i32): number[] {
+		const bytes: number[] = [];
+		for (let i = 0; i < count; i++) bytes.push(this.__number(arg + i));
+		return bytes;
+	}
+
+	/** @hidden */
+	protected __setBytes(arg: i32, value: number[]): void {
+		for (let i = 0; i < value.length; i++) this.__setNumber(arg + i, value[i]);
+	}
+
+	/** @hidden Whether the argument has the bit. */
+	protected __bit(arg: i32, bit: i32): bool {
+		return (<i32>this.__number(arg) & bit) != 0;
+	}
+
+	/** @hidden Sets or clears one bit of the argument, keeping the others. */
+	protected __setBit(arg: i32, bit: i32, on: bool): void {
+		const mask = <i32>this.__number(arg);
+		this.__setNumber(arg, on ? mask | bit : mask & ~bit);
+	}
 }
 
 // One register_message per message name, its listeners behind it: the engine
 // hands the plugin only the messages it listens to. Registered when the
 // server is up - a message's id is known from plugin_init - and a reload
-// takes the same public back.
+// takes the same public back. AMX Mod X's unregister_message can take
+// another plugin's hook off instead, so with no listener left the public is
+// switched off in the module.
 class MessageChannel {
 	listeners: ((event: ClientMessage) => void)[] = [];
+	hook: __Switch = new __Switch();
 	constructor(public name: string, public make: () => ClientMessage) {}
 }
 
@@ -2400,7 +2863,7 @@ function messageChannel(name: string): MessageChannel | null {
 	return null;
 }
 
-function addMessageListener<E>(name: string, listener: (event: E) => void): void {
+function listenToMessage<E>(name: string, listener: (event: E) => void): void {
 	let channel = messageChannel(name);
 
 	if (channel == null) {
@@ -2411,25 +2874,27 @@ function addMessageListener<E>(name: string, listener: (event: E) => void): void
 	}
 
 	channel.listeners.push(changetype<(event: ClientMessage) => void>(listener));
+	channel.hook.set(true);
 }
 
-function removeMessageListener<E>(name: string, listener: (event: E) => void): void {
+function stopListeningToMessage<E>(name: string, listener: (event: E) => void): void {
 	const channel = messageChannel(name);
 	if (channel == null) return;
 	const at = channel.listeners.indexOf(changetype<(event: ClientMessage) => void>(listener));
 	if (at >= 0) channel.listeners.splice(at, 1);
+	channel.hook.set(channel.listeners.length > 0);
 }
 
 function registerMessage(channel: MessageChannel): void {
 	const id = get_user_msgid(channel.name);
 
 	if (id == 0) {
-		console.error(`message:${channel.name} - the game has no message by that name`);
+		console.error(`${channel.name} - the game has no message by that name`);
 		return;
 	}
 
 	const fired = (message: number, dest: number, receiver: number, d: number): void => messageFired(channel, <i32>receiver);
-	const pub = publicFor(fired, `msg:${channel.name}`);
+	const pub = __switchedPublic(fired, `msg:${channel.name}`, channel.hook);
 	if (pub.length > 0) register_message(id, pub);
 }
 
@@ -2457,7 +2922,7 @@ function messageFired(channel: MessageChannel, receiver: i32): void {
  * plugin, TypeScript or Pawn:
  *
  * ```ts
- * server.addEventListener("playerchange", (event) => {
+ * server.addEventListener("playerChange", (event) => {
  *   print(event.player, event.value ? "You are protected" : "Your spawn protection is over");
  * }, { field: "spawnProtected" });
  * ```
@@ -2492,14 +2957,14 @@ export class PlayerChangeEvent<F extends string = string> {
 /** The third argument of `server.addEventListener`. */
 export interface ServerListenerOptions {
 	/**
-	 * For `"playerchange"`: the field listened for, e.g. `"spawnProtected"`, or
+	 * For `"playerChange"`: the field listened for, e.g. `"spawnProtected"`, or
 	 * an object field's member, `"glow.enabled"`; an object field's name
 	 * hears each of its members. Left out, every field.
 	 */
 	field?: string;
 }
 
-// This plugin's playerchange listeners. The module wakes the plugin only for
+// This plugin's playerChange listeners. The module wakes the plugin only for
 // the fields they are for (player_change_listen), and the trampoline hands a
 // change to the ones it concerns, each as its own event class - the field's
 // typed one, which the build makes (scripts/player-fields.ts).
@@ -2613,6 +3078,8 @@ function attachWaitingCvars(event: PluginInitEvent): void {
 	waitingHams.length = 0;
 	for (let i = 0; i < waitingMessages.length; i++) registerMessage(waitingMessages[i]);
 	waitingMessages.length = 0;
+	runWaiting(waitingAtPrecache);
+	runWaiting(waitingAtInit);
 }
 addServerListener<PluginInitEvent>(attachWaitingCvars);
 
@@ -2740,7 +3207,7 @@ export class Cvar {
  * the folders AMX Mod X keeps. Used through `server`:
  *
  * ```ts
- * server.addEventListener("putinserver", (event) => {
+ * server.addEventListener("putInServer", (event) => {
  *   print(event.player, "Welcome!");      // event is a PutinserverEvent
  * });
  * server.map;                             // "de_dust2"
@@ -2754,27 +3221,51 @@ export class Cvar {
  */
 export class Server {
 	/**
-	 * Calls `listener` every time the server raises the event `type` - or,
-	 * for `"message:<Name>"`, every time it sends that message to a client.
-	 * `"playerchange"` takes the field it is for: `{ field: "spawnProtected" }`.
+	 * Calls `listener` every time the server raises the event `type`.
+	 * `"playerChange"` takes the field it is for: `{ field: "spawnProtected" }`.
 	 */
 	addEventListener<K extends keyof ServerEventMap>(type: K, listener: (event: ServerEventMap[K]) => void, options: ServerListenerOptions = {}): void {
-		// @ts-ignore: a message's event is told apart by its field, at compile time
-		if (isDefined(changetype<ServerEventMap[K]>(0).__message)) addMessageListener<ServerEventMap[K]>(type.slice(8), listener);
-		// @ts-ignore: and so is a field's change
-		else if (isDefined(changetype<ServerEventMap[K]>(0).__playerChange)) addPlayerChangeListener<ServerEventMap[K]>(options.field ?? "", listener);
+		// @ts-ignore: a field's change is told apart by its field, at compile time
+		if (isDefined(changetype<ServerEventMap[K]>(0).__playerChange)) addPlayerChangeListener<ServerEventMap[K]>(options.field ?? "", listener);
 		else addServerListener<ServerEventMap[K]>(listener);
 	}
 
 	/** Stops calling a listener added with `addEventListener` - the same function and the same options. */
 	removeEventListener<K extends keyof ServerEventMap>(type: K, listener: (event: ServerEventMap[K]) => void, options: ServerListenerOptions = {}): void {
 		// @ts-ignore: as in addEventListener
-		if (isDefined(changetype<ServerEventMap[K]>(0).__message)) removeMessageListener<ServerEventMap[K]>(type.slice(8), listener);
-		// @ts-ignore: as in addEventListener
-		else if (isDefined(changetype<ServerEventMap[K]>(0).__playerChange)) removePlayerChangeListener<ServerEventMap[K]>(options.field ?? "", listener);
+		if (isDefined(changetype<ServerEventMap[K]>(0).__playerChange)) removePlayerChangeListener<ServerEventMap[K]>(options.field ?? "", listener);
 		else removeServerListener<ServerEventMap[K]>(listener);
 	}
 
+	/**
+	 * Calls `listener` every time the server sends the message `name` to a
+	 * client, before it leaves: the listener reads its fields, changes them, or
+	 * stops it with `preventDefault()`.
+	 *
+	 * ```ts
+	 * server.addMessageListener("death", (event) => {
+	 *   if (event.headshot) console.log(`${event.killer?.name} - headshot - ${event.victim?.name}`);
+	 * });
+	 * ```
+	 *
+	 * The editor lists the names, each with the game's own one in its words:
+	 * `death` is the game's `DeathMsg`. A name may hear a few of the game's
+	 * messages that are one thing: `progressBar` is `BarTime` and
+	 * `BarTime2`, and `event.name` says which one came.
+	 *
+	 * Pawn: `register_message`
+	 */
+	addMessageListener<K extends keyof ServerMessageMap>(name: K, listener: (event: ServerMessageMap[K]) => void): void {
+		const messages = protocolMessageNames(name);
+		for (let i = 0; i < messages.length; i++) listenToMessage<ServerMessageMap[K]>(messages[i], listener);
+	}
+
+	/** Stops calling a listener added with `addMessageListener` - the same name and the same function. */
+	removeMessageListener<K extends keyof ServerMessageMap>(name: K, listener: (event: ServerMessageMap[K]) => void): void {
+		const messages = protocolMessageNames(name);
+		for (let i = 0; i < messages.length; i++) stopListeningToMessage<ServerMessageMap[K]>(messages[i], listener);
+	}
+
 	/**
 	 * The current map's name, e.g. `"de_dust2"`.
 	 *
@@ -2793,6 +3284,51 @@ export class Server {
 		return get_maxplayers();
 	}
 
+	/**
+	 * The players on the server, every one connected - never an HLTV proxy -
+	 * read anew each time. Narrow them with the array's `filter`:
+	 *
+	 * ```ts
+	 * const alive = server.players.filter(player => player.isAlive);
+	 * const cts = server.players.filter(player => player.team === "CT" && !player.isBot);
+	 * ```
+	 *
+	 * Pawn: `get_players`
+	 */
+	get players(): Player[] {
+		const ids = playerIds("h");
+		const list: Player[] = [];
+		for (let i = 0; i < ids.length; i++) list.push(new Player(ids[i]));
+		return list;
+	}
+
+	/**
+	 * Adds a bot under `name`: a player the server runs, with no game behind
+	 * it and no mind of its own - it stands where it spawns until a plugin
+	 * moves it with `bot.move()`. `null` when no slot is free. `"putInServer"`
+	 * fires for it as for anyone, `bot.isBot` is `true` and `bot.kick()`
+	 * removes it.
+	 *
+	 * ```ts
+	 * const bot = server.addBot("Dummy");
+	 * bot?.joinTeam("CT");
+	 * ```
+	 *
+	 * Pawn: `engfunc(EngFunc_CreateFakeClient)`, `dllfunc(DLLFunc_ClientConnect)`, `dllfunc(DLLFunc_ClientPutInServer)`
+	 */
+	addBot(name: string): Player | null {
+		// The engine takes a slot and marks the client FL_FAKECLIENT; AMX Mod X
+		// connects it then and there. The game is told after, as the engine
+		// tells it of anyone: it connects and puts the player in the server.
+		const id = <i32>engfunc(EngFunc_CreateFakeClient, name);
+		if (id <= 0) return null;
+
+		const rejected = new Ref<string>("");
+		dllfunc(DLLFunc_ClientConnect, id, name, "127.0.0.1", rejected);
+		dllfunc(DLLFunc_ClientPutInServer, id);
+		return new Player(id);
+	}
+
 	/**
 	 * The AMX Mod X configs folder, relative to the game folder, as `fs` takes it:
 	 * `addons/amxmodx/configs` unless the server moved it.
@@ -2831,27 +3367,34 @@ export class Server {
 	}
 
 	/**
-	 * Adds a command players type, e.g. `"/hp"` in chat, or a name without the slash
-	 * in the console.
+	 * The commands this plugin added, players' and the server's, in the order
+	 * they were added: each one's `usage`, `description` and `access` - what a
+	 * `/help` prints.
 	 *
 	 * ```ts
-	 * server.addCommand("/hp", (player) => print(player, `${player.health} HP`));
-	 * server.addCommand("/kick", kick, { access: "Kick", description: "Kick a player" });
+	 * server.addCommand("/help", ({ player }) => {
+	 *   for (const command of server.commands) {
+	 *     if (command.access == null || player.access.includes(command.access)) print(player, command.usage);
+	 *   }
+	 * });
 	 * ```
-	 *
-	 * `args` are the words after the command. A chat command is not repeated in
-	 * chat, and it does not run for a player without the `access` right.
-	 * `"say time"` runs when a player writes exactly `"time"` in chat.
-	 *
-	 * Pawn: `register_clcmd`
 	 */
-	addCommand(name: string, handler: CommandHandler, options: CommandOptions = {}): void {
+	get commands(): CommandInfo[] {
+		return commandInfos.slice(0);
+	}
+
+	/**
+	 * @hidden A player's command, its words read by `run` - the parser the
+	 * build writes for each `addCommand` call (scripts/typed-commands.ts).
+	 */
+	__addCommand(usage: string, run: (words: __CommandWords) => void, options: CommandOptions = {}): void {
+		const name = commandName(usage);
 		const chat = name.startsWith("/") || name.startsWith("say ");
 		const access = options.access;
 
 		commandNames.push(name.toLowerCase());
-		commandHandlers.push(handler);
-		commandAccess.push(access ?? "");
+		commandRuns.push(run);
+		commandInfos.push(new CommandInfo(usage, options.description ?? "", access ?? null, false));
 
 		if (!chat) {
 			const flags = access != null ? ACCESS.bitOf(access) : 0;
@@ -2865,23 +3408,13 @@ export class Server {
 		_clcmd("say_team", chatCommand.index, 0, "", SHAPE_WIDE);
 	}
 
-	/**
-	 * Adds a command of the server console - typed there, sent over rcon or run by
-	 * another plugin. Players cannot use it.
-	 *
-	 * ```ts
-	 * server.addServerCommand("myplugin_reset", (args) => reset(args.length > 0 ? args[0] : "all"));
-	 * ```
-	 *
-	 * `args` are the words after the command. It may be added at the top level of
-	 * the file.
-	 *
-	 * Pawn: `register_srvcmd`
-	 */
-	addServerCommand(name: string, handler: ServerCommandHandler): void {
-		const lower = name.toLowerCase();
+	/** @hidden A command of the server console, its words read by `run`, as `__addCommand`'s are. */
+	__addServerCommand(usage: string, run: (words: __CommandWords) => void): void {
+		const lower = commandName(usage).toLowerCase();
 		serverCommandNames.push(lower);
-		serverCommandHandlers.push(handler);
+		serverCommandRuns.push(run);
+		serverCommandUsages.push(usage);
+		commandInfos.push(new CommandInfo(usage, "", null, true));
 
 		if (serverUp) registerServerCommand(lower);
 		else waitingServerCommands.push(lower);
@@ -2923,7 +3456,7 @@ export const server = new Server();
  *   if (event.player.isBot) event.preventDefault();
  * });
  * game.addEventListener("canPlayerHearPlayer", (event) => event.listener.team == event.sender.team);
- * game.addEventListener("flPlayerFallDamage", (event) => event.result / 2, true);
+ * game.addEventListener("fallDamage", (event) => event.result / 2, true);
  * ```
  *
  * The event's type follows from its name. What a listener returns is the
@@ -2932,7 +3465,7 @@ export const server = new Server();
  * nothing leaves it to the game; `event.preventDefault()` blocks without an
  * answer. A value of the wrong type is an error in the editor and in the build.
  *
- * The game rules are its fields: `game.freezePeriod`, `game.numCtWins`,
+ * The game rules are its fields: `game.isFreezeTime`, `game.ctWins`,
  * `game.roundWinner`.
  *
  * Pawn: `RegisterHookChain`, `RegisterHam`, `get_member_game`
@@ -3001,7 +3534,50 @@ export class Game extends GameFields {
 	 */
 	endRound(options: EndRoundOptions): void {
 		const status = max(WINNER_NAMES.indexOf(options.winner), 0);
-		rg_round_end(options.delay ?? 5.0, status, ROUND_REASONS[status], options.message ?? "default", options.sound ?? "default", options.dispatch ?? false);
+		const delay = options.delay ?? 5.0;
+		const message = options.message ?? "default";
+		const sound = options.sound ?? "default";
+		if (__hasReapi()) {
+			rg_round_end(delay, status, ROUND_REASONS[status], message, sound, options.dispatch ?? false);
+			return;
+		}
+
+		// Without reapi, what rg_round_end does through the game's
+		// TerminateRound: the winner, the moment the next round starts, and the
+		// round marked as ending, so the game does not end it again meanwhile;
+		// then the message and the sound.
+		this.roundWinner = options.winner;
+		this.roundEnding = true;
+		this.newRoundTime = this.time + delay;
+		const text = message == "default" ? ROUND_MESSAGES[status] : message;
+		const radio = sound == "default" ? ROUND_SOUNDS[status] : sound;
+		if (!(options.dispatch ?? false)) {
+			if (text.length > 0) client_print(0, print_center, text);
+			if (radio.length > 0) broadcastAudio(`%!MRAD_${radio}`);
+			return;
+		}
+
+		// Told as the game tells a round's end - the message and the sound
+		// through the engine, where every plugin's hooks hear them, then its
+		// log lines, which the roundEnd listeners hear on plain HLDS - Pawn
+		// plugins' logevents too.
+		if (text.length > 0) {
+			emessage_begin(MSG_ALL, get_user_msgid("TextMsg"));
+			ewrite_byte(print_center);
+			ewrite_string(text);
+			emessage_end();
+		}
+		if (radio.length > 0) {
+			emessage_begin(MSG_ALL, get_user_msgid("SendAudio"));
+			ewrite_byte(0);
+			ewrite_string(`%!MRAD_${radio}`);
+			ewrite_short(100);
+			emessage_end();
+		}
+		const score = `(CT "${this.ctWins}") (T "${this.terroristWins}")`;
+		if (status == 3) elog_message(`World triggered "Round_Draw" ${score}`);
+		else if (status > 0) elog_message(`Team "${status == 1 ? "CT" : "TERRORIST"}" triggered "${status == 1 ? "CTs_Win" : "Terrorists_Win"}" ${score}`);
+		elog_message(`World triggered "Round_End"`);
 	}
 }
 
@@ -3028,7 +3604,7 @@ export interface GameListenerOptions {
  */
 export type UseType = "off" | "on" | "set" | "toggle";
 
-/** The options of an entity's action such as `weapon.deploy()` or `entity.takeHealth(...)`. */
+/** The options of an entity's action such as `weapon.deploy()` or `entity.heal(...)`. */
 export interface ActionOptions {
 	/**
 	 * Whether the game's listeners run too - this plugin's and every other's,
@@ -3086,6 +3662,7 @@ function addTouchListener(listener: TouchListener, toucher: string, touched: str
 	}
 
 	filter.listeners.push(listener);
+	filter.hook.set(true);
 }
 
 function removeTouchListener(listener: TouchListener, toucher: string, touched: string): void {
@@ -3093,12 +3670,13 @@ function removeTouchListener(listener: TouchListener, toucher: string, touched:
 	if (filter == null) return;
 	const at = filter.listeners.indexOf(listener);
 	if (at >= 0) filter.listeners.splice(at, 1);
+	filter.hook.set(filter.listeners.length > 0);
 }
 
 /** Hands one pair of classes to the engine module; a reload takes the same public back. */
 function registerTouch(filter: TouchFilter): void {
 	const fired = (touched: number, toucher: number, c: number, d: number): void => touchFired(filter, touched, toucher);
-	const pub = publicFor(fired, `touch:${filter.toucher}:${filter.touched}`);
+	const pub = __switchedPublic(fired, `touch:${filter.toucher}:${filter.touched}`, filter.hook);
 	if (pub.length > 0) register_touch(filter.touched, filter.toucher, pub);
 }
 
@@ -3175,15 +3753,15 @@ export { Entity, Weapon, WeaponKind, weaponKindOf } from "./entities";
 // The names an enum field takes and gives: `entity.renderMode = "additive"`.
 export {
 	RenderMode, RenderFx, MoveType, Solid, TakeDamage, DeadFlag, WaterLevel, Contents, FixAngle, HitGroup,
-	ArmorType, ObserverMode, JoinState, GameMenu, PlayerModel, IgnoredChat, ThrowDirection, BloodColor, MonsterState, MusicState
+	ArmorType, ObserverMode, JoinState, GameMenu, PlayerModel, IgnoredChat, ThrowDirection, BloodColor, MusicState
 } from "./entities";
 import {
 	NATIVE_server_cmd, NATIVE_client_cmd, NATIVE_CreateMultiForward, NATIVE_ExecuteForward, get_gametime, get_mapname,
-	nvault_open, nvault_set, nvault_remove, rg_round_end
+	nvault_open, nvault_set, nvault_remove, rg_round_end, client_print
 } from "./natives";
 import { ET_IGNORE, ET_STOP, FP_ARRAY, FP_CELL, FP_FLOAT, FP_STRING } from "./constants";
-import { ROUND_NONE, ROUND_CTS_WIN, ROUND_TERRORISTS_WIN, ROUND_END_DRAW } from "./constants";
-import { PluginInitEvent, PluginPrecacheEvent, ServerEventMap, addServerListener, removeServerListener } from "./events";
+import { ROUND_NONE, ROUND_CTS_WIN, ROUND_TERRORISTS_WIN, ROUND_END_DRAW, print_center } from "./constants";
+import { PluginInitEvent, PluginPrecacheEvent, ServerEventMap, ServerMessageMap, addServerListener, protocolMessageNames, removeServerListener } from "./events";
 
 function variantOf(variant: VariantName): number {
 	if (variant == Variant.center) return 4;
@@ -3394,7 +3972,7 @@ export namespace cvar {
  *
  * Pawn: `register_clcmd`
  */
-export function cmd(pattern: string, handler: Handler, flag: FlagName = "ALL", info: string = ""): void {
+export function cmd(pattern: string, handler: Handler, flag: FlagName = "all", info: string = ""): void {
 	_clcmd(pattern, hostIndex(handler, false), flagOf(flag), info, SHAPE_NARROW);
 }
 
@@ -3405,7 +3983,7 @@ export function cmd(pattern: string, handler: Handler, flag: FlagName = "ALL", i
  *
  * Pawn: `register_clcmd`
  */
-export function cmdWide(pattern: string, handler: WideHandler, flag: FlagName = "ALL", info: string = ""): void {
+export function cmdWide(pattern: string, handler: WideHandler, flag: FlagName = "all", info: string = ""): void {
 	_clcmd(pattern, hostIndex(handler, true), flagOf(flag), info, SHAPE_WIDE);
 }
 
@@ -3513,11 +4091,11 @@ export function clearInterval(handle: number): void {
 @external("env", "call") declare function _call(id: i32, args: i32, mask: i32, argc: i32): i32;
 
 // WebAssembly fixes an import's arity, so a native with a `...` tail cannot be
-// declared in ~/natives at all - only its id is - and the module cannot infer
+// declared in @amxts/core/natives at all - only its id is - and the module cannot infer
 // the tail's types.
 /**
  * A call of a Pawn native with a `...` tail, built one argument at a time -
- * the low-level way. A native from `~/natives` is an ordinary function and
+ * the low-level way. A native from `@amxts/core/natives` is an ordinary function and
  * needs none of this.
  *
  *   new Call(NATIVE_server_print).str("%s").str(text).run();
@@ -3651,6 +4229,28 @@ export class Call {
 		return unchecked(this.cells[index]);
 	}
 
+	/** The number of arguments added so far: the position the next one takes. */
+	get count(): i32 {
+		return this.n;
+	}
+
+	/**
+	 * Adds room for text the native writes, in a `...` tail, holding `text` to
+	 * begin with; its length follows by address, as `ret[], len` wants it.
+	 * After `run` the text is in `cellsAt` of this position.
+	 */
+	textInto(text: string, length: i32): Call {
+		const cells = new StaticArray<i32>(length + 1);
+		__writeCellText(text, cells);
+		this.hold(cells);
+		return this.push(changetype<i32>(cells), 0x62).ref(length); // b
+	}
+
+	/** The cells at the address of the argument at this position, after `run`: a vector or text the native wrote. */
+	cellsAt(index: i32): StaticArray<i32> {
+		return changetype<StaticArray<i32>>(unchecked(this.args[index]));
+	}
+
 	/** Calls the native with the arguments added so far and returns its result. */
 	run(): number {
 		return _call(this.id, changetype<i32>(this.args), changetype<i32>(this.mask), this.n);
@@ -3668,10 +4268,139 @@ function arrayCells(values: number[], floats: bool): StaticArray<i32> {
 	return cells;
 }
 
+// ---------------------------------------------------------------- a native's `...` tail
+
+/** The longest text a native writes into a `Ref<string>`, in bytes. */
+const REF_TEXT: i32 = 1023;
+
+/**
+ * A value a native writes back through its argument, where Pawn passes a
+ * variable for the native to fill: text into `ret[], len`, a number into
+ * `&value`. Give it where the native takes one; after the call, `value` is
+ * what the native wrote.
+ *
+ * ```ts
+ * const reason = new Ref("");
+ * if (!dllfunc(DLLFunc_ClientConnect, id, "Bot", "127.0.0.1", reason)) console.log(reason.value);
+ * ```
+ */
+export class Ref<T> {
+	constructor(/** The value the native wrote; before the call, the one it starts with. */ public value: T) {}
+
+	/** @hidden Adds this to a call: text as room to write in with its length, a number or a boolean by address. */
+	__push(call: Call, float: bool): void {
+		const value = this.value;
+		if (isString<T>()) call.textInto(changetype<string>(value), REF_TEXT);
+		else if (isBoolean<T>()) call.ref(value ? 1 : 0);
+		else if (isFloat<T>() || isInteger<T>()) call.ref(float ? floatCell(<f64>value) : <i32><f64>value);
+		else ERROR("a Ref holds text, a number or a boolean");
+	}
+
+	/** @hidden Reads what the native wrote at this position of the call. */
+	__back(call: Call, at: i32, float: bool): void {
+		if (isString<T>()) this.value = changetype<T>(cellsToString(call.cellsAt(at)));
+		else if (isBoolean<T>()) this.value = <T>(call.out(at) != 0);
+		else this.value = <T>(float ? cellFloat(call.out(at)) : <f64>call.out(at));
+	}
+}
+
+/**
+ * One argument of a native's `...` tail, by its type: a number or a boolean
+ * by address (a number as a Float where `float` says), text as it is, a
+ * Vector or `[x, y, z]` as three Floats, a Player or an Entity as its index,
+ * a Ref as room for what the native writes; nothing for an argument left
+ * out. Each branch is decided as it compiles, so the conditions are the
+ * compiler's own. Returns the argument's position in the call, for tailBack.
+ */
+function tailArgument<T>(call: Call, value: T, float: bool): i32 {
+	const at = call.count;
+	if (isString<T>()) {
+		call.str(changetype<string>(value));
+	} else if (isBoolean<T>()) {
+		call.ref(value ? 1 : 0);
+	} else if (!isReference<T>()) {
+		call.ref(float ? floatCell(<f64>value) : <i32><f64>value);
+	} else if (isArray<T>()) {
+		// @ts-ignore: valueof is AssemblyScript's
+		if (!isFloat<valueof<T>>()) ERROR("a native's `...` takes a vector as a Vector or [x, y, z]");
+		const values = changetype<number[]>(value);
+		call.vec(values.length > 0 ? values[0] : 0, values.length > 1 ? values[1] : 0, values.length > 2 ? values[2] : 0);
+	// @ts-ignore: a Ref's method, looked for at compile time
+	} else if (isDefined(changetype<T>(0).__push)) {
+		// @ts-ignore: T is a Ref here
+		changetype<T>(value).__push(call, float);
+	// @ts-ignore: a Player's or an Entity's index, looked for at compile time
+	} else if (isDefined(changetype<T>(0).id)) {
+		// @ts-ignore: T has an id here
+		call.ref(value ? <i32>changetype<T>(value).id : 0);
+	} else if (idof<T>() != idof<NoArgument>()) {
+		ERROR("a native's `...` takes a number, a boolean, text, a Vector or [x, y, z], a Player, an Entity or a Ref");
+	}
+	return at;
+}
+
+/** What the native wrote back into the argument at `at`: a vector's numbers, a Ref's value. */
+function tailBack<T>(call: Call, value: T, at: i32, float: bool): void {
+	if (isArray<T>()) {
+		const values = changetype<number[]>(value);
+		const cells = call.cellsAt(at);
+		for (let i = 0; i < min(values.length, 3); i++) values[i] = cellFloat(unchecked(cells[i]));
+	// @ts-ignore: a Ref's method, looked for at compile time
+	} else if (isDefined(changetype<T>(0).__back)) {
+		// @ts-ignore: T is a Ref here
+		changetype<T>(value).__back(call, at, float);
+	}
+}
+
+/** @hidden What an argument left out of a native's `...` tail stands at: nothing is sent for it. */
+export function __noArgument<T>(): T {
+	return zeroOf<T>();
+}
+
+/** In a native's float table: its result is a Float. Bit `i` below it: the tail's argument `i` is one. */
+const TAIL_FLOAT_RESULT: i32 = 1 << 16;
+
+/**
+ * @hidden A native's `...` tail of up to twelve arguments of any kind, onto
+ * `call`, and the call run: what the generated wrappers of @amxts/core/natives call.
+ * `floats` is the native's float table for this call (bit `i`: the tail's
+ * argument `i` is a Float; TAIL_FLOAT_RESULT: so is the result) - a
+ * plugin's number cannot say whether it is one. What the native wrote into
+ * a vector or a Ref is read back into it.
+ */
+export function __callTail<A, B, C, D, E, F, G, H, I, J, K, L>(call: Call, floats: i32, a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L): number {
+	const at0 = tailArgument<A>(call, a, (floats & 1) != 0);
+	const at1 = tailArgument<B>(call, b, (floats & 2) != 0);
+	const at2 = tailArgument<C>(call, c, (floats & 4) != 0);
+	const at3 = tailArgument<D>(call, d, (floats & 8) != 0);
+	const at4 = tailArgument<E>(call, e, (floats & 16) != 0);
+	const at5 = tailArgument<F>(call, f, (floats & 32) != 0);
+	const at6 = tailArgument<G>(call, g, (floats & 64) != 0);
+	const at7 = tailArgument<H>(call, h, (floats & 128) != 0);
+	const at8 = tailArgument<I>(call, i, (floats & 256) != 0);
+	const at9 = tailArgument<J>(call, j, (floats & 512) != 0);
+	const at10 = tailArgument<K>(call, k, (floats & 1024) != 0);
+	const at11 = tailArgument<L>(call, l, (floats & 2048) != 0);
+	const result = call.run();
+	tailBack<A>(call, a, at0, (floats & 1) != 0);
+	tailBack<B>(call, b, at1, (floats & 2) != 0);
+	tailBack<C>(call, c, at2, (floats & 4) != 0);
+	tailBack<D>(call, d, at3, (floats & 8) != 0);
+	tailBack<E>(call, e, at4, (floats & 16) != 0);
+	tailBack<F>(call, f, at5, (floats & 32) != 0);
+	tailBack<G>(call, g, at6, (floats & 64) != 0);
+	tailBack<H>(call, h, at7, (floats & 128) != 0);
+	tailBack<I>(call, i, at8, (floats & 256) != 0);
+	tailBack<J>(call, j, at9, (floats & 512) != 0);
+	tailBack<K>(call, k, at10, (floats & 1024) != 0);
+	tailBack<L>(call, l, at11, (floats & 2048) != 0);
+	return (floats & TAIL_FLOAT_RESULT) != 0 ? cellFloat(result) : result;
+}
+
 // ---------------------------------------------------------------- field natives
 
 // What a field of reapi's field natives - get_entvar, get_member, get_pmove -
-// holds, as the generated __<native>_kind tables of ~/natives say
+// holds, as the generated __<native>_kind tables of @amxts/core/natives say
 // (scripts/generate-wasm-api.ts): a whole number, a Float, a vector or text,
 // and FIELD_ELEMENT on top for an array member.
 const FIELD_FLOAT: i32 = 1;
@@ -3834,6 +4563,58 @@ export interface ModuleOptions {}
 	return definition;
 }
 
+// A shared module's side of the calls other plugins make to it: as/remote.ts
+// sets the plugin whose call runs and tells of a plugin that stopped. Here,
+// not there, so that the kit's words reach the editor.
+let callingRun: i32 = 0;
+const stopListeners: ((plugin: number) => void)[] = [];
+
+/**
+ * The plugin whose call the module runs now, as a number: what the module
+ * keeps for that plugin - a menu it made, a function it gave - is marked with
+ * it, and dropped when `onPluginStop()` gives the same number. `0` when no
+ * other plugin's call runs: the module's own plugin, its natives for Pawn
+ * plugins, its events and timers.
+ *
+ * ```ts
+ * export function addRule(test: Rule) {
+ * 	rules.push({ test, from: callingPlugin() });
+ * }
+ * ```
+ */
+export function callingPlugin(): number {
+	return callingRun;
+}
+
+/**
+ * Calls `listener` when a plugin that called the module stops - unloaded,
+ * reloaded, or its load failed - with the number `callingPlugin()` gave
+ * during its calls. The module drops what that plugin gave it: a reloaded
+ * plugin is a new one, which gives everything again, and a function of the
+ * one that stopped answers nothing.
+ *
+ * ```ts
+ * onPluginStop((plugin) => {
+ * 	rules = rules.filter(rule => rule.from != plugin);
+ * });
+ * ```
+ */
+export function onPluginStop(listener: (plugin: number) => void): void {
+	stopListeners.push(listener);
+}
+
+/** @hidden as/remote.ts: a call of the run `from` starts; the run whose call ran before it, to give back. */
+export function __callFrom(from: i32): i32 {
+	const outer = callingRun;
+	callingRun = from;
+	return outer;
+}
+
+/** @hidden as/remote.ts: the plugin of the run `run` stopped. */
+export function __pluginStopped(run: i32): void {
+	for (const listener of stopListeners) listener(run);
+}
+
 // ---------------------------------------------------------------- forwards
 
 // @ts-ignore: decorator
@@ -3881,6 +4662,20 @@ const WINNER_NAMES: RoundWinner[] = ["none", "CT", "TERRORIST", "draw"];
 /** The reason a round ends with, by WinStatus number: rg_round_end's `event`. */
 const ROUND_REASONS: i32[] = [ROUND_NONE, ROUND_CTS_WIN, ROUND_TERRORISTS_WIN, ROUND_END_DRAW];
 
+// The game's message and radio phrase for a round's end, by WinStatus
+// number: what rg_round_end's "default" stands for.
+const ROUND_MESSAGES: string[] = ["", "#CTs_Win", "#Terrorists_Win", "#Round_Draw"];
+const ROUND_SOUNDS: string[] = ["", "ctwin", "terwin", "rounddraw"];
+
+/** A radio phrase to everyone, as the game broadcasts the round's end. */
+function broadcastAudio(sample: string): void {
+	message_begin(MSG_ALL, get_user_msgid("SendAudio"), [0, 0, 0], 0);
+	write_byte(0);
+	write_string(sample);
+	write_short(100);
+	message_end();
+}
+
 /** A name that crosses as a number - a Team or a RoundWinner - as that number. */
 function nameCell(name: string, crossing: string): i32 {
 	if (crossing == CROSS_WINNER) return max(WINNER_NAMES.indexOf(name as RoundWinner), 0);
@@ -4372,6 +5167,8 @@ import { GameAnswerMap, GameEventMap, addGameListener, removeGameListener } from
 // Three numbers with vector math - what entity.origin and the rest return.
 export * from "./vector";
 export * from "./effects";
+// fetch, URL and useFetch, over the module's network client.
+export * from "./fetch";
 export { EntityFilter } from "./entities";
 
 // =============================================================================
@@ -4637,3 +5434,226 @@ export function showMenu(id: number, keys: number, text: string, title: string):
 	// game's 175 bytes itself.
 	show_menu(id, keys, menuColors(text), -1, title);
 }
+
+// ---------------------------------------------------------------- menus
+
+// AMX Mod X's own menus (newmenus) as an object: `new Menu(title)`, items
+// with a title, a test for when each is shown and when it can be chosen, and
+// what choosing it does; `show(player, data)`. AMX Mod X draws the pages,
+// Back, More and Exit.
+//
+// What a menu shows depends on the player and the data it is shown with, so
+// each show() builds AMX Mod X's menu afresh - the title and every item's
+// title, `visible` and `enabled` asked then, for that player - and the menu
+// is destroyed when the player chooses or leaves it: the handler AMX Mod X
+// calls once per display destroys it before it runs the item. Every menu of
+// a plugin answers through one public, which finds the item by the menu's id;
+// a grey item is one an item callback that always says ITEM_DISABLED draws.
+// A menu left open by a plugin a reload took away answers the new one's
+// public, which knows nothing of it and destroys it.
+import { menu_additem, menu_create, menu_destroy, menu_display, menu_makecallback, NATIVE_menu_setprop } from "./natives";
+import {
+	ITEM_DISABLED, MEXIT_NEVER, MPROP_BACKNAME, MPROP_EXIT, MPROP_EXITNAME, MPROP_NEXTNAME, MPROP_NUMBER_COLOR, MPROP_PERPAGE
+} from "./constants";
+
+/** A colour of a menu's item numbers: a menu's colour tag, `"!y"`, `"!r"`, `"!d"` or `"!w"`. */
+export type MenuColor = "!y" | "!r" | "!d" | "!w";
+
+/** The options of a `Menu`: its pages and the texts of its own items. */
+export interface MenuOptions {
+	/**
+	 * Items on a page, `7` at most: Back, More and Exit go below them. `0`
+	 * puts every item on one page, without Back and More - `10` at most.
+	 *
+	 * Pawn: `MPROP_PERPAGE`
+	 */
+	perPage?: number;
+	/**
+	 * Whether the menu has an Exit item; `true` by default.
+	 *
+	 * Pawn: `MPROP_EXIT`
+	 */
+	exit?: boolean;
+	/**
+	 * The Back item's text; AMX Mod X's `"Back"`, in the player's language, by default.
+	 *
+	 * Pawn: `MPROP_BACKNAME`
+	 */
+	backText?: string;
+	/**
+	 * The More item's text; AMX Mod X's `"More"` by default.
+	 *
+	 * Pawn: `MPROP_NEXTNAME`
+	 */
+	nextText?: string;
+	/**
+	 * The Exit item's text; AMX Mod X's `"Exit"` by default.
+	 *
+	 * Pawn: `MPROP_EXITNAME`
+	 */
+	exitText?: string;
+	/**
+	 * The colour of the item numbers; `"!r"`, red, by default.
+	 *
+	 * Pawn: `MPROP_NUMBER_COLOR`
+	 */
+	numberColor?: MenuColor;
+}
+
+/** The context a menu's functions get: the player it is shown to, the menu and the data it was shown with. */
+export interface MenuContext<Data extends object = object> {
+	/** The player the menu is shown to. */
+	player: Player;
+	/** The menu itself: `menu.show(player, data)` keeps it open after a choice. */
+	menu: Menu<Data>;
+	/** The data `show` was given. */
+	data: Data;
+}
+
+/** An item of a `Menu`: its title, when it is shown and can be chosen, and what choosing it does. */
+export interface MenuItemOptions<Data extends object = object> {
+	/** The item's text - or a function that gives it for the player it is shown to. */
+	title: string | ((context: MenuContext<Data>) => string);
+	/** Whether the player can choose it; one he cannot is drawn grey and does nothing. `true` by default. */
+	enabled?: boolean | ((context: MenuContext<Data>) => boolean);
+	/** Whether it is shown at all; a hidden item takes no place. `true` by default. */
+	visible?: boolean | ((context: MenuContext<Data>) => boolean);
+	/** The item's action, run when the player chooses it. The menu closes, unless this shows it again. */
+	onSelect: (context: MenuContext<Data>) => void;
+}
+
+// The menus on players' screens, by AMX Mod X's id: what choosing item N of
+// each runs.
+const shownMenus = new Map<i32, (item: i32) => void>();
+let menuHandler = "";
+let greyItem: i32 = -1;
+
+/** A player chose an item of a menu this plugin showed - or left it, an item below `0`. */
+function menuChosen(player: number, menu: number, item: number, unused: number): void {
+	const id = <i32>menu;
+	const choose = shownMenus.has(id) ? shownMenus.get(id) : null;
+	shownMenus.delete(id);
+	menu_destroy(id);
+
+	if (choose != null && item >= 0) {
+		const ambient = __co_ambient_player;
+		__co_ambient_player = <i32>player;
+		choose(<i32>item);
+		__co_ambient_player = ambient;
+	}
+	handled();
+}
+
+/** An item AMX Mod X draws grey: the item callback of the items that cannot be chosen. */
+function itemDisabled(player: number, menu: number, item: number, unused: number): void {
+	ret(ITEM_DISABLED);
+}
+
+/** Sets a menu property that is text, when it is given, its colour tags made the game's codes. */
+function setMenuText(menu: i32, prop: i32, text: string | undefined): void {
+	if (text !== undefined) new Call(NATIVE_menu_setprop).num(menu).num(prop).str(menuColors(text)).run();
+}
+
+/** A text given as `string | ((context) => string)`: the compiler holds it as the function, a string as one that returns it. */
+function menuText<C>(text: string | ((context: C) => string), context: C): string {
+	// @ts-ignore: a function here - the editor sees the union
+	return menuColors(text(context));
+}
+
+/** A test given as `boolean | ((context) => boolean)`, held as the function as a text is; left out, it says yes. */
+function menuTest<C>(test: boolean | ((context: C) => boolean) | undefined, context: C): boolean {
+	// @ts-ignore: a function or null here - the editor sees the union
+	return test == null || test(context);
+}
+
+/**
+ * A menu of AMX Mod X's own: items a player picks with the number keys, on
+ * pages with Back and More, and Exit. `Data` is what it is shown with, which
+ * its functions get beside the player.
+ *
+ * ```ts
+ * interface ShopData {
+ *   category: string;
+ * }
+ *
+ * const shop = new Menu<ShopData>("!yShop");
+ * shop.addItem({
+ *   title: "Armor - $1000",
+ *   enabled: ({ player }) => player.armor < 100,
+ *   onSelect: ({ player }) => {
+ *     player.armor = 100;
+ *   },
+ * });
+ * shop.show(player, { category: "armor" });
+ * ```
+ *
+ * The title and each item's title, `visible` and `enabled` are asked at
+ * every `show`, for that player. Colour tags as in `showMenu`: `!y` yellow,
+ * `!r` red, `!d` grey, `!w` white, `!R` to the right edge.
+ *
+ * Pawn: `menu_create`, `menu_setprop`
+ */
+export class Menu<Data extends object = object> {
+	private readonly items: MenuItemOptions<Data>[] = [];
+
+	constructor(
+		private readonly title: string | ((context: MenuContext<Data>) => string),
+		private readonly options: MenuOptions = {}
+	) {
+		// Asked for now, not at the first show: after a reload, a menu the last
+		// start left open answers here, and is destroyed.
+		if (menuHandler.length == 0) menuHandler = callbackName(menuChosen, "menu");
+	}
+
+	/**
+	 * Adds an item: its title, when it is shown and can be chosen, and what
+	 * choosing it does.
+	 *
+	 * ```ts
+	 * shop.addItem({
+	 *   title: ({ player }) => `Heal (${player.health} HP)`,
+	 *   visible: ({ player }) => player.isAlive,
+	 *   enabled: ({ player }) => player.health < 100,
+	 *   onSelect: ({ player }) => {
+	 *     player.health = 100;
+	 *   },
+	 * });
+	 * ```
+	 *
+	 * Pawn: `menu_additem`
+	 */
+	addItem(item: MenuItemOptions<Data>): void {
+		this.items.push(item);
+	}
+
+	/**
+	 * Shows the menu to a player, with the data its functions get; it closes
+	 * when he chooses an item or leaves it.
+	 *
+	 * Pawn: `menu_display`
+	 */
+	show(player: Player, data: Data | null = null): void {
+		const context: MenuContext<Data> = { player, menu: this, data: changetype<Data>(data) };
+		const id = menu_create(menuText(this.title, context), menuHandler);
+
+		const options = this.options;
+		const perPage = options.perPage;
+		if (perPage !== undefined) new Call(NATIVE_menu_setprop).num(id).num(MPROP_PERPAGE).ref(perPage).run();
+		if (options.exit == false) new Call(NATIVE_menu_setprop).num(id).num(MPROP_EXIT).ref(MEXIT_NEVER).run();
+		setMenuText(id, MPROP_BACKNAME, options.backText);
+		setMenuText(id, MPROP_NEXTNAME, options.nextText);
+		setMenuText(id, MPROP_EXITNAME, options.exitText);
+		setMenuText(id, MPROP_NUMBER_COLOR, options.numberColor);
+
+		const shown = this.items.filter((item: MenuItemOptions<Data>) => menuTest(item.visible, context));
+		for (let i = 0; i < shown.length; i++) {
+			const item = shown[i];
+			const enabled = menuTest(item.enabled, context);
+			if (!enabled && greyItem < 0) greyItem = menu_makecallback(callbackName(itemDisabled, "menu-grey"));
+			menu_additem(id, menuText(item.title, context), "", 0, enabled ? -1 : greyItem);
+		}
+
+		shownMenus.set(id, (item: i32) => shown[item].onSelect(context));
+		menu_display(player.id, id);
+	}
+}