@amxts/core 0.2.4 → 0.3.0

package/src/testing/compile.ts

@@ -11,6 +11,7 @@ import { playerFieldsBuild } from '../../scripts/player-fields';
 import { nativesBeside, nativesTransform, setNativesBeside } from '../../scripts/plugin-natives';
 import { ascPath, CONFIG_FILE, currentProjectDir, sourcesFor } from '../../scripts/project';
 import { targetTransforms } from '../../scripts/reapi-events';
+import { envBuild } from '../../scripts/server-env';
 import { sharedModulesBuild } from '../../scripts/shared-modules';
 import { existsSync, hashOf } from '../../scripts/tracked-fs';
 import { cached } from './compile-cache';
@@ -26,6 +27,8 @@ export interface Compiled {
 	binary: Uint8Array;
 	/** Whether it carries the coroutine scheduler's exports (as/promise.ts). */
 	async: boolean;
+	/** Its env() calls as the section amxts.env writes them, a line a name (scripts/server-env.ts). */
+	env: string[];
 }
 
 const compiled = new Map<string, Promise<Compiled>>();
@@ -77,6 +80,19 @@ function moduleOwner(source: string): string | null {
 /** A compile as the disk cache keeps it: no WebAssembly.Module, and an error as its text. */
 type Built = (Omit<Compiled, 'module'> & { beside: NativesBeside }) | { error: string };
 
+/**
+ * `AMXTS_GC_STRESS=1` in the environment: every plugin and snippet a test
+ * compiles runs a step of the collector on every allocation
+ * (`ASC_GC_STRESS`), so a value a function holds without a shadow-stack
+ * slot is freed at once and its test fails. Part of the cache's key.
+ */
+const GC_STRESS = process.env.AMXTS_GC_STRESS ? ['--use', 'ASC_GC_STRESS=1'] : [];
+
+/** `args` with GC_STRESS, unless they ask for it themselves. */
+export function stressed(args: string[]): string[] {
+	return args.includes('ASC_GC_STRESS=1') ? args : [...args, ...GC_STRESS];
+}
+
 /** A failure worth keeping on disk is the compiler's; a file that could not be opened is not. */
 const PASSING = /\b(?:EBUSY|EPERM|EACCES|EMFILE|ENFILE|EAGAIN)\b/;
 
@@ -89,7 +105,7 @@ function lasting(built: Built): boolean {
  * when an earlier run compiled it from the same files.
  */
 async function build(path: string): Promise<Compiled> {
-	const built = await cached<Built>(['plugin', process.cwd(), path, PLUGINS_ROOT], async () => {
+	const built = await cached<Built>(['plugin', process.cwd(), path, PLUGINS_ROOT, GC_STRESS], async () => {
 		try {
 			const fresh = await buildFresh(path);
 			return { ...fresh, beside: nativesBeside(fresh.natives) };
@@ -127,11 +143,12 @@ async function buildWith(path: string, hoodExports: string): Promise<Omit<Compil
 	let binary: Uint8Array | undefined;
 	const natives: PluginNative[] = [];
 	const playerFields = playerFieldsBuild();
+	const env = envBuild();
 	// scripts/compile.ts's shared modules: a proxy for one another plugin owns.
 	const shared = await sharedModulesBuild(PLUGINS_ROOT, entry);
 
 	const { error, stderr } = await ascMain(
-		[entry, HOOD_EXPORTS, '--outFile', 'plugin.wasm', '--optimize', '--exportTable', '--exportStart', '_start'],
+		stressed([entry, HOOD_EXPORTS, '--outFile', 'plugin.wasm', '--optimize', '--exportTable', '--exportStart', '_start']),
 		{
 			// scripts/compile.ts's readFile: the `~/` alias, the hood's exports and the fields plugins add to Player.
 			readFile(filename: string, baseDir: string): string | null {
@@ -139,7 +156,10 @@ async function buildWith(path: string, hoodExports: string): Promise<Omit<Compil
 
 				const file = ascPath(PLUGINS_ROOT, filename, baseDir);
 				const text = sources.read(file);
-				return text === null ? null : shared.read(file, playerFields.read(relative('.', (sources.real(file) ?? file)), text));
+				if (text === null) return null;
+				const shown = relative('.', (sources.real(file) ?? file));
+				env.read(shown, text);
+				return shared.read(file, playerFields.read(shown, text));
 			},
 			// Only the binary is wanted; nothing is written to disk.
 			writeFile(_: string, contents: string | Uint8Array) {
@@ -151,12 +171,13 @@ async function buildWith(path: string, hoodExports: string): Promise<Omit<Compil
 	);
 
 	if (sources.problems.length) throw new Error(sources.problems.join('\n'));
+	if (env.problems.length) throw new Error(env.problems.join('\n'));
 
 	if (error || !binary) {
 		throw new Error(`${relative(process.cwd(), path)} does not compile:\n${stderr.toString() || String(error?.message ?? error)}`);
 	}
 
-	return { natives, binary, async: false };
+	return { natives, binary, async: false, env: env.entries() };
 }
 
 /**
@@ -188,19 +209,21 @@ export interface SourcesCompiled {
 /**
  * asc - the patched one, as the build runs it - on `sources` alone, a test's
  * snippet of the compiler at work, with the disk cache in front. Nothing is
- * read from disk, so the sources and `args` are the whole key.
+ * read from disk, so the sources and `args` are the whole key. `finished`
+ * adds what a full build does after asc's optimiser (finishing).
  */
-export async function compileSources(args: string[], sources: Record<string, string>): Promise<SourcesCompiled> {
-	return cached<SourcesCompiled>(['sources', args, sources], async () => {
+export async function compileSources(args: string[], sources: Record<string, string>, finished = false): Promise<SourcesCompiled> {
+	return cached<SourcesCompiled>(['sources', stressed(args), sources, finished], async () => {
 		let binary: Uint8Array | null = null;
 		const text: Record<string, string> = {};
-		const { error, stderr } = await ascMain(args, {
+		const { error, stderr } = await ascMain(stressed(args), {
 			readFile: (name: string) => sources[name] ?? null,
 			writeFile(name: string, contents: string | Uint8Array) {
 				if (typeof contents === 'string') text[name] = contents;
 				else binary = contents;
 			},
 			listFiles: () => [],
+			transforms: finished ? [finishing(BASE_EXPORTS, null)] : [],
 		});
 		return error ? { error: stderr.toString(), binary: null, text } : { error: null, binary, text };
 	});

package/src/testing/coroutines.ts

@@ -24,15 +24,6 @@ interface Coroutine {
 	drop: boolean;
 }
 
-// co_id(): a task id no other plugin on the server has, as module.cpp's is -
-// one counter for every plugin.
-let nextId = 0x60000000;
-
-/** The next of those ids. @internal */
-export function nextTaskId(): number {
-	return nextId++;
-}
-
 export class Coroutines {
 	/** What a trap inside a coroutine said: it drops that one coroutine, as on the server. */
 	readonly traps: string[] = [];
@@ -81,7 +72,6 @@ export class Coroutines {
 				this.exports.asyncify_start_unwind(coroutine.buffer);
 			},
 			co_wake: () => { this.wake = true; },
-			co_id: nextTaskId,
 		};
 	}
 

package/src/testing/memory.ts

@@ -22,6 +22,22 @@ export function bitsFloat(cell: number): number {
 	return floatView[0];
 }
 
+/** How many of the bytes are whole UTF-8 characters: a last one cut short is left out. */
+function wholeUtf8(bytes: Uint8Array): number {
+	let lead = bytes.length;
+	while (lead > 0 && (bytes[lead - 1] & 0xC0) === 0x80) lead--;
+	if (lead === 0 || bytes[lead - 1] < 0xC0) return bytes.length;
+	const size = bytes[lead - 1] >= 0xF0 ? 4 : bytes[lead - 1] >= 0xE0 ? 3 : 2;
+	return bytes.length - (lead - 1) < size ? lead - 1 : bytes.length;
+}
+
+// The AMX heap the module passes text through (Frame::inText, outText):
+// cells of the fake's own at addresses past any plugin's memory, which a
+// native reads and writes as it does the plugin's.
+const HEAP = 0x7F000000;
+// The longest text that crosses, in bytes and its terminator (MAX_CROSSING_CELLS).
+const CROSSING_CELLS = 16384;
+
 /** How many of the bytes fit in `max` without cutting a UTF-8 character in two. */
 export function utf8Fit(bytes: Uint8Array, max: number): number {
 	let length = Math.min(bytes.length, max);
@@ -31,6 +47,8 @@ export function utf8Fit(bytes: Uint8Array, max: number): number {
 
 export class Memory {
 	private dataView?: DataView;
+	private heap = new Int32Array(1 << 18);
+	private heapTop = 0;
 
 	constructor(private exports: any) {}
 
@@ -42,11 +60,70 @@ export class Memory {
 	}
 
 	cell(pointer: number): number {
-		return this.view.getInt32(pointer, true);
+		return pointer >= HEAP ? this.heap[(pointer - HEAP) >> 2] : this.view.getInt32(pointer, true);
+	}
+
+	byte(pointer: number): number {
+		return this.view.getUint8(pointer);
 	}
 
 	setCell(pointer: number, value: number): void {
-		this.view.setInt32(pointer, value | 0, true);
+		if (pointer >= HEAP) this.heap[(pointer - HEAP) >> 2] = value | 0;
+		else this.view.setInt32(pointer, value | 0, true);
+	}
+
+	/**
+	 * A native's call as the module's thunk makes it, by the native's marks in
+	 * runtime/natives.txt: an `s` argument is the plugin's string, handed to
+	 * the native as a Pawn string on the heap; a `t` one is a buffer the
+	 * native fills on the heap, back in the plugin as UTF-8 bytes up to its end.
+	 */
+	across(marks: readonly string[], args: number[], call: (cells: number[]) => number): number {
+		const top = this.heapTop;
+		try {
+			const cells = args.map((arg, i) => marks[i] === 's' ? this.heapText(this.string(arg)) : marks[i] === 't' ? this.heapCells(args[i + 1] + 1) : arg);
+			const result = call(cells);
+			marks.forEach((mark, i) => {
+				if (mark !== 't') return;
+				const bytes = this.bytes(cells[i], args[i + 1]);
+				const kept = bytes.subarray(0, wholeUtf8(bytes));
+				this.setRaw(args[i], Uint8Array.of(...kept, 0));
+				this.setTextHead(args[i], kept);
+			});
+			return result;
+		} finally {
+			this.heapTop = top;
+		}
+	}
+
+	/** Frame::backText's head before a text a native filled: its count, the top bit for one not ASCII, and its hash. */
+	private setTextHead(pointer: number, bytes: Uint8Array): void {
+		// As the module's: four bytes a word, little-endian, while all four are there, then a byte at a time.
+		let hash = 0;
+		let bits = 0;
+		let i = 0;
+		for (; i + 4 <= bytes.length; i += 4) hash = (Math.imul(hash, 31) + (bytes[i] | bytes[i + 1] << 8 | bytes[i + 2] << 16 | bytes[i + 3] << 24)) >>> 0;
+		for (; i < bytes.length; i++) hash = (Math.imul(hash, 31) + bytes[i]) >>> 0;
+		for (const byte of bytes) bits |= byte;
+		this.view.setUint32(pointer - 8, (bytes.length | (bits >= 0x80 ? 0x80000000 : 0)) >>> 0, true);
+		this.view.setUint32(pointer - 4, hash, true);
+	}
+
+	/** `count` empty cells of the heap: their address. */
+	private heapCells(count: number): number {
+		const at = this.heapTop;
+		this.heapTop += Math.min(Math.max(count, 1), CROSSING_CELLS);
+		this.heap.fill(0, at, this.heapTop);
+		return HEAP + at * 4;
+	}
+
+	/** Text as a Pawn string on the heap, cut at the longest that crosses, between letters. */
+	private heapText(text: string): number {
+		const bytes = encoder.encode(text);
+		const length = utf8Fit(bytes, CROSSING_CELLS - 1);
+		const at = this.heapCells(length + 1);
+		this.heap.set(bytes.subarray(0, length), (at - HEAP) >> 2);
+		return at;
 	}
 
 	float(pointer: number): number {
@@ -61,6 +138,16 @@ export class Memory {
 		return [this.float(pointer), this.float(pointer + 4), this.float(pointer + 8)];
 	}
 
+	/** A plugin's number (f64) read from its own memory. */
+	number(pointer: number): number {
+		return this.view.getFloat64(pointer, true);
+	}
+
+	/** A plugin's number (f64) in its own memory. */
+	setNumber(pointer: number, value: number): void {
+		this.view.setFloat64(pointer, value, true);
+	}
+
 	setVector(pointer: number, value: number[]): void {
 		for (let i = 0; i < 3; i++) this.setFloat(pointer + i * 4, value[i] ?? 0);
 	}

package/src/testing/natives.ts

@@ -200,7 +200,7 @@ function cvarNumber(value: number): string {
 	return Number.isInteger(value) ? String(value) : value.toFixed(6);
 }
 
-function giveWeapon(target: FakePlayer | undefined, name: string): number {
+export function giveWeapon(target: FakePlayer | undefined, name: string): number {
 	if (!target) return 0;
 	if (name === 'item_kevlar' || name === 'item_assaultsuit') {
 		target.armor = 100;
@@ -214,7 +214,15 @@ function weaponByName(target: FakePlayer | undefined, name: string) {
 	return target?.items.find(w => w.kind === name);
 }
 
-function switchTo(target: FakePlayer | undefined, name: string): number {
+/** A command run as the player's, as the game takes it: a weapon chosen, a side picked in the team menu. */
+export function clientCommand(target: FakePlayer | undefined, line: string): void {
+	target?.commands.push(line);
+	if (line.startsWith('weapon_')) switchTo(target, line);
+	const side = { 'jointeam 1': 'TERRORIST', 'jointeam 2': 'CT', 'jointeam 6': 'SPECTATOR' }[line];
+	if (target && side) target.team = side as TeamName;
+}
+
+export function switchTo(target: FakePlayer | undefined, name: string): number {
 	const weapon = weaponByName(target, name);
 	if (!target || !weapon) return 0;
 	target.set('m_pActiveItem', weapon.id);
@@ -273,17 +281,26 @@ function setHamReturn(call: NativeCall, value: Value): number {
 	return 1;
 }
 
-// The engine's own message for a temporary effect: it is no user message, so
-// no name get_user_msgid handed out stands for it.
-const SVC_TEMPENTITY = 23;
+// The engine's own messages, by number: below 64 no user message lives, so
+// no name get_user_msgid handed out stands for them.
+const SVC_NAMES = (
+	'BAD NOP DISCONNECT EVENT VERSION SETVIEW SOUND TIME PRINT STUFFTEXT SETANGLE SERVERINFO LIGHTSTYLE UPDATEUSERINFO'
+	+ ' DELTADESCRIPTION CLIENTDATA STOPSOUND PINGS PARTICLE DAMAGE SPAWNSTATIC EVENT_RELIABLE SPAWNBASELINE TEMPENTITY'
+	+ ' SETPAUSE SIGNONNUM CENTERPRINT KILLEDMONSTER FOUNDSECRET SPAWNSTATICSOUND INTERMISSION FINALE CDTRACK RESTORE'
+	+ ' CUTSCENE WEAPONANIM DECALNAME ROOMTYPE ADDANGLE NEWUSERMSG PACKETENTITIES DELTAPACKETENTITIES CHOKE RESOURCELIST'
+	+ ' NEWMOVEVARS RESOURCEREQUEST CUSTOMIZATION CROSSHAIRANGLE SOUNDFADE FILETXFERFAILED HLTV DIRECTOR VOICEINIT'
+	+ ' VOICEDATA SENDEXTRAINFO TIMESCALE RESOURCELOCATION SENDCVARVALUE SENDCVARVALUE2'
+).split(' ');
 
 /**
- * message_begin: a user message by its name, or a temporary effect - with
- * who it goes to (`dest`, MSG_*) and the point it is seen from.
+ * message_begin: a user message by its name, or the engine's own (a temporary
+ * effect, movevars, ...) as `SVC_<name>` - with who it goes to (`dest`,
+ * MSG_*) and the point it is seen from.
  */
 function beginMessage(call: NativeCall, dest: number, type: number, player: number, origin: number[]): number {
-	if (type === SVC_TEMPENTITY) {
-		call.server.writing = { name: 'SVC_TEMPENTITY', player, args: [], dest, origin };
+	const svc = SVC_NAMES[type];
+	if (svc) {
+		call.server.writing = { name: `SVC_${svc}`, player, args: [], dest, origin };
 		return 1;
 	}
 	const name = [...call.server.messageIds].find(([, id]) => id === type)?.[0];
@@ -298,7 +315,7 @@ function sendText(call: NativeCall, id: number, variant: 'chat' | 'center' | 'co
 const PRINT_VARIANTS = ['', 'notify', 'console', 'chat', 'center'] as const;
 
 // Reunion's client_auth_type by its number, as the player's API names each.
-const AUTH_TYPES = ['unknown', 'dproto', 'steam', 'steamEmu', 'revEmu', 'oldRevEmu', 'hltv', 'sc2009', 'avsmp', 'sxei', 'revEmu2013', 'sse3'];
+export const AUTH_TYPES = ['unknown', 'dproto', 'steam', 'steamEmu', 'revEmu', 'oldRevEmu', 'hltv', 'sc2009', 'avsmp', 'sxei', 'revEmu2013', 'sse3'];
 
 /** A Pawn string of UTF-8 bytes - a path, a line of a file - as text. */
 function bytesText(call: NativeCall, pointer: number): string {
@@ -387,6 +404,24 @@ export const NATIVES: Record<string, Native> = {
 		return 1;
 	},
 	close_dir: (c, [handle]) => +c.server.handles.delete(handle),
+	delete_file: (c, [name]) => +c.server.files.delete(normalizePath(bytesText(c, name))),
+	rename_file: (c, [from, to]) => {
+		const source = normalizePath(bytesText(c, from));
+		const bytes = c.server.files.get(source);
+		if (!bytes) return 0;
+		c.server.files.delete(source);
+		c.server.files.set(normalizePath(bytesText(c, to)), bytes);
+		return 1;
+	},
+	// An empty folder only, as the real one.
+	rmdir: (c, [name]) => {
+		const folder = normalizePath(bytesText(c, name));
+		const inside = [...c.server.files.keys(), ...c.server.folders].some(path => path.startsWith(`${folder}/`));
+		return +(!inside && c.server.folders.delete(folder));
+	},
+	file_size: (c, [name]) => c.server.files.get(normalizePath(bytesText(c, name)))?.length ?? -1,
+	// Every file of the fake changed when the server was made.
+	GetFileTime: c => Math.floor(c.server.startedAt / 1000),
 	// 0 when made; the parent has to be there, as for the real one.
 	mkdir: (c, [name]) => {
 		const folder = normalizePath(bytesText(c, name));
@@ -473,6 +508,10 @@ export const NATIVES: Record<string, Native> = {
 		if (!target) throw new Error(`menu_display: player ${id} is not in game`);
 		c.server.displayMenu(target, c.server.menu(menu), page);
 	},
+	show_menu: (c, [id, keys, text]) => {
+		c.server.showMenu(id, keys, c.memory.text(text));
+		return 1;
+	},
 	menu_destroy: (c, [menu]) => {
 		c.server.destroyMenu(menu);
 		return 1;
@@ -519,7 +558,7 @@ export const NATIVES: Record<string, Native> = {
 	},
 
 	set_hudmessage: (c, [r, g, b, x, y, _effects, _fxtime, hold, _fadein, _fadeout, channel]) => {
-		c.server.hud = { color: [r, g, b], x: bitsFloat(x), y: bitsFloat(y), hold: bitsFloat(hold), channel };
+		c.server.hud = { color: [r, g, b], x: bitsFloat(x), y: bitsFloat(y), hold: bitsFloat(hold), channel, line: 0, large: false };
 	},
 	show_hudmessage: (c, [id, format, ...tail]) => sendText(c, id, 'hud', formatPawn(c, c.memory.text(format), tail)),
 
@@ -633,13 +672,7 @@ export const NATIVES: Record<string, Native> = {
 	rg_switch_weapon: (c, [id, weapon]) => switchTo(player(c, id), entity(c, weapon)?.classname ?? ''),
 	user_has_weapon: (c, [id, weapon]) => +!!weaponByName(player(c, id), WEAPON_NAMES[weapon] ?? ''),
 	engclient_cmd: (c, [id, command, arg1, arg2]) => {
-		const target = player(c, id);
-		const line = [command, arg1, arg2].map(p => c.memory.text(p)).filter(Boolean).join(' ');
-		target?.commands.push(line);
-		if (line.startsWith('weapon_')) switchTo(target, line);
-		// The team menu's slots, as the game handles `jointeam`.
-		const side = { 'jointeam 1': 'TERRORIST', 'jointeam 2': 'CT', 'jointeam 6': 'SPECTATOR' }[line];
-		if (target && side) target.team = side as TeamName;
+		clientCommand(player(c, id), [command, arg1, arg2].map(p => c.memory.text(p)).filter(Boolean).join(' '));
 	},
 	rg_reset_maxspeed: () => {},
 
@@ -745,23 +778,23 @@ export const NATIVES: Record<string, Native> = {
 
 	nvault_open: (c, [name]) => {
 		const vault = c.memory.text(name);
-		c.server.vault(vault);
+		c.server.storage(vault);
 		c.server.vaultHandles.push(vault);
 		return c.server.vaultHandles.length - 1;
 	},
 	nvault_close: () => {},
 	nvault_set: (c, [handle, key, value]) => {
-		c.server.vault(c.server.vaultHandles[handle]).set(c.memory.text(key), c.memory.text(value));
+		c.server.storage(c.server.vaultHandles[handle]).set(c.memory.text(key), c.memory.text(value));
 	},
 	nvault_lookup: (c, [handle, key, value, length, stampAt]) => {
-		const found = c.server.vault(c.server.vaultHandles[handle]).get(c.memory.text(key));
+		const found = c.server.storage(c.server.vaultHandles[handle]).get(c.memory.text(key));
 		if (found === undefined) return 0;
 		c.memory.setText(value, length, found);
 		if (stampAt) c.memory.setCell(stampAt, 0);
 		return 1;
 	},
 	nvault_remove: (c, [handle, key]) => {
-		c.server.vault(c.server.vaultHandles[handle]).delete(c.memory.text(key));
+		c.server.storage(c.server.vaultHandles[handle]).delete(c.memory.text(key));
 	},
 
 	// ------------------------------------------------------------ cvars
@@ -812,6 +845,12 @@ export const NATIVES: Record<string, Native> = {
 	// ------------------------------------------------------------ the game (reapi, engine, resemiclip)
 
 	register_dictionary: (c, [file]) => (c.server.loadDictionary(c.memory.text(file)) ? 1 : 0),
+	get_langsnum: c => c.server.dictionary.size,
+	get_lang: (c, [id, name]) => {
+		const code = [...c.server.dictionary.keys()][id] ?? '';
+		[code.charCodeAt(0) || 0, code.charCodeAt(1) || 0, 0].forEach((cell, at) => c.memory.setCell(name + at * 4, cell));
+		return 1;
+	},
 	GetLangTransKey: (c, [key]) => c.server.langKey(c.memory.text(key)),
 	LookupLangKey: (c, [out, size, key, id]) => {
 		const text = c.server.lookupLang(c.memory.text(key), c.memory.cell(id));
@@ -1004,7 +1043,7 @@ export const NATIVES: Record<string, Native> = {
 	GetHamReturnString: (c, [out, size]) => c.memory.setText(out, size, String(chain(c).answer)),
 	GetHamReturnVector: (c, [out]) => c.memory.setVector(out, [0, 0, 0]),
 	set_dhudmessage: (c, [r, g, b, x, y, _effects, _fxtime, hold]) => {
-		c.server.hud = { color: [r, g, b], x: bitsFloat(x), y: bitsFloat(y), hold: bitsFloat(hold), channel: -1 };
+		c.server.hud = { color: [r, g, b], x: bitsFloat(x), y: bitsFloat(y), hold: bitsFloat(hold), channel: -1, line: 0, large: true };
 	},
 	// A server without reapi hears ReGameDLL's events through these (as/hlds.ts).
 	// register_logevent(function[], argsnum, ...filters): server.gameLog() calls it.
@@ -1056,13 +1095,7 @@ export const NATIVES: Record<string, Native> = {
 			if (c.server.players.length >= c.server.maxPlayers) return 0;
 			return c.server.join(text(0), { bot: true, team: 'UNASSIGNED', alive: false }).id;
 		}
-		if (type === constant('EngFunc_RunPlayerMove')) {
-			const bot = player(c, cell(0));
-			const [, yaw] = c.memory.vector(tail[1]);
-			const [forward, msec] = [float(2), cell(7)];
-			call(`RunPlayerMove ${cell(0)} ${vector(1)} ${forward} ${float(3)} ${float(4)} ${cell(5)} ${cell(6)} ${msec}`);
-			if (bot) bot.origin = [bot.origin[0] + Math.cos(yaw * Math.PI / 180) * forward * msec / 1000, bot.origin[1] + Math.sin(yaw * Math.PI / 180) * forward * msec / 1000, bot.origin[2]];
-		}
+		if (type === constant('EngFunc_RunPlayerMove')) c.server.runPlayerMove(cell(0), c.memory.vector(tail[1]), float(2), float(3), float(4), cell(5), cell(6), cell(7));
 		return 0;
 	},
 	dllfunc: (c, [type, ...tail]) => {
@@ -1111,7 +1144,11 @@ const SAME_AS: Record<string, string> = {
 	write_long: 'write_byte',
 	// A message sent through the engine, which every plugin's message hooks hear (emessage_end).
 	emessage_begin: 'message_begin',
+	emessage_begin_f: 'message_begin_f',
 	ewrite_byte: 'write_byte',
+	ewrite_char: 'write_byte',
+	ewrite_coord_f: 'write_coord_f',
+	ewrite_angle_f: 'write_coord_f',
 	ewrite_long: 'write_byte',
 	ewrite_short: 'write_byte',
 	ewrite_string: 'write_string',