@amxts/core 0.2.3 → 0.3.0

package/as/promise.ts

@@ -30,6 +30,8 @@
 // (__tryDepth): the count is kept across an await and put back around a
 // spawn and a resume.
 
+import { __ServerEvent } from "./facade";
+
 // ---------------------------------------------------------------- host
 
 // @ts-ignore: decorator
@@ -41,11 +43,9 @@
 // @ts-ignore: decorator
 @external("env", "co_wake") declare function __co_host_wake(): void;
 // @ts-ignore: decorator
-@external("env", "co_id") declare function __co_host_id(): i32;
-// @ts-ignore: decorator
-@external("env", "task") declare function __co_host_task(secondsBits: i32, fn: i32, id: i32, repeat: i32): i32;
+@external("env", "task") declare function __co_host_task(secondsBits: i32, fn: i32, repeat: i32): i32;
 // @ts-ignore: decorator
-@external("env", "stop_task") declare function __co_host_stop_task(id: i32): i32;
+@external("env", "stop_task") declare function __co_host_stop_task(slot: i32): i32;
 // @ts-ignore: decorator
 @external("env", "on") declare function __co_host_on(event: string, fn: i32, shape: i32): void;
 
@@ -829,10 +829,15 @@ function __co_current(): __Coroutine {
 	return changetype<usize>(__spawnArgs);
 }
 
-/** @hidden a managed argument, held while the call lasts. */
+/**
+ * @hidden a managed argument, held while the call lasts. A server event's
+ * object is read after the call: it keeps its fields (__ServerEvent).
+ */
 // @ts-ignore: decorator
 @global function __co_keep(value: usize): void {
-	if (value != 0) __keep.push(changetype<Object>(value));
+	if (value == 0) return;
+	if (changetype<Object>(value) instanceof __ServerEvent) changetype<__ServerEvent>(value).__keep();
+	__keep.push(changetype<Object>(value));
 }
 
 /** @hidden runs an async function's body as a coroutine - see the top of this file. */
@@ -1167,9 +1172,8 @@ function __co_reportUnhandled(): void {
 	/** A signal that aborts by itself after `ms`, with an Error named `"TimeoutError"`. */
 	static timeout(ms: number): AbortSignal {
 		const signal = new AbortSignal();
-		const id = __co_host_id();
-		__timeouts.set(id, signal);
-		__co_host_task(reinterpret<i32>(<f32>(ms / 1000.0)), __co_timeoutFired.index, id, 0);
+		const slot = __co_host_task(reinterpret<i32>(<f32>(ms / 1000.0)), __co_timeoutFired.index, 0);
+		if (slot >= 0) __timeouts[slot] = signal;
 		return signal;
 	}
 
@@ -1263,13 +1267,14 @@ class __CoroutineAbort extends __AbortWatch {
 	}
 }
 
+// AbortSignal.timeout's signals, by the slot the module keeps their timers in.
 // @ts-ignore: decorator
-@lazy const __timeouts = new Map<i32, AbortSignal>();
+@lazy const __timeouts: (AbortSignal | null)[] = [];
 
-function __co_timeoutFired(id: i32): void {
-	if (!__timeouts.has(id)) return;
-	const signal = __timeouts.get(id);
-	__timeouts.delete(id);
+function __co_timeoutFired(slot: i32): void {
+	const signal = unchecked(__timeouts[slot]);
+	unchecked(__timeouts[slot] = null);
+	if (!signal) return;
 	const error = new Error("The operation was aborted due to timeout");
 	error.name = "TimeoutError";
 	signal.__abort(error);
@@ -1314,28 +1319,31 @@ function __co_timeoutFired(id: i32): void {
 class __Sleep extends __AbortWatch {
 	guard: __AbortGuard | null = null;
 
-	constructor(public promise: Promise<void>, public id: i32) {
+	// The slot the module keeps its timer in, -1 before it is armed.
+	slot: i32 = -1;
+
+	constructor(public promise: Promise<void>) {
 		super();
 	}
 
 	run(reason: Error): void {
-		if (!__sleeps.has(this.id)) return;
-		__sleeps.delete(this.id);
-		__co_host_stop_task(this.id);
+		if (this.slot < 0 || unchecked(__sleeps[this.slot]) != this) return;
+		unchecked(__sleeps[this.slot] = null);
+		__co_host_stop_task(this.slot);
 		(this.guard as __AbortGuard).release();
 		this.promise.__reject(reason);
 	}
 }
 
+// The sleeps that wait, by the slot the module keeps their timers in.
 // @ts-ignore: decorator
-@lazy const __sleeps = new Map<i32, __Sleep>();
+@lazy const __sleeps: (__Sleep | null)[] = [];
 
 /** @hidden the facade's sleep(): fulfilled after `ms`, rejected if a signal aborts first. */
 // @ts-ignore: decorator
 @global export function __co_sleep(ms: f64, signal: AbortSignal | null): Promise<void> {
 	const promise = __co_promise<void>();
-	const id = __co_host_id();
-	const sleep = new __Sleep(promise, id);
+	const sleep = new __Sleep(promise);
 	const guard = new __AbortGuard(sleep, signal);
 	sleep.guard = guard;
 
@@ -1346,15 +1354,17 @@ class __Sleep extends __AbortWatch {
 		return promise;
 	}
 
-	__sleeps.set(id, sleep);
-	__co_host_task(reinterpret<i32>(<f32>(ms / 1000.0)), __co_sleepFired.index, id, 0);
+	const slot = __co_host_task(reinterpret<i32>(<f32>(ms / 1000.0)), __co_sleepFired.index, 0);
+	if (slot < 0) return promise;
+	sleep.slot = slot;
+	__sleeps[slot] = sleep;
 	return promise;
 }
 
-function __co_sleepFired(id: i32): void {
-	if (!__sleeps.has(id)) return;
-	const sleep = __sleeps.get(id);
-	__sleeps.delete(id);
+function __co_sleepFired(slot: i32): void {
+	const sleep = unchecked(__sleeps[slot]);
+	unchecked(__sleeps[slot] = null);
+	if (!sleep) return;
 	(sleep.guard as __AbortGuard).release();
 	sleep.promise.__fulfillVoid();
 }

package/as/vector.ts

@@ -8,27 +8,45 @@
 
 /** Three numbers, x y z, with the math a plugin needs on them. */
 export class Vector extends Array<number> {
-	// x, y and z read and write their element without the index's check: a
-	// Vector is made with room for three, which a shorter length leaves in
-	// place, and the check was a call - most of what reading one cost.
-	constructor(x: number = 0.0, y: number = 0.0, z: number = 0.0) {
-		super(3);
-		unchecked(this[0] = x);
-		unchecked(this[1] = y);
-		unchecked(this[2] = z);
+	// The three numbers live in the object itself, after the array's fields:
+	// a new Vector is one allocation, not an array and its buffer. Grown past
+	// three, they move out to a buffer of their own, as any array's do.
+	private room0: f64 = 0;
+	private room1: f64 = 0;
+	private room2: f64 = 0;
+
+	// x, y and z are loads and stores at the array's data: a Vector is made
+	// with room for three, which a shorter length leaves in place. An index,
+	// even unchecked, was a call - and a write a checked one, which may grow.
+	// The getters are inlined; a setter is small enough for a full build to
+	// inline it (an accessor pair takes one decorator in the editor). The
+	// constructor is inlined too, so a Vector that never leaves the function
+	// that makes it - `player.origin.x` - is made in that function's frame.
+	// @ts-ignore: decorator
+	@inline constructor(x: number = 0.0, y: number = 0.0, z: number = 0.0) {
+		// @ts-ignore: the compiler's own form of Array's constructor, which the editor's typings leave out
+		super(3, true);
+		// The array's buffer is the object itself, its data the room.
+		const self = changetype<usize>(this);
+		store<usize>(self, self, offsetof<ArrayBufferView>("buffer"));
+		store<usize>(self, self + offsetof<Vector>("room0"), offsetof<ArrayBufferView>("dataStart"));
+		store<i32>(self, 3 << alignof<f64>(), offsetof<ArrayBufferView>("byteLength"));
+		store<f64>(this.dataStart, x);
+		store<f64>(this.dataStart, y, 8);
+		store<f64>(this.dataStart, z, 16);
 	}
 
 	/** The x coordinate, `vector[0]`. */
-	get x() { return unchecked(this[0]); }
-	set x(value: number) { unchecked(this[0] = value); }
+	@inline get x(): number { return load<f64>(this.dataStart); }
+	set x(value: number) { store<f64>(this.dataStart, value); }
 
 	/** The y coordinate, `vector[1]`. */
-	get y() { return unchecked(this[1]); }
-	set y(value: number) { unchecked(this[1] = value); }
+	@inline get y(): number { return load<f64>(this.dataStart, 8); }
+	set y(value: number) { store<f64>(this.dataStart, value, 8); }
 
 	/** The z coordinate, `vector[2]`. */
-	get z() { return unchecked(this[2]); }
-	set z(value: number) { unchecked(this[2] = value); }
+	@inline get z(): number { return load<f64>(this.dataStart, 16); }
+	set z(value: number) { store<f64>(this.dataStart, value, 16); }
 
 	/** A new vector: this one plus `other`, number by number. */
 	add(other: number[]) {
@@ -65,4 +83,66 @@ export class Vector extends Array<number> {
 		const size = this.magnitude();
 		return size > 0 ? this.scale(1 / size) : new Vector();
 	}
+
+	/**
+	 * The direction angles look in, one unit long:
+	 * `Vector.fromAngles(player.viewAngle).scale(500)` is a push the way the
+	 * player looks.
+	 *
+	 * Pawn: `angle_vector(..., ANGLEVECTOR_FORWARD, ...)`, `velocity_by_aim`
+	 */
+	static fromAngles(angles: number[]): Vector {
+		const pitch = angles[0] * DEGREES;
+		const yaw = angles[1] * DEGREES;
+		const across = Math.cos(pitch);
+		return new Vector(across * Math.cos(yaw), across * Math.sin(yaw), -Math.sin(pitch));
+	}
+
+	/**
+	 * The three directions of angles, one unit long each: where they look,
+	 * to their right and above them - `const { forward, right } =
+	 * Vector.directions(player.viewAngle)`.
+	 *
+	 * Pawn: `angle_vector`, `engfunc(EngFunc_MakeVectors, ...)`
+	 */
+	static directions(angles: number[]): Directions {
+		const pitch = angles[0] * DEGREES;
+		const yaw = angles[1] * DEGREES;
+		const roll = angles[2] * DEGREES;
+		const sp = Math.sin(pitch), cp = Math.cos(pitch);
+		const sy = Math.sin(yaw), cy = Math.cos(yaw);
+		const sr = Math.sin(roll), cr = Math.cos(roll);
+		return {
+			forward: new Vector(cp * cy, cp * sy, -sp),
+			right: new Vector(-sr * sp * cy + cr * sy, -sr * sp * sy - cr * cy, -sr * cp),
+			up: new Vector(cr * sp * cy + sr * sy, cr * sp * sy - sr * cy, cr * cp),
+		};
+	}
+
+	/**
+	 * The angles that look along this vector, as a player's view holds them -
+	 * a pitch below the horizon positive: `player.viewAngle =
+	 * target.subtract(player.eyes).toAngles()`. `Vector.fromAngles` turns
+	 * them back.
+	 *
+	 * Pawn: `vector_to_angle`, `engfunc(EngFunc_VecToAngles, ...)`
+	 */
+	toAngles(): Vector {
+		const x = this[0], y = this[1], z = this[2];
+		if (x == 0 && y == 0) return new Vector(z > 0 ? -90 : 90, 0, 0);
+		const yaw = Math.atan2(y, x) / DEGREES;
+		return new Vector(-Math.atan2(z, Math.sqrt(x * x + y * y)) / DEGREES, yaw < 0 ? yaw + 360 : yaw, 0);
+	}
+}
+
+const DEGREES: f64 = Math.PI / 180;
+
+/** The three directions of angles: ahead, to the right and up - `Vector.directions`. */
+export interface Directions {
+	/** The direction they look in. */
+	forward: Vector;
+	/** To their right. */
+	right: Vector;
+	/** Above them. */
+	up: Vector;
 }

package/includes/order.txt

@@ -1,4 +1,4 @@
-# Which includes the host plugin pulls in, and in what order.
+# Which includes the natives' image pulls in, and in what order.
 # This cannot be derived from the .inc files: an include may use reapi's
 # constants without including reapi itself. Files missing from this list are still
 # parsed for their natives — reapi.inc, for instance, already pulls in
@@ -20,28 +20,26 @@ universal_config
 menu_core
 
 # engine, fakemeta, nvault and geoip are stock AMX Mod X modules shipped with
-# the server (addons/amxmodx/modules/); geoip is listed in modules.ini and the
-# others are auto-detected from the `#pragma reqlib` amxxpc writes into the
-# .amxx. The module itself calls engine's get_global_int and fakemeta's
-# pev_valid and get_pdata_int to find the engine's edicts (runtime/src/fields.h).
-# resemiclip is a third-party module, present as a DLL and enabled explicitly
-# in modules.ini.
+# the server (addons/amxmodx/modules/); the image names each module its
+# includes ask for, and AMX Mod X loads it as it loads the image, as it does
+# for a plugin's includes. resemiclip is a third-party module, present as a
+# DLL and enabled explicitly in modules.ini.
 #
 # universal_config and menu_core are not modules: their natives come from
-# universal_config.amxx and menu_core.amxx, which plugins.ini loads ahead of
-# amxts_host.amxx. AMX Mod X resolves plugin-registered natives after every
-# plugin has run plugin_natives(), so the host links against them fine, and a
-# server without those two plugins loads it too (below).
+# plugins - a Pawn plugin's register_native, or an amxts module's exported
+# natives. AMX Mod X binds the natives plugins register in the image once
+# every plugin has loaded, and a server without those plugins loads it too
+# (below).
 
 # A line starting with `-` is a deny marker: the include is still resolved and
 # parsed (amxxpc needs the file on disk to compile an include that #includes
-# it), but its natives are never pulled into the host's native table. None is
+# it), but its natives are never pulled into the image's native table. None is
 # needed today.
 #
-# A native the server does not have does not keep the host from loading: the
-# host's native filter lets it load without the native, and a call to it
-# answers 0 and says so once. So the includes whose natives a server may lack
-# are pulled like any other: reapi's add-ons - Reunion's natives exist only
-# when reapi finds Reunion, VTC's and ReChecker's only with those plugins - and
-# geoip, whose module turns its natives off when the GeoIP2 databases are not
-# there. The facade asks before it calls one (has_reunion).
+# A native the server does not have does not keep the image from loading: its
+# entry stays unbound, and a call to it answers 0 and says so once. So the
+# includes whose natives a server may lack are pulled like any other: reapi's
+# add-ons - Reunion's natives exist only when reapi finds Reunion, VTC's and
+# ReChecker's only with those plugins - and geoip, whose module turns its
+# natives off when the GeoIP2 databases are not there. The facade asks before
+# it calls one (has_reunion).

package/node_modules/assemblyscript/std/assembly/index.d.ts

@@ -2094,6 +2094,7 @@ declare class Array<T> {
   reverse(): this;
   /** Flattens an array of arrays. If any null entries exist in the array, they are ignored, unlike JavaScript's version of Array#flat(). */
   flat(): T extends unknown[] ? T : never;
+  flatMap<U>(callbackfn: (value: T, index: i32, array: Array<T>) => U[]): Array<U>;
   toString(): string;
 }
 
@@ -2634,7 +2635,6 @@ declare const Mathf: IMath<f32>;
 /** Environmental abort function. */
 declare function abort(msg?: string | null, fileName?: string | null, lineNumber?: i32, columnNumber?: i32): never;
 /** Environmental tracing function. */
-declare function trace(msg: string, n?: i32, a0?: f64, a1?: f64, a2?: f64, a3?: f64, a4?: f64): void;
 /** Environmental seeding function. */
 declare function seed(): f64;
 

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@amxts/core",
 	"type": "module",
-	"version": "0.2.3",
+	"version": "0.3.0",
 	"description": "Counter-Strike 1.6 plugins in TypeScript: compiled ahead of time and run inside AMX Mod X, next to Pawn plugins.",
 	"author": {
 		"name": "kukson777",
@@ -63,6 +63,7 @@
 		"scripts/file-contents.ts",
 		"scripts/hlds-events.ts",
 		"scripts/includes.ts",
+		"scripts/leaf-natives.ts",
 		"scripts/player-fields.ts",
 		"scripts/plugin-cache.ts",
 		"scripts/plugin-natives.ts",
@@ -71,6 +72,7 @@
 		"scripts/project.ts",
 		"scripts/reapi-events.ts",
 		"scripts/run.ts",
+		"scripts/server-env.ts",
 		"scripts/shared-modules.ts",
 		"scripts/source-map.ts",
 		"scripts/system.ts",
@@ -79,6 +81,7 @@
 		"scripts/typed-configs.ts",
 		"scripts/ui.ts",
 		"scripts/upgrade.ts",
+		"scripts/upgrade-calls.ts",
 		"scripts/upgrade-menus.ts",
 		"scripts/upgrade-names.ts",
 		"includes/*.inc",
@@ -98,18 +101,18 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@amxts/cli": "^0.2.1",
+		"@amxts/cli": "^0.3.0",
 		"bun": "^1.4.2",
 		"typescript": "^5.6.0",
 		"assemblyscript": "0.28.20"
 	},
 	"optionalDependencies": {
-		"@amxts/wamrc-linux-x64": "^0.2.3",
-		"@amxts/wamrc-win32-x64": "^0.2.3"
+		"@amxts/wamrc-linux-x64": "^0.3.0",
+		"@amxts/wamrc-win32-x64": "^0.3.0"
 	},
 	"devDependencies": {
-		"@amxts/config-core": "^0.1.2",
-		"@amxts/menu-core": "^0.2.1",
+		"@amxts/config-core": "^0.2.0",
+		"@amxts/menu-core": "^0.3.0",
 		"@e18e/eslint-plugin": "^0.8.1",
 		"@eslint-community/eslint-plugin-eslint-comments": "^4.8.1",
 		"@stylistic/eslint-plugin": "^5.10.0",