@amxts/core 0.1.0 → 0.2.0

package/scripts/client-messages.ts

@@ -0,0 +1,246 @@
+// The messages Counter-Strike's server sends its clients, as
+// server.addMessageListener(name, ...) hears them - read by
+// scripts/generate-host.ts, which writes their events into as/events.ts.
+//
+// Every name the game registers is a message a plugin can listen to, by the
+// name MESSAGE_NAMES gives it in the player's words: `death`, not `DeathMsg`.
+// The game's own name stays in the tooltip and in `event.name`, where someone
+// porting a Pawn plugin looks for it. MESSAGE_FIELDS is the one table
+// of the layouts the game writes them in: a message there is a class of its
+// own with a typed field per argument it names (1 is the first write_*),
+// read and written as the kind says; one without a known layout - a bot's
+// progress, a tutor's text - is read by place, through `event.args`. Every
+// message has `args` too, for what the table leaves out. `player` is every
+// message's receiver, so a player an argument names is `target` (or its
+// role: `killer`, `sender`). The words are scripts/docs/messages.ts's.
+//
+// A name hears one message, or a few that are the same thing to an author:
+// `progressBar` is BarTime and BarTime2, which only adds where the bar
+// starts. Its event has the fields of them all, each at the same argument in
+// every one that writes it; a field one of them lacks reads as empty there,
+// as an argument past the last does.
+
+/**
+ * What an argument is read as: a number, a boolean, text; `texts` every text
+ * from the argument on (the words a game text puts in); `player` a player's
+ * number, `0` none (`Player | null`); `weapon` a weapon's id as WeaponKind
+ * names it; `team` a TeamName number and `teamName` a team written as text,
+ * both a Team; `vector` three coordinates from the argument on; `color`
+ * `size` bytes from it, red, green, blue (and alpha); `fixed` a number of
+ * `scale` parts to one (a time in 1/4096 s); `bit` whether `mask`'s bit is
+ * set; `fadeDirection` ScreenFade's FFADE_OUT bit as FadeDirection;
+ * `hideHud`, `damage`, `scoreStatus` a mask as an array of HideHud, Damage,
+ * ScoreStatus names; `statusIcon` StatusIcon's state (0 hide, 1 show,
+ * 2 flash); `destination` TextMsg's (1 notify, 2 console, 3 chat, 4 center);
+ * `vguiMenu` a VGUIMenu number as VguiMenu names it.
+ */
+export type MessageFieldKind = 'number' | 'boolean' | 'string' | 'texts' | 'player' | 'weapon' | 'team' | 'teamName' | 'vector' | 'color' | 'fixed' | 'bit' | 'fadeDirection' | 'hideHud' | 'damage' | 'scoreStatus' | 'statusIcon' | 'destination' | 'vguiMenu';
+
+export interface MessageField {
+	name: string;
+	/** The argument's number, 1 for the first. */
+	arg: number;
+	kind: MessageFieldKind;
+	/** `fixed`: the parts that make one. `bit`: the bit. `color`: the bytes. */
+	of?: number;
+}
+
+const f = (name: string, arg: number, kind: MessageFieldKind, of?: number): MessageField => ({ name, arg, kind, ...(of === undefined ? {} : { of }) });
+
+/** The messages whose layout is known, each argument a field. */
+export const MESSAGE_FIELDS: Record<string, MessageField[]> = {
+	ADStop: [],
+	AllowSpec: [f('allowed', 1, 'boolean')],
+	AmmoPickup: [f('ammo', 1, 'number'), f('amount', 2, 'number')],
+	AmmoX: [f('ammo', 1, 'number'), f('amount', 2, 'number')],
+	ArmorType: [f('helmet', 1, 'boolean')],
+	BarTime: [f('seconds', 1, 'number')],
+	BarTime2: [f('seconds', 1, 'number'), f('startPercent', 2, 'number')],
+	Battery: [f('armor', 1, 'number')],
+	BlinkAcct: [f('blinks', 1, 'number')],
+	BombDrop: [f('origin', 1, 'vector'), f('planted', 4, 'boolean')],
+	BombPickup: [],
+	BotVoice: [f('talking', 1, 'boolean'), f('target', 2, 'player')],
+	BuyClose: [],
+	ClCorpse: [f('model', 1, 'string'), f('team', 11, 'team'), f('target', 12, 'player')],
+	Crosshair: [f('shown', 1, 'boolean')],
+	CurWeapon: [f('active', 1, 'boolean'), f('weapon', 2, 'weapon'), f('clip', 3, 'number')],
+	Damage: [f('armor', 1, 'number'), f('damage', 2, 'number'), f('damageType', 3, 'damage'), f('origin', 4, 'vector')],
+	DeathMsg: [f('killer', 1, 'player'), f('victim', 2, 'player'), f('headshot', 3, 'boolean'), f('weapon', 4, 'string')],
+	Flashlight: [f('on', 1, 'boolean'), f('battery', 2, 'number')],
+	FlashBat: [f('battery', 1, 'number')],
+	Geiger: [f('range', 1, 'number')],
+	Health: [f('health', 1, 'number')],
+	HideWeapon: [f('flags', 1, 'hideHud')],
+	HostageK: [f('hostage', 1, 'number')],
+	HostagePos: [f('hostage', 2, 'number'), f('origin', 3, 'vector')],
+	HudText: [f('text', 1, 'string')],
+	HudTextArgs: [f('text', 1, 'string'), f('params', 4, 'texts')],
+	HudTextPro: [f('text', 1, 'string')],
+	InitHUD: [],
+	ItemPickup: [f('item', 1, 'string')],
+	ItemStatus: [f('nightVision', 1, 'bit', 1), f('defuseKit', 1, 'bit', 2)],
+	Location: [f('target', 1, 'player'), f('place', 2, 'string')],
+	Money: [f('amount', 1, 'number'), f('flash', 2, 'boolean')],
+	MOTD: [f('last', 1, 'boolean'), f('text', 2, 'string')],
+	NVGToggle: [f('on', 1, 'boolean')],
+	Radar: [f('target', 1, 'player'), f('origin', 2, 'vector')],
+	ReqState: [],
+	ResetHUD: [],
+	RoundTime: [f('seconds', 1, 'number')],
+	SayText: [f('sender', 1, 'player'), f('text', 2, 'string'), f('params', 3, 'texts')],
+	Scenario: [f('active', 1, 'boolean'), f('sprite', 2, 'string'), f('alpha', 3, 'number')],
+	ScoreAttrib: [f('target', 1, 'player'), f('flags', 2, 'scoreStatus')],
+	ScoreInfo: [f('target', 1, 'player'), f('frags', 2, 'number'), f('deaths', 3, 'number'), f('team', 5, 'team')],
+	ScreenFade: [
+		f('duration', 1, 'fixed', 4096),
+		f('hold', 2, 'fixed', 4096),
+		f('direction', 3, 'fadeDirection'),
+		f('modulate', 3, 'bit', 2),
+		f('stay', 3, 'bit', 4),
+		f('color', 4, 'color', 4),
+	],
+	ScreenShake: [f('amplitude', 1, 'fixed', 4096), f('duration', 2, 'fixed', 4096), f('frequency', 3, 'fixed', 256)],
+	SendAudio: [f('sender', 1, 'player'), f('sound', 2, 'string'), f('pitch', 3, 'number')],
+	ServerName: [f('serverName', 1, 'string')],
+	SetFOV: [f('fov', 1, 'number')],
+	ShowMenu: [f('more', 3, 'boolean'), f('text', 4, 'string')],
+	ShowTimer: [],
+	SpecHealth: [f('health', 1, 'number')],
+	SpecHealth2: [f('health', 1, 'number'), f('target', 2, 'player')],
+	Spectator: [f('target', 1, 'player'), f('spectator', 2, 'boolean')],
+	StatusIcon: [f('state', 1, 'statusIcon'), f('sprite', 2, 'string'), f('color', 3, 'color', 3)],
+	StatusText: [f('line', 1, 'number'), f('text', 2, 'string')],
+	StatusValue: [f('slot', 1, 'number'), f('value', 2, 'number')],
+	TaskTime: [f('seconds', 1, 'number'), f('active', 2, 'boolean'), f('fade', 3, 'number')],
+	TeamInfo: [f('target', 1, 'player'), f('team', 2, 'teamName')],
+	TeamScore: [f('team', 1, 'teamName'), f('score', 2, 'number')],
+	TextMsg: [f('destination', 1, 'destination'), f('text', 2, 'string'), f('params', 3, 'texts')],
+	Train: [f('speed', 1, 'number')],
+	TutorClose: [],
+	VGUIMenu: [f('menu', 1, 'vguiMenu')],
+	ViewMode: [],
+	WeaponList: [
+		f('classname', 1, 'string'),
+		f('ammo', 2, 'number'),
+		f('maxAmmo', 3, 'number'),
+		f('ammo2', 4, 'number'),
+		f('maxAmmo2', 5, 'number'),
+		f('slot', 6, 'number'),
+		f('position', 7, 'number'),
+		f('weapon', 8, 'weapon'),
+	],
+	WeapPickup: [f('weapon', 1, 'weapon')],
+};
+
+/** Every message Counter-Strike 1.6 registers, by the name get_user_msgid takes. */
+export const CLIENT_MESSAGES = `
+	ADStop AllowSpec AmmoPickup AmmoX ArmorType BarTime BarTime2 Battery BlinkAcct BombDrop BombPickup
+	BotProgress BotVoice Brass BuyClose ClCorpse Crosshair CurWeapon CZCareer CZCareerHUD Damage
+	DeathMsg Flashlight FlashBat Fog ForceCam GameMode GameTitle Geiger Health HideWeapon HLTV HostageK
+	HostagePos HudText HudTextArgs HudTextPro InitHUD ItemPickup ItemStatus Location Money MOTD
+	NVGToggle Radar ReceiveW ReloadSound ReqState ResetHUD RoundTime SayText Scenario ScoreAttrib
+	ScoreInfo ScreenFade ScreenShake SendAudio ServerName SetFOV ShadowIdx ShowMenu ShowTimer
+	SpecHealth SpecHealth2 Spectator StatusIcon StatusText StatusValue TaskTime TeamInfo TeamScore
+	TextMsg Train TutorClose TutorLine TutorState TutorText VGUIMenu ViewMode VoiceMask WeaponList
+	WeapPickup
+`.trim().split(/\s+/);
+
+/**
+ * Every message's name in the player's words, by the game's: lowerCamelCase,
+ * without the protocol's `Msg`, an abbreviation spelled out (`CurWeapon` is
+ * `currentWeapon`, `SetFOV` `fov`) and an opaque name given its meaning
+ * (`SayText` is `chat`, `Battery` `armor`, `ShowMenu` `menu`). Messages that
+ * are one thing to an author share a name (`BarTime`, `BarTime2`).
+ */
+export const MESSAGE_NAMES: Record<string, string> = {
+	ADStop: 'adStop',
+	AllowSpec: 'allowSpectate',
+	AmmoPickup: 'ammoPickup',
+	AmmoX: 'ammo',
+	ArmorType: 'armorType',
+	BarTime: 'progressBar',
+	BarTime2: 'progressBar',
+	Battery: 'armor',
+	BlinkAcct: 'moneyBlink',
+	BombDrop: 'bombDrop',
+	BombPickup: 'bombPickup',
+	BotProgress: 'botProgress',
+	BotVoice: 'botVoice',
+	Brass: 'shellCasing',
+	BuyClose: 'closeBuyMenu',
+	ClCorpse: 'corpse',
+	Crosshair: 'crosshair',
+	CurWeapon: 'currentWeapon',
+	CZCareer: 'czCareer',
+	CZCareerHUD: 'czCareerHud',
+	Damage: 'damage',
+	DeathMsg: 'death',
+	Flashlight: 'flashlight',
+	FlashBat: 'flashlightBattery',
+	Fog: 'fog',
+	ForceCam: 'forceCamera',
+	GameMode: 'gameMode',
+	GameTitle: 'gameTitle',
+	Geiger: 'geiger',
+	Health: 'health',
+	HideWeapon: 'hideWeapon',
+	HLTV: 'hltv',
+	HostageK: 'hostageKilled',
+	HostagePos: 'hostagePosition',
+	HudText: 'hint',
+	HudTextArgs: 'hint',
+	HudTextPro: 'hint',
+	InitHUD: 'initHud',
+	ItemPickup: 'itemPickup',
+	ItemStatus: 'itemStatus',
+	Location: 'location',
+	Money: 'money',
+	MOTD: 'motd',
+	NVGToggle: 'nightVision',
+	Radar: 'radar',
+	ReceiveW: 'weather',
+	ReloadSound: 'reloadSound',
+	ReqState: 'requestState',
+	ResetHUD: 'resetHud',
+	RoundTime: 'roundTime',
+	SayText: 'chat',
+	Scenario: 'scenarioIcon',
+	ScoreAttrib: 'scoreAttribute',
+	ScoreInfo: 'score',
+	ScreenFade: 'screenFade',
+	ScreenShake: 'screenShake',
+	SendAudio: 'sound',
+	ServerName: 'serverName',
+	SetFOV: 'fov',
+	ShadowIdx: 'shadow',
+	ShowMenu: 'menu',
+	ShowTimer: 'showTimer',
+	SpecHealth: 'spectatedHealth',
+	SpecHealth2: 'spectatedHealth',
+	Spectator: 'spectator',
+	StatusIcon: 'statusIcon',
+	StatusText: 'statusText',
+	StatusValue: 'statusValue',
+	TaskTime: 'taskTime',
+	TeamInfo: 'team',
+	TeamScore: 'teamScore',
+	TextMsg: 'text',
+	Train: 'train',
+	TutorClose: 'tutorClose',
+	TutorLine: 'tutorLine',
+	TutorState: 'tutorState',
+	TutorText: 'tutorText',
+	VGUIMenu: 'vguiMenu',
+	ViewMode: 'viewMode',
+	VoiceMask: 'voiceMask',
+	WeaponList: 'weaponList',
+	WeapPickup: 'weaponPickup',
+};
+
+/** The names server.addMessageListener takes, each with the game's messages it hears, in the game's order. */
+export const MESSAGE_GROUPS = new Map<string, string[]>();
+for (const message of CLIENT_MESSAGES) {
+	const name = MESSAGE_NAMES[message];
+	if (name) MESSAGE_GROUPS.set(name, [...(MESSAGE_GROUPS.get(name) ?? []), message]);
+}

package/scripts/compile-pool.ts

@@ -0,0 +1,128 @@
+// Several plugins compiled at once. asc is not reentrant and a compile holds
+// about a gigabyte at its peak, so each runs in a process of its own
+// (scripts/compile-worker.ts), as many at once as the CPUs and the memory
+// budget allow: AMXTS_BUILD_MEMORY megabytes for all of them (3072), or
+// AMXTS_BUILD_JOBS compiles. A single plugin, or room for one, is compiled in
+// this process. Either way a plugin compiles to the same bytes.
+import type { Plugin } from './compile';
+import type { NativesBeside, PluginNative } from './plugin-natives';
+import { spawn } from 'node:child_process';
+import { availableParallelism } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { setNativesBeside } from './plugin-natives';
+
+const MB = 1024 * 1024;
+
+/** A compile's peak, asc's and wamrc's together: measured at about a gigabyte, with room. */
+export const COMPILE_MEMORY = 1280 * MB;
+
+/** What the compiles of a build may hold together, unless AMXTS_BUILD_MEMORY says otherwise. */
+export const BUILD_MEMORY = 3072 * MB;
+
+const WORKER = join(dirname(fileURLToPath(import.meta.url)), 'compile-worker.ts');
+
+/** How many compiles run at once: AMXTS_BUILD_JOBS, else as many as the memory budget holds, at most one per CPU. */
+export function compileSlots(env: Record<string, string | undefined> = process.env, cpus = availableParallelism()): number {
+	const jobs = Number(env.AMXTS_BUILD_JOBS);
+	if (Number.isInteger(jobs) && jobs > 0) return jobs;
+	const budget = Number(env.AMXTS_BUILD_MEMORY) > 0 ? Number(env.AMXTS_BUILD_MEMORY) * MB : BUILD_MEMORY;
+	return Math.max(1, Math.min(cpus, Math.floor(budget / COMPILE_MEMORY)));
+}
+
+/**
+ * `run` on every item, at most `slots` at a time, each given the slot it runs
+ * in (0, 1, ...) and its index: the items start in order, and the results come
+ * back in it.
+ */
+export async function inSlots<T, R>(items: T[], slots: number, run: (item: T, slot: number, index: number) => Promise<R>): Promise<R[]> {
+	const results: R[] = Array.from({ length: items.length });
+	let next = 0;
+	const slot = async (number: number) => {
+		while (next < items.length) {
+			const index = next++;
+			results[index] = await run(items[index], number, index);
+		}
+	};
+	await Promise.all(Array.from({ length: Math.min(slots, items.length) }, (_, number) => slot(number)));
+	return results;
+}
+
+/** One plugin compiled: what went wrong, or null, and its natives. */
+export interface Compiled {
+	problem: string | null;
+	natives: PluginNative[];
+}
+
+/** What a worker is sent: the plugin, and the plugin cache it compiles through (scripts/plugin-cache.ts). */
+export interface WorkerJob {
+	plugin: Plugin;
+	/** The project, whose cache it is; null for none. */
+	dir: string | null;
+	/** The includes the build writes itself. */
+	includes: string[];
+}
+
+export type WorkerResult = Compiled & { beside: NativesBeside };
+
+/** A worker process: one job at a time, until it is closed. */
+function worker() {
+	const child = spawn(process.execPath, [WORKER], { stdio: ['ignore', 'inherit', 'inherit', 'ipc'] });
+	let waiting: { resolve: (result: WorkerResult) => void; reject: (error: Error) => void } | null = null;
+	const answer = () => {
+		const now = waiting;
+		waiting = null;
+		return now;
+	};
+	child.on('message', (result: WorkerResult) => answer()?.resolve(result));
+	child.on('exit', code => answer()?.reject(new Error(`a compile process stopped (exit ${code})`)));
+	return {
+		compile: (job: WorkerJob) => new Promise<WorkerResult>((resolve, reject) => {
+			waiting = { resolve, reject };
+			child.send(job);
+		}),
+		close: () => child.connected && child.disconnect(),
+	};
+}
+
+export interface CompileAll {
+	/** The project and the includes its builds write: the plugin cache's (null: none). */
+	dir: string | null;
+	includes: string[];
+	/** The compile in this process: the build's plugin cache. */
+	here: (plugin: Plugin, natives: PluginNative[]) => Promise<string | null>;
+	started?: (index: number) => void;
+	finished?: (index: number, compiled: Compiled) => void;
+}
+
+/**
+ * The plugins compiled, several at once when there is room - in this process
+ * when there is room for one. After a failure no other compile starts: those
+ * that did not are null.
+ */
+export async function compileAll(plugins: Plugin[], options: CompileAll): Promise<(Compiled | null)[]> {
+	const slots = Math.min(plugins.length, compileSlots());
+	const workers = slots > 1 ? Array.from({ length: slots }, worker) : [];
+	let failed = false;
+	const compile = async (plugin: Plugin, slot: number): Promise<Compiled> => {
+		if (workers.length === 0) {
+			const natives: PluginNative[] = [];
+			return { problem: await options.here(plugin, natives), natives };
+		}
+		const { beside, ...compiled } = await workers[slot].compile({ plugin, dir: options.dir, includes: options.includes });
+		setNativesBeside(compiled.natives, beside);
+		return compiled;
+	};
+	try {
+		return await inSlots(plugins, slots, async (plugin, slot, index) => {
+			if (failed) return null;
+			options.started?.(index);
+			const compiled = await compile(plugin, slot);
+			failed ||= compiled.problem !== null;
+			options.finished?.(index, compiled);
+			return compiled;
+		});
+	} finally {
+		for (const each of workers) each.close();
+	}
+}

package/scripts/compile-worker.ts

@@ -0,0 +1,23 @@
+// A compile process of scripts/compile-pool.ts: compiles the plugins it is
+// sent, one at a time, through the build's plugin cache (scripts/plugin-cache.ts),
+// and answers each with what went wrong and the plugin's natives. It ends when
+// the build disconnects.
+import type { WorkerJob, WorkerResult } from './compile-pool';
+import type { PluginNative } from './plugin-natives';
+import { pluginCache } from './plugin-cache';
+import { nativesBeside } from './plugin-natives';
+
+const caches = new Map<string, ReturnType<typeof pluginCache>>();
+
+process.on('message', async ({ plugin, dir, includes }: WorkerJob) => {
+	const key = JSON.stringify([dir, includes]);
+	if (!caches.has(key)) caches.set(key, pluginCache(dir, includes));
+	const natives: PluginNative[] = [];
+	let problem: string | null;
+	try {
+		problem = await caches.get(key)!.compile(plugin, natives);
+	} catch (error) {
+		problem = String((error as Error).stack ?? error);
+	}
+	process.send!({ problem, natives, beside: nativesBeside(natives) } satisfies WorkerResult);
+});