@amxts/core 0.2.3 → 0.3.0

package/as/entities.ts

@@ -5,7 +5,7 @@
 // reapi documents for it: `entity.gravity = 0.5`, `entity.origin`,
 // `player.hideHud`. Under the hood the module reads and writes each one
 // where the game keeps it, on any server; reapi's include says its type.
-import { ActionOptions, Call, Player, RoundWinner, SoundChannel, SoundOptions, UseType, WeaponName, cellFloat, floatCell, __hasReapi, __sayOnce } from "./facade";
+import { ActionOptions, Call, Player, RoundWinner, SoundChannel, SoundOptions, UseType, WeaponName, cellFloat, floatCell, __playerOf, __sayOnce } from "./facade";
 import { Vector } from "./vector";
 import { gameNameHlds, setGameNameHlds, timeLimitHlds, setTimeLimitHlds, gameStartTimeHlds, setGameStartTimeHlds, maxPlayersHlds, setMaxPlayersHlds } from "./hlds";
 import {
@@ -20,8 +20,7 @@ import {
 	find_ent_by_class, find_ent_in_sphere, get_global_int, entity_set_origin, emit_sound,
 	entity_set_model, entity_set_size, is_user_connected, is_user_alive, get_maxplayers, get_user_msgid,
 	emessage_begin, ewrite_string, ewrite_short, ewrite_byte, ewrite_long, emessage_end, client_print,
-	get_member_game, set_member_game, rg_update_teamscores, rg_set_observer_mode,
-	NATIVE_get_member_game, NATIVE_set_member_game, NATIVE_ExecuteHam, NATIVE_ExecuteHamB
+	NATIVE_ExecuteHam, NATIVE_ExecuteHamB
 } from "./natives";
 import {
 	m_bFreezePeriod, m_bBombDropped, m_GameDesc, m_nMaxPlayers, m_UpdateInterval, m_flRestartRoundTime,
@@ -37,14 +36,15 @@ import {
 	m_iMaxRoundsWon, m_iStoredSpectValue, m_flForceCameraValue, m_flForceChaseCamValue, m_flFadeToBlackValue, m_pVIP,
 	m_flIntermissionEndTime, m_flIntermissionStartTime, m_iEndIntermissionButtonHit, m_tmNextPeriodicThink, m_bGameStarted, m_bSkipSpawn,
 	m_bSkipShowMenu, m_bNeededPlayers, m_flEscapeRatio, m_flTimeLimit, m_flGameStartTime, m_bTeamBalanced,
-	EV_SZ_classname, EV_SZ_globalname, EV_SZ_model, EV_SZ_target, EV_SZ_targetname, EV_SZ_netname,
-	EV_SZ_message, EV_SZ_noise, EV_SZ_noise1, EV_SZ_noise2, EV_SZ_noise3, EV_INT_flags,
-	EV_ENT_owner, FL_KILLME, GL_maxEntities, MSG_ALL, MSG_ONE, ARMOR_VESTHELM,
-	print_center, Ham_Spawn, Ham_Activate, Ham_TakeHealth, Ham_Killed, Ham_Think,
-	Ham_Use, Ham_Blocked, Ham_CS_Restart, Ham_AddPoints, Ham_AddPointsToTeam, Ham_AddPlayerItem,
-	Ham_RemovePlayerItem, Ham_GiveAmmo, Ham_Player_Jump, Ham_Player_Duck, Ham_Item_AddToPlayer, Ham_Item_Deploy,
-	Ham_Item_Holster, Ham_Item_Drop, Ham_Item_AttachToPlayer, Ham_Weapon_ExtractAmmo, Ham_Weapon_ExtractClipAmmo, Ham_Weapon_ResetEmptySound,
-	Ham_Weapon_PrimaryAttack, Ham_Weapon_SecondaryAttack, Ham_Weapon_Reload, Ham_Weapon_WeaponIdle, Ham_Weapon_RetireWeapon, Ham_CS_Weapon_SendWeaponAnim
+	EV_SZ_classname, EV_SZ_globalname, EV_SZ_model, EV_SZ_viewmodel, EV_SZ_weaponmodel, EV_SZ_target,
+	EV_SZ_targetname, EV_SZ_netname, EV_SZ_message, EV_SZ_noise, EV_SZ_noise1, EV_SZ_noise2,
+	EV_SZ_noise3, EV_INT_flags, EV_ENT_owner, FL_KILLME, GL_maxEntities, MSG_ALL,
+	MSG_ONE, ARMOR_VESTHELM, print_center, Ham_Spawn, Ham_Activate, Ham_TakeHealth,
+	Ham_Killed, Ham_Think, Ham_Use, Ham_Blocked, Ham_CS_Restart, Ham_AddPoints,
+	Ham_AddPointsToTeam, Ham_AddPlayerItem, Ham_RemovePlayerItem, Ham_GiveAmmo, Ham_Player_Jump, Ham_Player_Duck,
+	Ham_Item_AddToPlayer, Ham_Item_Deploy, Ham_Item_Holster, Ham_Item_Drop, Ham_Item_AttachToPlayer, Ham_Weapon_ExtractAmmo,
+	Ham_Weapon_ExtractClipAmmo, Ham_Weapon_ResetEmptySound, Ham_Weapon_PrimaryAttack, Ham_Weapon_SecondaryAttack, Ham_Weapon_Reload, Ham_Weapon_WeaponIdle,
+	Ham_Weapon_RetireWeapon, Ham_CS_Weapon_SendWeaponAnim
 } from "./constants";
 
 /** A name's number when it has none ("unknown"): the setter then leaves the field alone. */
@@ -53,9 +53,24 @@ const UNNAMED = i32.MIN_VALUE;
 // A use's type, USE_OFF to USE_TOGGLE in their numbers' order.
 const USE_TYPES: UseType[] = ["off", "on", "set", "toggle"];
 
-/** An action's call: every plugin's listeners run on it, unless `{ hooks: false }`. */
+// @ts-ignore: decorator
+@external("env", "ham_bypass") declare function _hamBypass(fn: i32, id: i32): void;
+// ReGameDLL's Observer_SetMode: -1 on a server without it.
+// @ts-ignore: decorator
+@external("env", "player_observe") declare function _playerObserve(id: i32, mode: i32): i32;
+// The engine's DropToFloor: 1 landed, 0 nothing under it, -1 stuck.
+// @ts-ignore: decorator
+@external("env", "entity_drop") declare function _entityDrop(id: i32): i32;
+
+/**
+ * An action's call: every plugin's listeners run on it, unless
+ * `{ hooks: false }` - then the module's own hook of the function lets this
+ * one call past (ham_bypass), as Ham Sandwich's ExecuteHam goes past its own.
+ */
 function hamCall(fn: i32, id: number, options: ActionOptions): Call {
-	return new Call((options.hooks ?? true) ? NATIVE_ExecuteHamB : NATIVE_ExecuteHam).num(fn).num(id);
+	const hooks = options.hooks ?? true;
+	if (!hooks) _hamBypass(fn, <i32>id);
+	return new Call(hooks ? NATIVE_ExecuteHamB : NATIVE_ExecuteHam).num(fn).num(id);
 }
 
 // ---------------------------------------------------------------- fields
@@ -69,6 +84,9 @@ function hamCall(fn: i32, id: number, options: ActionOptions): Call {
 @external("env", "ent_get")         declare function _entGet(id: i32, offset: i32): i32;
 // @ts-ignore: decorator
 @external("env", "ent_set")         declare function _entSet(id: i32, offset: i32, cell: i32): void;
+// A leaf: it only writes the three numbers, so a call to it collects nothing.
+// @ts-ignore: decorator
+@external("env", "ent_vector") @leaf declare function _entVector(id: i32, offset: i32, out: usize): void;
 // @ts-ignore: decorator
 @external("env", "ent_entity")      declare function _entEntity(id: i32, offset: i32): i32;
 // @ts-ignore: decorator
@@ -85,10 +103,22 @@ function hamCall(fn: i32, id: number, options: ActionOptions): Call {
 @external("env", "member_set_text") declare function _memberSetText(id: i32, slot: i32, text: string): void;
 // @ts-ignore: decorator
 @external("env", "game_rules")      declare function _gameRules(): i32;
-// The native itself, given an origin of cells that is made once (NOWHERE):
-// its wrapper makes one from an array on every call.
+// A message a setter sends with its field, to one player in the game, through
+// the engine as the game's own go: every plugin's message hooks hear it.
+// send_one answers 0, and begins nothing, for a player who is not in the game.
+// @ts-ignore: decorator
+@external("env", "send_one")        declare function _sendOne(player: i32, type: i32): i32;
+// @ts-ignore: decorator
+@external("env", "send_byte")       declare function _sendByte(value: i32): void;
+// @ts-ignore: decorator
+@external("env", "send_long")       declare function _sendLong(value: i32): void;
+// @ts-ignore: decorator
+@external("env", "send_string")     declare function _sendString(text: string): void;
+// @ts-ignore: decorator
+@external("env", "send_end")        declare function _sendEnd(): void;
+// A message of one or two numbers, begun, written as `kinds` says (SEND_*) and sent in one call.
 // @ts-ignore: decorator
-@external("env", "emessage_begin")  declare function _emessageBegin(dest: i32, type: i32, origin: usize, player: i32): i32;
+@external("env", "send_cells")      declare function _sendCells(player: i32, type: i32, first: i32, second: i32, kinds: i32): void;
 
 /** The id the module reads the game rules' members by. */
 const RULES: i32 = -1;
@@ -220,6 +250,7 @@ const MEMBERS: StaticArray<string> = [
 	"CBasePlayer", "m_pentSndLast", // m_pentSndLast
 	"CBasePlayer", "m_flSndRoomtype", // m_flSndRoomtype
 	"CBasePlayer", "m_flSndRange", // m_flSndRange
+	"CBasePlayer", "m_flFallVelocity", // m_flFallVelocity
 	"CBasePlayer", "m_fNewAmmo", // m_fNewAmmo
 	"CBasePlayer", "m_afPhysicsFlags", // m_afPhysicsFlags
 	"CBasePlayer", "m_fNextSuicideTime", // m_fNextSuicideTime
@@ -308,6 +339,9 @@ const MEMBERS: StaticArray<string> = [
 	"CBasePlayer", "m_tmNextAccountHealthUpdate", // m_tmNextAccountHealthUpdate
 	"CGameRules", "m_bFreezePeriod", // m_bFreezePeriod
 	"CGameRules", "m_bBombDropped", // m_bBombDropped
+	"CHalfLifeMultiplay", "m_GameDesc", // m_GameDesc
+	"CHalfLifeMultiplay", "m_nMaxPlayers", // m_nMaxPlayers
+	"CHalfLifeMultiplay", "m_UpdateInterval", // m_UpdateInterval
 	"CHalfLifeMultiplay", "m_fTeamCount", // m_flRestartRoundTime
 	"CHalfLifeMultiplay", "m_flCheckWinConditions", // m_flCheckWinConditions
 	"CHalfLifeMultiplay", "m_fRoundCount", // m_fRoundStartTime
@@ -373,6 +407,12 @@ const MEMBERS: StaticArray<string> = [
 	"CHalfLifeMultiplay", "m_tmNextPeriodicThink", // m_tmNextPeriodicThink
 	"CHalfLifeMultiplay", "m_bFirstConnected", // m_bGameStarted
 	"CHalfLifeMultiplay", "m_bSkipSpawn", // m_bSkipSpawn
+	"CHalfLifeMultiplay", "m_bSkipShowMenu", // m_bSkipShowMenu
+	"CHalfLifeMultiplay", "m_bNeededPlayers", // m_bNeededPlayers
+	"CHalfLifeMultiplay", "m_flEscapeRatio", // m_flEscapeRatio
+	"CHalfLifeMultiplay", "m_flTimeLimit", // m_flTimeLimit
+	"CHalfLifeMultiplay", "m_flGameStartTime", // m_flGameStartTime
+	"CHalfLifeMultiplay", "m_bTeamBalanced", // m_bTeamBalanced
 	"CBasePlayerItem", "m_pPlayer", // m_pPlayer
 	"CBasePlayerWeapon", "m_iPlayEmptySound", // m_Weapon_iPlayEmptySound
 	"CBasePlayerWeapon", "m_fFireOnEmpty", // m_Weapon_fFireOnEmpty
@@ -532,16 +572,41 @@ const MEMBERS: StaticArray<string> = [
 // var_euser4 672
 
 /** The module's slot of each member, plus one: 0 until the member is first used. */
-const memberSlots = new StaticArray<i32>(304);
+const memberSlots = new StaticArray<i32>(314);
 
-/** The module's slot of the member at `at` in MEMBERS. */
+/** The module's slot of the member at `at` in MEMBERS; -1 for one of ReGameDLL's own on another server. */
 function slotOf(at: i32): i32 {
 	let slot = unchecked(memberSlots[at]);
 	if (slot == 0) {
-		slot = _memberSlot(unchecked(MEMBERS[at * 2]), unchecked(MEMBERS[at * 2 + 1])) + 1;
+		slot = _memberSlot(unchecked(MEMBERS[at * 2]), unchecked(MEMBERS[at * 2 + 1])) + 2;
 		unchecked(memberSlots[at] = slot);
 	}
-	return slot - 1;
+	return slot - 2;
+}
+
+// The text of a class's or a model's string_t: the engine points one
+// string_t at one text for the whole map - a class name, a model's name in
+// its precache list - so a read is a cell, and the text is made once a
+// string_t. Kept by the string_t, a slot of the table each; one another
+// string_t takes is read again. Not netname: the engine points a player's at
+// his name's buffer, which it rewrites.
+const KEPT_TEXTS: i32 = 256;
+const keptKeys = new StaticArray<i32>(KEPT_TEXTS);
+const keptTexts = new StaticArray<string | null>(KEPT_TEXTS);
+
+/** The text of the string_t entvar at `offset` (keptTexts); `key` is its EV_SZ_, for the engine module's read of one not kept. */
+function keptText(id: number, offset: i32, key: i32): string {
+	const at = _entGet(<i32>id, offset);
+	const slot = (at ^ (at >>> 8)) & (KEPT_TEXTS - 1);
+	const kept = unchecked(keptTexts[slot]);
+	// A kept text is a load and a compare: `kept != null` on a string is a call.
+	if (at != 0 && changetype<usize>(kept) != 0 && unchecked(keptKeys[slot]) == at) return changetype<string>(kept);
+	// 0 is no text, or no entity: the engine module's read says which.
+	const text = entity_get_string(id, key);
+	if (at == 0) return text;
+	unchecked(keptKeys[slot] = at);
+	unchecked(keptTexts[slot] = text);
+	return text;
 }
 
 /** An entvar's cell: a whole number, or a Float's bits. */
@@ -570,9 +635,7 @@ function entvarVector(id: number, offset: i32): Vector {
 
 /** A vector entvar written into a Vector the plugin keeps: get<Field>(target). */
 function entvarVectorInto(id: number, offset: i32, target: Vector): Vector {
-	target.x = cellFloat(_entGet(<i32>id, offset));
-	target.y = cellFloat(_entGet(<i32>id, offset + 4));
-	target.z = cellFloat(_entGet(<i32>id, offset + 8));
+	_entVector(<i32>id, offset, target.dataStart);
 	return target;
 }
 
@@ -621,79 +684,67 @@ function setMemberText(id: number, at: i32, value: string): void {
 }
 
 /**
- * How the game rules are read, chosen the first time: 1 in memory, 0
- * through reapi; -1 not chosen yet. AMX Mod X's gamedata lays them out as
- * the original game does, and ReGameDLL's add a member to their base class -
- * every offset after it is off - so a server with reapi, which runs
- * ReGameDLL, reads them through reapi.
+ * The game rules are read in memory on every server, where the module finds
+ * them (runtime/src/fields.h): the original game's members by the gamedata,
+ * ReGameDLL's moved as ReGameDLL lays them out.
  */
-let rulesInMemory: i32 = -1;
+let rulesSaid = false;
 
-function rulesHere(): bool {
-	if (rulesInMemory < 0) {
-		rulesInMemory = __hasReapi() ? 0 : 1;
-		if (!__hasReapi() && _gameRules() == 0) __sayOnce("the game rules are not in AMX Mod X's gamedata for this server: game's fields read 0");
-	}
-	return rulesInMemory == 1;
+function rulesHere(): void {
+	if (rulesSaid) return;
+	rulesSaid = true;
+	if (_gameRules() == 0) __sayOnce("the game rules are not in AMX Mod X's gamedata for this server: game's fields read 0");
 }
 
-/** A game rules member's cell: `at` in MEMBERS, or reapi's `field`. */
-function gameCell(at: i32, field: i32): i32 {
-	return rulesHere() ? _memberGet(RULES, slotOf(at), 0) : <i32>new Call(NATIVE_get_member_game).num(field).run();
+/** A game rules member's cell: `at` in MEMBERS. */
+function gameCell(at: i32): i32 {
+	rulesHere();
+	return _memberGet(RULES, slotOf(at), 0);
 }
 
-function setGameCell(at: i32, field: i32, cell: i32): void {
-	if (rulesHere()) _memberSet(RULES, slotOf(at), 0, cell);
-	else new Call(NATIVE_set_member_game).num(field).ref(cell).run();
+function setGameCell(at: i32, cell: i32): void {
+	rulesHere();
+	_memberSet(RULES, slotOf(at), 0, cell);
 }
 
-// A game rules member of ReGameDLL's own, which reapi alone reaches. On a
-// server without it, a member plain HLDS has another way to - a cvar, a count
-// AMX Mod X keeps - is read and written through `hlds` (as/hlds.ts); any
-// other reads 0 and says so once.
-function reapiGameCell(field: i32, name: string, hlds: (() => i32) | null = null): i32 {
-	if (!__hasReapi()) {
-		if (hlds) return hlds();
-		__sayOnce(`game.${name} is ReGameDLL's, read through ReAPI, which this server does not have: it reads 0 and writes nothing`);
-		return 0;
-	}
-	return <i32>new Call(NATIVE_get_member_game).num(field).run();
+// A game rules member of ReGameDLL's own, which a server without ReGameDLL
+// does not have: there a member plain HLDS has another way to - a cvar, a
+// count AMX Mod X keeps - is read and written through `hlds` (as/hlds.ts);
+// any other reads 0 and says so once.
+function regameCell(at: i32, name: string, hlds: (() => i32) | null = null): i32 {
+	if (slotOf(at) >= 0) return gameCell(at);
+	if (hlds) return hlds();
+	__sayOnce(`game.${name} is ReGameDLL's, which this server does not have: it reads 0 and writes nothing`);
+	return 0;
 }
 
-function setReapiGameCell(field: i32, name: string, cell: i32, hlds: ((cell: i32) => void) | null = null): void {
-	if (__hasReapi()) new Call(NATIVE_set_member_game).num(field).ref(cell).run();
+function setRegameCell(at: i32, name: string, cell: i32, hlds: ((cell: i32) => void) | null = null): void {
+	if (slotOf(at) >= 0) setGameCell(at, cell);
 	else if (hlds) hlds(cell);
-	else reapiGameCell(field, name);
+	else regameCell(at, name);
 }
 
-function reapiGameText(field: i32, name: string, hlds: (() => string) | null = null): string {
-	if (!__hasReapi()) {
-		if (hlds) return hlds();
-		__sayOnce(`game.${name} is ReGameDLL's, read through ReAPI, which this server does not have: it reads "" and writes nothing`);
-		return "";
-	}
-	return get_member_game<string>(field);
+// A text member of ReGameDLL's own: the game's own text in memory, which
+// the game allocates, so it is read and written the way every server has.
+function regameText(name: string, hlds: (() => string) | null = null): string {
+	if (hlds) return hlds();
+	__sayOnce(`game.${name} is not read on this server: it reads "" and writes nothing`);
+	return "";
 }
 
-function setReapiGameText(field: i32, name: string, value: string, hlds: ((value: string) => void) | null = null): void {
-	if (__hasReapi()) set_member_game<string>(field, value);
-	else if (hlds) hlds(value);
-	else reapiGameText(field, name);
+function setRegameText(name: string, value: string, hlds: ((value: string) => void) | null = null): void {
+	if (hlds) hlds(value);
+	else regameText(name);
 }
 
 /**
- * Both teams' scores, sent to the scoreboard at once: reapi's
- * rg_update_teamscores, or, without it, the members and the TeamScore
- * message the game's UpdateTeamScores sends - sent so that other plugins'
- * message listeners hear it, as they would the game's.
+ * Both teams' scores, sent to the scoreboard at once: the members, and the
+ * TeamScore message the game's UpdateTeamScores sends - sent so that other
+ * plugins' message listeners hear it, as they would the game's.
  */
 function setTeamScores(ct: number, terrorists: number): void {
-	if (__hasReapi()) {
-		rg_update_teamscores(ct, terrorists, false);
-		return;
-	}
-	setGameCell(3, m_iNumCTWins, <i32>ct);
-	setGameCell(4, m_iNumTerroristWins, <i32>terrorists);
+	setGameCell(3, <i32>ct);
+	setGameCell(4, <i32>terrorists);
 	sendTeamScore("CT", ct);
 	sendTeamScore("TERRORIST", terrorists);
 }
@@ -711,10 +762,22 @@ function sendTeamScore(team: string, score: number): void {
  * a player who is not in the game.
  */
 function messageTo(id: number, message: GameMessage): bool {
-	if (is_user_connected(id) == 0) return false;
+	return _sendOne(<i32>id, messageId(message)) != 0;
+}
+
+/** The message's id, looked up the first time. */
+function messageId(message: GameMessage): i32 {
 	if (message.id == 0) message.id = get_user_msgid(message.name);
-	_emessageBegin(MSG_ONE, message.id, changetype<usize>(NOWHERE), <i32>id);
-	return true;
+	return message.id;
+}
+
+// How sendCells writes each of its numbers, two bits a number (SEND_* in runtime/src/enginehooks.h).
+const SEND_BYTE: i32 = 1;
+const SEND_LONG: i32 = 2;
+
+/** A message of one or two numbers to the player, if he is in the game, in one call into the module. */
+function sendCells(id: number, message: GameMessage, first: i32, second: i32, kinds: i32): void {
+	_sendCells(<i32>id, messageId(message), first, second, kinds);
 }
 
 /** A message the setters send: its name, and its id, looked up the first time it is sent. */
@@ -730,32 +793,22 @@ const NIGHT_VISION_TOGGLE = new GameMessage("NVGToggle");
 const STATUS_ICON = new GameMessage("StatusIcon");
 const ITEM_STATUS = new GameMessage("ItemStatus");
 
-/** The origin a message to one player is sent from: none. */
-const NOWHERE = new StaticArray<i32>(3);
-
 /** The player's money, and the Money message that shows it on his HUD, flashing - what cs_set_user_money sends. */
 function setMoney(id: number, cell: i32): void {
 	setMemberCell(id, 7, cell);
-	if (!messageTo(id, MONEY)) return;
-	ewrite_long(cell);
-	ewrite_byte(1);
-	emessage_end();
+	sendCells(id, MONEY, cell, 1, SEND_LONG | (SEND_BYTE << 2));
 }
 
 /** The player's armour kind, and ArmorType: whether his HUD shows a helmet. */
 function setKevlar(id: number, cell: i32): void {
 	setMemberCell(id, 8, cell);
-	if (!messageTo(id, ARMOR_TYPE)) return;
-	ewrite_byte(cell == ARMOR_VESTHELM ? 1 : 0);
-	emessage_end();
+	sendCells(id, ARMOR_TYPE, cell == ARMOR_VESTHELM ? 1 : 0, 0, SEND_BYTE);
 }
 
 /** The flashlight's charge, and FlashBat: the bar on his HUD. */
 function setFlashlightBattery(id: number, cell: i32): void {
 	setMemberCell(id, 9, cell);
-	if (!messageTo(id, FLASHLIGHT_BATTERY)) return;
-	ewrite_byte(cell);
-	emessage_end();
+	sendCells(id, FLASHLIGHT_BATTERY, cell, 0, SEND_BYTE);
 }
 
 /** Whether he owns night vision goggles, told to his buy menu (ItemStatus). */
@@ -767,9 +820,7 @@ function setNightVision(id: number, cell: i32): void {
 /** Night vision switched on or off, and NVGToggle: his screen turns green or back. */
 function setNightVisionOn(id: number, cell: i32): void {
 	setMemberCell(id, 11, cell);
-	if (!messageTo(id, NIGHT_VISION_TOGGLE)) return;
-	ewrite_byte(cell);
-	emessage_end();
+	sendCells(id, NIGHT_VISION_TOGGLE, cell, 0, SEND_BYTE);
 }
 
 /**
@@ -780,37 +831,32 @@ function setDefuser(id: number, cell: i32): void {
 	setMemberCell(id, 12, cell);
 	setEntvarCell(id, 276, cell);
 	if (messageTo(id, STATUS_ICON)) {
-		ewrite_byte(cell);
-		ewrite_string("defuser");
+		_sendByte(cell);
+		_sendString("defuser");
 		if (cell != 0) {
-			ewrite_byte(0);
-			ewrite_byte(160);
-			ewrite_byte(0);
+			_sendByte(0);
+			_sendByte(160);
+			_sendByte(0);
 		}
-		emessage_end();
+		_sendEnd();
 	}
 	sendItemStatus(id);
 }
 
 /** ItemStatus: the night vision and the defuse kit the player owns, which his buy menu shows. */
 function sendItemStatus(id: number): void {
-	if (!messageTo(id, ITEM_STATUS)) return;
-	ewrite_byte((memberCell(id, 10) != 0 ? 1 : 0) | (memberCell(id, 12) != 0 ? 2 : 0));
-	emessage_end();
+	sendCells(id, ITEM_STATUS, (memberCell(id, 10) != 0 ? 1 : 0) | (memberCell(id, 12) != 0 ? 2 : 0), 0, SEND_BYTE);
 }
 
 /**
  * Switches a spectator's mode as the game's Observer_SetMode does: reapi's
- * rg_set_observer_mode, or, without it, the same steps here - the target
+ * ReGameDLL's Observer_SetMode, or, without it, the same steps here - the target
  * kept while it is another living player, the next one found otherwise,
  * "roaming" when there is none, the mode asked for kept as the last one,
  * and the mode's name on his screen.
  */
 function setObserverMode(id: number, mode: i32): void {
-	if (__hasReapi()) {
-		rg_set_observer_mode(id, mode);
-		return;
-	}
+	if (_playerObserve(<i32>id, mode) >= 0) return;
 	if (entvarCell(id, 580) == mode) return;
 
 	let target = memberCell(id, 5);
@@ -1755,6 +1801,10 @@ function vipSafetyZoneCell(name: VipSafetyZone): i32 {
 	return UNNAMED;
 }
 
+// A trace's hit group (trace.line), a point's contents (pointContents) and an
+// entity's state as a player is sent it (entityState) read as the fields' do.
+export { contentsName, hitGroupName, renderFxCell, renderFxName, renderModeCell, renderModeName };
+
 /** The WeaponKind names and the bit each has in var_weapons: 1 << its id. */
 const WEAPON_BITS = new FlagFamily(
 	["p228", "glock", "scout", "hegrenade", "xm1014", "c4", "mac10", "aug", "smokegrenade", "elite", "fiveseven", "ump45", "sg550", "galil", "famas", "usp", "glock18", "awp", "mp5n", "m249", "m3", "m4a1", "tmp", "g3sg1", "flashbang", "deagle", "sg552", "ak47", "knife", "p90"],
@@ -1842,6 +1892,15 @@ export class Entity {
 		entity_set_int(this.id, EV_INT_flags, entity_get_int(this.id, EV_INT_flags) | FL_KILLME);
 	}
 
+	/**
+	 * Drops the entity straight down onto what is under it, as the game puts an item on the floor when a map starts: `true` when it landed, `false` when there is nothing under it within 256 units or it is stuck in something.
+	 *
+	 * Pawn: `drop_to_floor`, `engfunc(EngFunc_DropToFloor, ...)`
+	 */
+	dropToFloor(): boolean {
+		return _entityDrop(this.id) == 1;
+	}
+
 	// is_valid_ent rather than reapi's is_entity: it answers false for 0 and
 	// for a number past the last entity instead of logging an error.
 	/**
@@ -1882,7 +1941,7 @@ export class Entity {
 	 *
 	 * Pawn: `pev->classname`
 	 */
-	get classname(): string { return entity_get_string(this.id, EV_SZ_classname); }
+	get classname(): string { return keptText(this.id, 0, EV_SZ_classname); }
 	set classname(value: string) { entity_set_string(this.id, EV_SZ_classname, value); }
 
 	/**
@@ -2169,7 +2228,7 @@ export class Entity {
 	 *
 	 * Pawn: `pev->model`
 	 */
-	get model(): string { return entity_get_string(this.id, EV_SZ_model); }
+	get model(): string { return keptText(this.id, 184, EV_SZ_model); }
 	set model(value: string) { entity_set_model(this.id, value); }
 
 	/**
@@ -2177,16 +2236,16 @@ export class Entity {
 	 *
 	 * Pawn: `pev->viewmodel`
 	 */
-	get viewModel(): number { return entvarCell(this.id, 188); }
-	set viewModel(value: number) { setEntvarCell(this.id, 188, <i32>value); }
+	get viewModel(): string { return keptText(this.id, 188, EV_SZ_viewmodel); }
+	set viewModel(value: string) { entity_set_string(this.id, EV_SZ_viewmodel, value); }
 
 	/**
 	 * The weapon model other players see in the player's hands, e.g. `"models/p_knife.mdl"`.
 	 *
 	 * Pawn: `pev->weaponmodel`
 	 */
-	get weaponModel(): number { return entvarCell(this.id, 192); }
-	set weaponModel(value: number) { setEntvarCell(this.id, 192, <i32>value); }
+	get weaponModel(): string { return keptText(this.id, 192, EV_SZ_weaponmodel); }
+	set weaponModel(value: string) { entity_set_string(this.id, EV_SZ_weaponmodel, value); }
 
 	/**
 	 * The low corner of the entity's bounding box in world coordinates; the engine recomputes it when the entity moves.
@@ -4103,262 +4162,273 @@ export class PlayerFields extends Entity {
 	get soundRange(): number { return cellFloat(memberCell(this.id, 120)); }
 	set soundRange(value: number) { setMemberCell(this.id, 120, <i32>floatCell(value)); }
 
+	/**
+	 * The player's falling speed, units per second, positive downwards: the one the game works fall damage out from on landing. Setting it sets the entity's `fallVelocity` too - `player.fallVelocity = 0` lands him without damage.
+	 *
+	 * Pawn: `CBasePlayer::m_flFallVelocity`
+	 */
+	get fallVelocity(): number { return cellFloat(memberCell(this.id, 121)); }
+	set fallVelocity(value: number) {
+		setMemberCell(this.id, 121, <i32>floatCell(value));
+		setEntvarCell(this.id, 564, <i32>floatCell(value));
+	}
+
 	/**
 	 * The player's “new ammo to send” flag from Half-Life. CS does not use the field.
 	 *
 	 * Pawn: `CBasePlayer::m_fNewAmmo`
 	 */
-	get newAmmo(): number { return memberCell(this.id, 121); }
-	set newAmmo(value: number) { setMemberCell(this.id, 121, <i32>value); }
+	get newAmmo(): number { return memberCell(this.id, 122); }
+	set newAmmo(value: number) { setMemberCell(this.id, 122, <i32>value); }
 
 	/**
 	 * The player's physics state, a list of any of: `"onLadder"`, `"onTrain"`, `"onBarnacle"`, `"ducking"` - crouching down right now, `"using"` - holding an object's use key, `"observer"` - a spectator locked in place.
 	 *
 	 * Pawn: `CBasePlayer::m_afPhysicsFlags`, `PFLAG_*`
 	 */
-	get physicsFlags(): PhysicsFlag[] { return flagList<PhysicsFlag>(new MemberFlags(this.id, 122), PHYSICS_FLAG); }
-	set physicsFlags(values: PhysicsFlag[]) { setMemberCell(this.id, 122, PHYSICS_FLAG.maskOf(values)); }
+	get physicsFlags(): PhysicsFlag[] { return flagList<PhysicsFlag>(new MemberFlags(this.id, 123), PHYSICS_FLAG); }
+	set physicsFlags(values: PhysicsFlag[]) { setMemberCell(this.id, 123, PHYSICS_FLAG.maskOf(values)); }
 
 	/**
 	 * The game time when the kill command works for the player again, a second after the last one.
 	 *
 	 * Pawn: `CBasePlayer::m_fNextSuicideTime`
 	 */
-	get nextSuicideTime(): number { return cellFloat(memberCell(this.id, 123)); }
-	set nextSuicideTime(value: number) { setMemberCell(this.id, 123, <i32>floatCell(value)); }
+	get nextSuicideTime(): number { return cellFloat(memberCell(this.id, 124)); }
+	set nextSuicideTime(value: number) { setMemberCell(this.id, 124, <i32>floatCell(value)); }
 
 	/**
 	 * The player's idle timer from Half-Life; CS keeps it on the weapon (a Weapon's `nextIdle`) and does not use this one.
 	 *
 	 * Pawn: `CBasePlayer::m_flTimeWeaponIdle`
 	 */
-	get timeWeaponIdle(): number { return cellFloat(memberCell(this.id, 124)); }
-	set timeWeaponIdle(value: number) { setMemberCell(this.id, 124, <i32>floatCell(value)); }
+	get timeWeaponIdle(): number { return cellFloat(memberCell(this.id, 125)); }
+	set timeWeaponIdle(value: number) { setMemberCell(this.id, 125, <i32>floatCell(value)); }
 
 	/**
 	 * The player's wall-jump timer from Half-Life. CS does not use the field.
 	 *
 	 * Pawn: `CBasePlayer::m_flWallJumpTime`
 	 */
-	get wallJumpTime(): number { return cellFloat(memberCell(this.id, 125)); }
-	set wallJumpTime(value: number) { setMemberCell(this.id, 125, <i32>floatCell(value)); }
+	get wallJumpTime(): number { return cellFloat(memberCell(this.id, 126)); }
+	set wallJumpTime(value: number) { setMemberCell(this.id, 126, <i32>floatCell(value)); }
 
 	/**
 	 * The game time of the next HEV suit phrase (Half-Life); `0` for none.
 	 *
 	 * Pawn: `CBasePlayer::m_flSuitUpdate`
 	 */
-	get suitUpdate(): number { return cellFloat(memberCell(this.id, 126)); }
-	set suitUpdate(value: number) { setMemberCell(this.id, 126, <i32>floatCell(value)); }
+	get suitUpdate(): number { return cellFloat(memberCell(this.id, 127)); }
+	set suitUpdate(value: number) { setMemberCell(this.id, 127, <i32>floatCell(value)); }
 
 	/**
 	 * The next place in the HEV suit's phrase queue (Half-Life).
 	 *
 	 * Pawn: `CBasePlayer::m_iSuitPlayNext`
 	 */
-	get suitPlayNext(): number { return memberCell(this.id, 127); }
-	set suitPlayNext(value: number) { setMemberCell(this.id, 127, <i32>value); }
+	get suitPlayNext(): number { return memberCell(this.id, 128); }
+	set suitPlayNext(value: number) { setMemberCell(this.id, 128, <i32>value); }
 
 	/**
 	 * The damage the player took from the last hit.
 	 *
 	 * Pawn: `CBasePlayer::m_lastDamageAmount`
 	 */
-	get lastDamageAmount(): number { return memberCell(this.id, 128); }
-	set lastDamageAmount(value: number) { setMemberCell(this.id, 128, <i32>value); }
+	get lastDamageAmount(): number { return memberCell(this.id, 129); }
+	set lastDamageAmount(value: number) { setMemberCell(this.id, 129, <i32>value); }
 
 	/**
 	 * The game time when damage over time (poison, burn, drowning recovery) was last applied to the player.
 	 *
 	 * Pawn: `CBasePlayer::m_tbdPrev`
 	 */
-	get timeBasedDamagePrev(): number { return cellFloat(memberCell(this.id, 129)); }
-	set timeBasedDamagePrev(value: number) { setMemberCell(this.id, 129, <i32>floatCell(value)); }
+	get timeBasedDamagePrev(): number { return cellFloat(memberCell(this.id, 130)); }
+	set timeBasedDamagePrev(value: number) { setMemberCell(this.id, 130, <i32>floatCell(value)); }
 
 	/**
 	 * The distance to the nearest radiation, for Half-Life's Geiger counter.
 	 *
 	 * Pawn: `CBasePlayer::m_flgeigerRange`
 	 */
-	get geigerRange(): number { return cellFloat(memberCell(this.id, 130)); }
-	set geigerRange(value: number) { setMemberCell(this.id, 130, <i32>floatCell(value)); }
+	get geigerRange(): number { return cellFloat(memberCell(this.id, 131)); }
+	set geigerRange(value: number) { setMemberCell(this.id, 131, <i32>floatCell(value)); }
 
 	/**
 	 * The game time of the next Geiger counter update (Half-Life).
 	 *
 	 * Pawn: `CBasePlayer::m_flgeigerDelay`
 	 */
-	get geigerDelay(): number { return cellFloat(memberCell(this.id, 131)); }
-	set geigerDelay(value: number) { setMemberCell(this.id, 131, <i32>floatCell(value)); }
+	get geigerDelay(): number { return cellFloat(memberCell(this.id, 132)); }
+	set geigerDelay(value: number) { setMemberCell(this.id, 132, <i32>floatCell(value)); }
 
 	/**
 	 * The Geiger counter reading last sent to the client (Half-Life).
 	 *
 	 * Pawn: `CBasePlayer::m_igeigerRangePrev`
 	 */
-	get geigerRangePrev(): number { return memberCell(this.id, 132); }
-	set geigerRangePrev(value: number) { setMemberCell(this.id, 132, <i32>value); }
+	get geigerRangePrev(): number { return memberCell(this.id, 133); }
+	set geigerRangePrev(value: number) { setMemberCell(this.id, 133, <i32>value); }
 
 	/**
 	 * The name of the texture the player last stood on, which his footsteps sound by.
 	 *
 	 * Pawn: `CBasePlayer::m_szTextureName`
 	 */
-	get textureName(): string { return memberText(this.id, 133); }
-	set textureName(value: string) { setMemberText(this.id, 133, value); }
+	get textureName(): string { return memberText(this.id, 134); }
+	set textureName(value: string) { setMemberText(this.id, 134, value); }
 
 	/**
 	 * The type of texture under the player, for step sounds. CS does not use the field.
 	 *
 	 * Pawn: `CBasePlayer::m_chTextureType`
 	 */
-	get textureType(): number { return memberCell(this.id, 134); }
-	set textureType(value: number) { setMemberCell(this.id, 134, <i32>value); }
+	get textureType(): number { return memberCell(this.id, 135); }
+	set textureType(value: number) { setMemberCell(this.id, 135, <i32>value); }
 
 	/**
 	 * The health drowning has taken from the player; it is given back once he surfaces.
 	 *
 	 * Pawn: `CBasePlayer::m_idrowndmg`
 	 */
-	get drownDamage(): number { return memberCell(this.id, 135); }
-	set drownDamage(value: number) { setMemberCell(this.id, 135, <i32>value); }
+	get drownDamage(): number { return memberCell(this.id, 136); }
+	set drownDamage(value: number) { setMemberCell(this.id, 136, <i32>value); }
 
 	/**
 	 * The part of the drowning damage already given back to the player.
 	 *
 	 * Pawn: `CBasePlayer::m_idrownrestored`
 	 */
-	get drownRestored(): number { return memberCell(this.id, 136); }
-	set drownRestored(value: number) { setMemberCell(this.id, 136, <i32>value); }
+	get drownRestored(): number { return memberCell(this.id, 137); }
+	set drownRestored(value: number) { setMemberCell(this.id, 137, <i32>value); }
 
 	/**
 	 * The kinds of damage last shown on the player's HUD, as bits; `-1` makes the game send them again.
 	 *
 	 * Pawn: `CBasePlayer::m_bitsHUDDamage`, `DMG_*`
 	 */
-	get hudDamage(): number { return memberCell(this.id, 137); }
-	set hudDamage(value: number) { setMemberCell(this.id, 137, <i32>value); }
+	get hudDamage(): number { return memberCell(this.id, 138); }
+	set hudDamage(value: number) { setMemberCell(this.id, 138, <i32>value); }
 
 	/**
 	 * `true` when the player's HUD has to be reset on his next update (after a spawn).
 	 *
 	 * Pawn: `CBasePlayer::m_fInitHUD`
 	 */
-	get initHud(): boolean { return memberCell(this.id, 138) != 0; }
-	set initHud(value: boolean) { setMemberCell(this.id, 138, value ? 1 : 0); }
+	get initHud(): boolean { return memberCell(this.id, 139) != 0; }
+	set initHud(value: boolean) { setMemberCell(this.id, 139, value ? 1 : 0); }
 
 	/**
 	 * `true` once the player's HUD has been set up since he connected.
 	 *
 	 * Pawn: `CBasePlayer::m_fGameHUDInitialized`
 	 */
-	get gameHudInitialized(): boolean { return memberCell(this.id, 139) != 0; }
-	set gameHudInitialized(value: boolean) { setMemberCell(this.id, 139, value ? 1 : 0); }
+	get gameHudInitialized(): boolean { return memberCell(this.id, 140) != 0; }
+	set gameHudInitialized(value: boolean) { setMemberCell(this.id, 140, value ? 1 : 0); }
 
 	/**
 	 * The train control on the player's HUD: `0` off, `1` to `5` the speed notch, plus bits for `"changed"` and `"active"`.
 	 *
 	 * Pawn: `CBasePlayer::m_iTrain`, `TRAIN_*`
 	 */
-	get trainControls(): number { return memberCell(this.id, 140); }
-	set trainControls(value: number) { setMemberCell(this.id, 140, <i32>value); }
+	get trainControls(): number { return memberCell(this.id, 141); }
+	set trainControls(value: number) { setMemberCell(this.id, 141, <i32>value); }
 
 	/**
 	 * `false` when the player's weapon list has to be sent again.
 	 *
 	 * Pawn: `CBasePlayer::m_fWeapon`
 	 */
-	get weaponHudValid(): boolean { return memberCell(this.id, 141) != 0; }
-	set weaponHudValid(value: boolean) { setMemberCell(this.id, 141, value ? 1 : 0); }
+	get weaponHudValid(): boolean { return memberCell(this.id, 142) != 0; }
+	set weaponHudValid(value: boolean) { setMemberCell(this.id, 142, value ? 1 : 0); }
 
 	/**
 	 * The mounted gun (`func_tank`) the player is using.
 	 *
 	 * Pawn: `CBasePlayer::m_pTank`
 	 */
-	get mountedGun(): number { return memberCell(this.id, 142); }
-	set mountedGun(value: number) { setMemberCell(this.id, 142, <i32>value); }
+	get mountedGun(): number { return memberCell(this.id, 143); }
+	set mountedGun(value: number) { setMemberCell(this.id, 143, <i32>value); }
 
 	/**
 	 * The game time of the player's death.
 	 *
 	 * Pawn: `CBasePlayer::m_fDeadTime`
 	 */
-	get deadTime(): number { return cellFloat(memberCell(this.id, 143)); }
-	set deadTime(value: number) { setMemberCell(this.id, 143, <i32>floatCell(value)); }
+	get deadTime(): number { return cellFloat(memberCell(this.id, 144)); }
+	set deadTime(value: number) { setMemberCell(this.id, 144, <i32>floatCell(value)); }
 
 	/**
 	 * `true` if monsters do not hear the player.
 	 *
 	 * Pawn: `CBasePlayer::m_fNoPlayerSound`
 	 */
-	get noPlayerSound(): boolean { return memberCell(this.id, 144) != 0; }
-	set noPlayerSound(value: boolean) { setMemberCell(this.id, 144, value ? 1 : 0); }
+	get noPlayerSound(): boolean { return memberCell(this.id, 145) != 0; }
+	set noPlayerSound(value: boolean) { setMemberCell(this.id, 145, value ? 1 : 0); }
 
 	/**
 	 * `true` if the player has the long jump module from Half-Life.
 	 *
 	 * Pawn: `CBasePlayer::m_fLongJump`
 	 */
-	get hasLongJump(): boolean { return memberCell(this.id, 145) != 0; }
-	set hasLongJump(value: boolean) { setMemberCell(this.id, 145, value ? 1 : 0); }
+	get hasLongJump(): boolean { return memberCell(this.id, 146) != 0; }
+	set hasLongJump(value: boolean) { setMemberCell(this.id, 146, value ? 1 : 0); }
 
 	/**
 	 * The game time from which the player counts as sneaking (Half-Life).
 	 *
 	 * Pawn: `CBasePlayer::m_tSneaking`
 	 */
-	get sneakingUntil(): number { return cellFloat(memberCell(this.id, 146)); }
-	set sneakingUntil(value: number) { setMemberCell(this.id, 146, <i32>floatCell(value)); }
+	get sneakingUntil(): number { return cellFloat(memberCell(this.id, 147)); }
+	set sneakingUntil(value: number) { setMemberCell(this.id, 147, <i32>floatCell(value)); }
 
 	/**
 	 * The player's update counter: set to `5` on reset, never read by the game.
 	 *
 	 * Pawn: `CBasePlayer::m_iUpdateTime`
 	 */
-	get updateTime(): number { return memberCell(this.id, 147); }
-	set updateTime(value: number) { setMemberCell(this.id, 147, <i32>value); }
+	get updateTime(): number { return memberCell(this.id, 148); }
+	set updateTime(value: number) { setMemberCell(this.id, 148, <i32>value); }
 
 	/**
 	 * The health last sent to the player's HUD; when it differs from his health, the game sends the new one.
 	 *
 	 * Pawn: `CBasePlayer::m_iClientHealth`
 	 */
-	get healthSent(): number { return memberCell(this.id, 148); }
-	set healthSent(value: number) { setMemberCell(this.id, 148, <i32>value); }
+	get healthSent(): number { return memberCell(this.id, 149); }
+	set healthSent(value: number) { setMemberCell(this.id, 149, <i32>value); }
 
 	/**
 	 * The armour last sent to the player's HUD; `-1` makes the game send it again.
 	 *
 	 * Pawn: `CBasePlayer::m_iClientBattery`
 	 */
-	get batterySent(): number { return memberCell(this.id, 149); }
-	set batterySent(value: number) { setMemberCell(this.id, 149, <i32>value); }
+	get batterySent(): number { return memberCell(this.id, 150); }
+	set batterySent(value: number) { setMemberCell(this.id, 150, <i32>value); }
 
 	/**
 	 * The parts of the player's HUD that are hidden: `["money", "timer"]`; the game sends the change itself.
 	 *
 	 * Pawn: `CBasePlayer::m_iHideHUD`
 	 */
-	get hideHud(): HideHud[] { return flagList<HideHud>(new MemberFlags(this.id, 150), HIDE_HUD); }
-	set hideHud(values: HideHud[]) { setMemberCell(this.id, 150, HIDE_HUD.maskOf(values)); }
+	get hideHud(): HideHud[] { return flagList<HideHud>(new MemberFlags(this.id, 151), HIDE_HUD); }
+	set hideHud(values: HideHud[]) { setMemberCell(this.id, 151, HIDE_HUD.maskOf(values)); }
 
 	/**
 	 * The hidden HUD parts last sent to the player; when they differ from `hideHud`, the game sends `hideHud`.
 	 *
 	 * Pawn: `CBasePlayer::m_iClientHideHUD`
 	 */
-	get hideHudSent(): HideHud[] { return flagList<HideHud>(new MemberFlags(this.id, 151), HIDE_HUD); }
-	set hideHudSent(values: HideHud[]) { setMemberCell(this.id, 151, HIDE_HUD.maskOf(values)); }
+	get hideHudSent(): HideHud[] { return flagList<HideHud>(new MemberFlags(this.id, 152), HIDE_HUD); }
+	set hideHudSent(values: HideHud[]) { setMemberCell(this.id, 152, HIDE_HUD.maskOf(values)); }
 
 	/**
 	 * The player's field of view in degrees: `90` is normal, `40` and `10` through a sniper scope. Setting it widens or narrows his view - `110` shows more - until the game sets it again: at spawn, when he draws a weapon, when he zooms.
 	 *
 	 * Pawn: `CBasePlayer::m_iFOV`
 	 */
-	get fov(): number { return memberCell(this.id, 152); }
+	get fov(): number { return memberCell(this.id, 153); }
 	set fov(value: number) {
-		setMemberCell(this.id, 152, <i32>value);
+		setMemberCell(this.id, 153, <i32>value);
 		setEntvarCell(this.id, 532, <i32>floatCell(value));
 	}
 
@@ -4367,24 +4437,24 @@ export class PlayerFields extends Entity {
 	 *
 	 * Pawn: `CBasePlayer::m_iClientFOV`
 	 */
-	get fovSent(): number { return memberCell(this.id, 153); }
-	set fovSent(value: number) { setMemberCell(this.id, 153, <i32>value); }
+	get fovSent(): number { return memberCell(this.id, 154); }
+	set fovSent(value: number) { setMemberCell(this.id, 154, <i32>value); }
 
 	/**
 	 * The number of times the player has spawned this round; with `mp_forcerespawn` off, a second spawn is refused.
 	 *
 	 * Pawn: `CBasePlayer::m_iNumSpawns`
 	 */
-	get spawnCount(): number { return memberCell(this.id, 154); }
-	set spawnCount(value: number) { setMemberCell(this.id, 154, <i32>value); }
+	get spawnCount(): number { return memberCell(this.id, 155); }
+	set spawnCount(value: number) { setMemberCell(this.id, 155, <i32>value); }
 
 	/**
 	 * An observer entity tied to the player; the game never creates one and only removes it when he disconnects.
 	 *
 	 * Pawn: `CBasePlayer::m_pObserver`
 	 */
-	get observer(): number { return memberCell(this.id, 155); }
-	set observer(value: number) { setMemberCell(this.id, 155, <i32>value); }
+	get observer(): number { return memberCell(this.id, 156); }
+	set observer(value: number) { setMemberCell(this.id, 156, <i32>value); }
 
 	/**
 	 * The weapon in the player's hands, or `null`. Read only.
@@ -4392,7 +4462,7 @@ export class PlayerFields extends Entity {
 	 * Pawn: `CBasePlayer::m_pActiveItem`
 	 */
 	get activeItem(): Weapon | null {
-		const index = memberCell(this.id, 156);
+		const index = memberCell(this.id, 157);
 		return index > 0 ? new Weapon(index) : null;
 	}
 
@@ -4402,7 +4472,7 @@ export class PlayerFields extends Entity {
 	 * Pawn: `CBasePlayer::m_pClientActiveItem`
 	 */
 	get activeItemSent(): Weapon | null {
-		const index = memberCell(this.id, 157);
+		const index = memberCell(this.id, 158);
 		return index > 0 ? new Weapon(index) : null;
 	}
 
@@ -4412,7 +4482,7 @@ export class PlayerFields extends Entity {
 	 * Pawn: `CBasePlayer::m_pLastItem`
 	 */
 	get lastItem(): Weapon | null {
-		const index = memberCell(this.id, 158);
+		const index = memberCell(this.id, 159);
 		return index > 0 ? new Weapon(index) : null;
 	}
 
@@ -4421,7 +4491,7 @@ export class PlayerFields extends Entity {
 	 *
 	 * Pawn: `CBasePlayer::m_vecAutoAim`
 	 */
-	get autoAim(): Vector { return memberVector(this.id, 159); }
+	get autoAim(): Vector { return memberVector(this.id, 160); }
 	/**
 	 * `autoAim`, written into `target`, which is returned: no new `Vector` is made - for code that runs every frame.
 	 *
@@ -4430,119 +4500,119 @@ export class PlayerFields extends Entity {
 	 * player.getAutoAim(autoAim);
 	 * ```
 	 */
-	getAutoAim(target: Vector): Vector { return memberVectorInto(this.id, 159, target); }
-	set autoAim(value: number[]) { setMemberVector(this.id, 159, value); }
+	getAutoAim(target: Vector): Vector { return memberVectorInto(this.id, 160, target); }
+	set autoAim(value: number[]) { setMemberVector(this.id, 160, value); }
 
 	/**
 	 * `true` while the player's aim assist has a target under the crosshair.
 	 *
 	 * Pawn: `CBasePlayer::m_fOnTarget`
 	 */
-	get aimingAtTarget(): boolean { return memberCell(this.id, 160) != 0; }
-	set aimingAtTarget(value: boolean) { setMemberCell(this.id, 160, value ? 1 : 0); }
+	get aimingAtTarget(): boolean { return memberCell(this.id, 161) != 0; }
+	set aimingAtTarget(value: boolean) { setMemberCell(this.id, 161, value ? 1 : 0); }
 
 	/**
 	 * The game time of the next update of the player's status bar (the name under the crosshair), every 0.2 seconds.
 	 *
 	 * Pawn: `CBasePlayer::m_flNextSBarUpdateTime`
 	 */
-	get nextStatusBarUpdate(): number { return cellFloat(memberCell(this.id, 161)); }
-	set nextStatusBarUpdate(value: number) { setMemberCell(this.id, 161, <i32>floatCell(value)); }
+	get nextStatusBarUpdate(): number { return cellFloat(memberCell(this.id, 162)); }
+	set nextStatusBarUpdate(value: number) { setMemberCell(this.id, 162, <i32>floatCell(value)); }
 
 	/**
 	 * The game time the status bar about the player under the crosshair stays until: 2 seconds after he leaves the crosshair.
 	 *
 	 * Pawn: `CBasePlayer::m_flStatusBarDisappearDelay`
 	 */
-	get statusBarDisappearDelay(): number { return cellFloat(memberCell(this.id, 162)); }
-	set statusBarDisappearDelay(value: number) { setMemberCell(this.id, 162, <i32>floatCell(value)); }
+	get statusBarDisappearDelay(): number { return cellFloat(memberCell(this.id, 163)); }
+	set statusBarDisappearDelay(value: number) { setMemberCell(this.id, 163, <i32>floatCell(value)); }
 
 	/**
 	 * The status bar text the game last sent the player - the line that names whom he aims at, as a format his client fills in.
 	 *
 	 * Pawn: `CBasePlayer::m_SbarString0`
 	 */
-	get statusBarText(): string { return memberText(this.id, 163); }
-	set statusBarText(value: string) { setMemberText(this.id, 163, value); }
+	get statusBarText(): string { return memberText(this.id, 164); }
+	set statusBarText(value: string) { setMemberText(this.id, 164, value); }
 
 	/**
 	 * The horizontal aim assist correction last sent to the player's client.
 	 *
 	 * Pawn: `CBasePlayer::m_lastx`
 	 */
-	get lastX(): number { return memberCell(this.id, 164); }
-	set lastX(value: number) { setMemberCell(this.id, 164, <i32>value); }
+	get lastX(): number { return memberCell(this.id, 165); }
+	set lastX(value: number) { setMemberCell(this.id, 165, <i32>value); }
 
 	/**
 	 * The vertical aim assist correction last sent to the player's client.
 	 *
 	 * Pawn: `CBasePlayer::m_lasty`
 	 */
-	get lastY(): number { return memberCell(this.id, 165); }
-	set lastY(value: number) { setMemberCell(this.id, 165, <i32>value); }
+	get lastY(): number { return memberCell(this.id, 166); }
+	set lastY(value: number) { setMemberCell(this.id, 166, <i32>value); }
 
 	/**
 	 * The number of frames in the player's own spray logo; `-1` for none.
 	 *
 	 * Pawn: `CBasePlayer::m_nCustomSprayFrames`
 	 */
-	get customSprayFrames(): number { return memberCell(this.id, 166); }
-	set customSprayFrames(value: number) { setMemberCell(this.id, 166, <i32>value); }
+	get customSprayFrames(): number { return memberCell(this.id, 167); }
+	set customSprayFrames(value: number) { setMemberCell(this.id, 167, <i32>value); }
 
 	/**
 	 * The game time when the player can spray again (decalfrequency).
 	 *
 	 * Pawn: `CBasePlayer::m_flNextDecalTime`
 	 */
-	get nextDecalTime(): number { return cellFloat(memberCell(this.id, 167)); }
-	set nextDecalTime(value: number) { setMemberCell(this.id, 167, <i32>floatCell(value)); }
+	get nextDecalTime(): number { return cellFloat(memberCell(this.id, 168)); }
+	set nextDecalTime(value: number) { setMemberCell(this.id, 168, <i32>floatCell(value)); }
 
 	/**
 	 * The index of the player's own model; the game sets `modelIndex` back to it, at spawn for one.
 	 *
 	 * Pawn: `CBasePlayer::m_modelIndexPlayer`
 	 */
-	get modelIndexPlayer(): number { return memberCell(this.id, 168); }
-	set modelIndexPlayer(value: number) { setMemberCell(this.id, 168, <i32>value); }
+	get modelIndexPlayer(): number { return memberCell(this.id, 169); }
+	set modelIndexPlayer(value: number) { setMemberCell(this.id, 169, <i32>value); }
 
 	/**
 	 * The animation set the player's model holds his weapon with, e.g. `"knife"`, `"rifle"`, `"c4"`.
 	 *
 	 * Pawn: `CBasePlayer::m_szAnimExtention`
 	 */
-	get animExtension(): string { return memberText(this.id, 169); }
-	set animExtension(value: string) { setMemberText(this.id, 169, value); }
+	get animExtension(): string { return memberText(this.id, 170); }
+	set animExtension(value: string) { setMemberText(this.id, 170, value); }
 
 	/**
 	 * The legs' animation the game picked for the player this frame.
 	 *
 	 * Pawn: `CBasePlayer::m_iGaitsequence`
 	 */
-	get playerGaitSequence(): number { return memberCell(this.id, 170); }
-	set playerGaitSequence(value: number) { setMemberCell(this.id, 170, <i32>value); }
+	get playerGaitSequence(): number { return memberCell(this.id, 171); }
+	set playerGaitSequence(value: number) { setMemberCell(this.id, 171, <i32>value); }
 
 	/**
 	 * The playback position of the player's legs' animation, in frames.
 	 *
 	 * Pawn: `CBasePlayer::m_flGaitframe`
 	 */
-	get gaitFrame(): number { return cellFloat(memberCell(this.id, 171)); }
-	set gaitFrame(value: number) { setMemberCell(this.id, 171, <i32>floatCell(value)); }
+	get gaitFrame(): number { return cellFloat(memberCell(this.id, 172)); }
+	set gaitFrame(value: number) { setMemberCell(this.id, 172, <i32>floatCell(value)); }
 
 	/**
 	 * The direction the player's legs face, in degrees; it catches up with the body's.
 	 *
 	 * Pawn: `CBasePlayer::m_flGaityaw`
 	 */
-	get gaitYaw(): number { return cellFloat(memberCell(this.id, 172)); }
-	set gaitYaw(value: number) { setMemberCell(this.id, 172, <i32>floatCell(value)); }
+	get gaitYaw(): number { return cellFloat(memberCell(this.id, 173)); }
+	set gaitYaw(value: number) { setMemberCell(this.id, 173, <i32>floatCell(value)); }
 
 	/**
 	 * The player's position on the previous animation update, to estimate his speed.
 	 *
 	 * Pawn: `CBasePlayer::m_prevgaitorigin`
 	 */
-	get prevGaitOrigin(): Vector { return memberVector(this.id, 173); }
+	get prevGaitOrigin(): Vector { return memberVector(this.id, 174); }
 	/**
 	 * `prevGaitOrigin`, written into `target`, which is returned: no new `Vector` is made - for code that runs every frame.
 	 *
@@ -4551,250 +4621,250 @@ export class PlayerFields extends Entity {
 	 * player.getPrevGaitOrigin(prevGaitOrigin);
 	 * ```
 	 */
-	getPrevGaitOrigin(target: Vector): Vector { return memberVectorInto(this.id, 173, target); }
-	set prevGaitOrigin(value: number[]) { setMemberVector(this.id, 173, value); }
+	getPrevGaitOrigin(target: Vector): Vector { return memberVectorInto(this.id, 174, target); }
+	set prevGaitOrigin(value: number[]) { setMemberVector(this.id, 174, value); }
 
 	/**
 	 * The upper body's tilt the game worked out for the player's model.
 	 *
 	 * Pawn: `CBasePlayer::m_flPitch`
 	 */
-	get pitch(): number { return cellFloat(memberCell(this.id, 174)); }
-	set pitch(value: number) { setMemberCell(this.id, 174, <i32>floatCell(value)); }
+	get pitch(): number { return cellFloat(memberCell(this.id, 175)); }
+	set pitch(value: number) { setMemberCell(this.id, 175, <i32>floatCell(value)); }
 
 	/**
 	 * The turn of the player's upper body against the legs, in degrees.
 	 *
 	 * Pawn: `CBasePlayer::m_flYaw`
 	 */
-	get yaw(): number { return cellFloat(memberCell(this.id, 175)); }
-	set yaw(value: number) { setMemberCell(this.id, 175, <i32>floatCell(value)); }
+	get yaw(): number { return cellFloat(memberCell(this.id, 176)); }
+	set yaw(value: number) { setMemberCell(this.id, 176, <i32>floatCell(value)); }
 
 	/**
 	 * The distance the player moved since the previous animation update, for the legs' animation.
 	 *
 	 * Pawn: `CBasePlayer::m_flGaitMovement`
 	 */
-	get gaitMovement(): number { return cellFloat(memberCell(this.id, 176)); }
-	set gaitMovement(value: number) { setMemberCell(this.id, 176, <i32>floatCell(value)); }
+	get gaitMovement(): number { return cellFloat(memberCell(this.id, 177)); }
+	set gaitMovement(value: number) { setMemberCell(this.id, 177, <i32>floatCell(value)); }
 
 	/**
 	 * The player's `_cl_autowepswitch` setting: `0` never switch to a picked-up weapon, `1` always, `2` only when not firing.
 	 *
 	 * Pawn: `CBasePlayer::m_iAutoWepSwitch`
 	 */
-	get autoSwitchWeapon(): number { return memberCell(this.id, 177); }
-	set autoSwitchWeapon(value: number) { setMemberCell(this.id, 177, <i32>value); }
+	get autoSwitchWeapon(): number { return memberCell(this.id, 178); }
+	set autoSwitchWeapon(value: number) { setMemberCell(this.id, 178, <i32>value); }
 
 	/**
 	 * `true` if the player uses the graphical (VGUI) menus — his `_vgui_menus` setting.
 	 *
 	 * Pawn: `CBasePlayer::m_bVGUIMenus`
 	 */
-	get vguiMenus(): boolean { return memberCell(this.id, 178) != 0; }
-	set vguiMenus(value: boolean) { setMemberCell(this.id, 178, value ? 1 : 0); }
+	get vguiMenus(): boolean { return memberCell(this.id, 179) != 0; }
+	set vguiMenus(value: boolean) { setMemberCell(this.id, 179, value ? 1 : 0); }
 
 	/**
 	 * `true` if the player wants hints — his _ah setting.
 	 *
 	 * Pawn: `CBasePlayer::m_bShowHints`
 	 */
-	get showHints(): boolean { return memberCell(this.id, 179) != 0; }
-	set showHints(value: boolean) { setMemberCell(this.id, 179, value ? 1 : 0); }
+	get showHints(): boolean { return memberCell(this.id, 180) != 0; }
+	set showHints(value: boolean) { setMemberCell(this.id, 180, value ? 1 : 0); }
 
 	/**
 	 * `true` while the player holds his shield up.
 	 *
 	 * Pawn: `CBasePlayer::m_bShieldDrawn`
 	 */
-	get shieldDrawn(): boolean { return memberCell(this.id, 180) != 0; }
-	set shieldDrawn(value: boolean) { setMemberCell(this.id, 180, value ? 1 : 0); }
+	get shieldDrawn(): boolean { return memberCell(this.id, 181) != 0; }
+	set shieldDrawn(value: boolean) { setMemberCell(this.id, 181, value ? 1 : 0); }
 
 	/**
 	 * `true` if the player has a tactical shield.
 	 *
 	 * Pawn: `CBasePlayer::m_bOwnsShield`
 	 */
-	get ownsShield(): boolean { return memberCell(this.id, 181) != 0; }
-	set ownsShield(value: boolean) { setMemberCell(this.id, 181, value ? 1 : 0); }
+	get ownsShield(): boolean { return memberCell(this.id, 182) != 0; }
+	set ownsShield(value: boolean) { setMemberCell(this.id, 182, value ? 1 : 0); }
 
 	/**
 	 * `true` if the spectator was following a player before he switched to free look.
 	 *
 	 * Pawn: `CBasePlayer::m_bWasFollowing`
 	 */
-	get wasFollowing(): boolean { return memberCell(this.id, 182) != 0; }
-	set wasFollowing(value: boolean) { setMemberCell(this.id, 182, value ? 1 : 0); }
+	get wasFollowing(): boolean { return memberCell(this.id, 183) != 0; }
+	set wasFollowing(value: boolean) { setMemberCell(this.id, 183, value ? 1 : 0); }
 
 	/**
 	 * The game time when the spectator can switch to the next player again.
 	 *
 	 * Pawn: `CBasePlayer::m_flNextFollowTime`
 	 */
-	get nextFollowTime(): number { return cellFloat(memberCell(this.id, 183)); }
-	set nextFollowTime(value: number) { setMemberCell(this.id, 183, <i32>floatCell(value)); }
+	get nextFollowTime(): number { return cellFloat(memberCell(this.id, 184)); }
+	set nextFollowTime(value: number) { setMemberCell(this.id, 184, <i32>floatCell(value)); }
 
 	/**
 	 * The speed at which the player's legs turn after the body, for his animation.
 	 *
 	 * Pawn: `CBasePlayer::m_flYawModifier`
 	 */
-	get yawModifier(): number { return cellFloat(memberCell(this.id, 184)); }
-	set yawModifier(value: number) { setMemberCell(this.id, 184, <i32>floatCell(value)); }
+	get yawModifier(): number { return cellFloat(memberCell(this.id, 185)); }
+	set yawModifier(value: number) { setMemberCell(this.id, 185, <i32>floatCell(value)); }
 
 	/**
 	 * The game time when the player's flashbang blindness ends. Writing it does not blind the screen — that is `player.screen.fade`.
 	 *
 	 * Pawn: `CBasePlayer::m_blindUntilTime`
 	 */
-	get blindUntilTime(): number { return cellFloat(memberCell(this.id, 185)); }
-	set blindUntilTime(value: number) { setMemberCell(this.id, 185, <i32>floatCell(value)); }
+	get blindUntilTime(): number { return cellFloat(memberCell(this.id, 186)); }
+	set blindUntilTime(value: number) { setMemberCell(this.id, 186, <i32>floatCell(value)); }
 
 	/**
 	 * The game time when the player was blinded.
 	 *
 	 * Pawn: `CBasePlayer::m_blindStartTime`
 	 */
-	get blindStartTime(): number { return cellFloat(memberCell(this.id, 186)); }
-	set blindStartTime(value: number) { setMemberCell(this.id, 186, <i32>floatCell(value)); }
+	get blindStartTime(): number { return cellFloat(memberCell(this.id, 187)); }
+	set blindStartTime(value: number) { setMemberCell(this.id, 187, <i32>floatCell(value)); }
 
 	/**
 	 * The time the player's blindness stays full, in seconds.
 	 *
 	 * Pawn: `CBasePlayer::m_blindHoldTime`
 	 */
-	get blindHoldTime(): number { return cellFloat(memberCell(this.id, 187)); }
-	set blindHoldTime(value: number) { setMemberCell(this.id, 187, <i32>floatCell(value)); }
+	get blindHoldTime(): number { return cellFloat(memberCell(this.id, 188)); }
+	set blindHoldTime(value: number) { setMemberCell(this.id, 188, <i32>floatCell(value)); }
 
 	/**
 	 * The time the player's blindness takes to fade, in seconds.
 	 *
 	 * Pawn: `CBasePlayer::m_blindFadeTime`
 	 */
-	get blindFadeTime(): number { return cellFloat(memberCell(this.id, 188)); }
-	set blindFadeTime(value: number) { setMemberCell(this.id, 188, <i32>floatCell(value)); }
+	get blindFadeTime(): number { return cellFloat(memberCell(this.id, 189)); }
+	set blindFadeTime(value: number) { setMemberCell(this.id, 189, <i32>floatCell(value)); }
 
 	/**
 	 * The strength of the player's blindness, `0` to `255`; `255` is fully blind.
 	 *
 	 * Pawn: `CBasePlayer::m_blindAlpha`
 	 */
-	get blindAlpha(): number { return memberCell(this.id, 189); }
-	set blindAlpha(value: number) { setMemberCell(this.id, 189, <i32>value); }
+	get blindAlpha(): number { return memberCell(this.id, 190); }
+	set blindAlpha(value: number) { setMemberCell(this.id, 190, <i32>value); }
 
 	/**
 	 * The game time from which a bot may follow teammates on its own.
 	 *
 	 * Pawn: `CBasePlayer::m_allowAutoFollowTime`
 	 */
-	get allowAutoFollowTime(): number { return cellFloat(memberCell(this.id, 190)); }
-	set allowAutoFollowTime(value: number) { setMemberCell(this.id, 190, <i32>floatCell(value)); }
+	get allowAutoFollowTime(): number { return cellFloat(memberCell(this.id, 191)); }
+	set allowAutoFollowTime(value: number) { setMemberCell(this.id, 191, <i32>floatCell(value)); }
 
 	/**
 	 * The player's autobuy list: the items his client sent for `autobuy`.
 	 *
 	 * Pawn: `CBasePlayer::m_autoBuyString`
 	 */
-	get autoBuyString(): string { return memberText(this.id, 191); }
-	set autoBuyString(value: string) { setMemberText(this.id, 191, value); }
+	get autoBuyString(): string { return memberText(this.id, 192); }
+	set autoBuyString(value: string) { setMemberText(this.id, 192, value); }
 
 	/**
 	 * The player's rebuy list: the items his client sent for `rebuy`.
 	 *
 	 * Pawn: `CBasePlayer::m_rebuyString`
 	 */
-	get rebuyString(): string { return memberText(this.id, 192); }
-	set rebuyString(value: string) { setMemberText(this.id, 192, value); }
+	get rebuyString(): string { return memberText(this.id, 193); }
+	set rebuyString(value: string) { setMemberText(this.id, 193, value); }
 
 	/**
 	 * `true` while the rebuy command is buying the player's last equipment.
 	 *
 	 * Pawn: `CBasePlayer::m_bIsInRebuy`
 	 */
-	get isInRebuy(): boolean { return memberCell(this.id, 193) != 0; }
-	set isInRebuy(value: boolean) { setMemberCell(this.id, 193, value ? 1 : 0); }
+	get isInRebuy(): boolean { return memberCell(this.id, 194) != 0; }
+	set isInRebuy(value: boolean) { setMemberCell(this.id, 194, value ? 1 : 0); }
 
 	/**
 	 * The game time of the last update of the player's location name (the place on the map).
 	 *
 	 * Pawn: `CBasePlayer::m_flLastUpdateTime`
 	 */
-	get lastUpdateTime(): number { return cellFloat(memberCell(this.id, 194)); }
-	set lastUpdateTime(value: number) { setMemberCell(this.id, 194, <i32>floatCell(value)); }
+	get lastUpdateTime(): number { return cellFloat(memberCell(this.id, 195)); }
+	set lastUpdateTime(value: number) { setMemberCell(this.id, 195, <i32>floatCell(value)); }
 
 	/**
 	 * The name of the place on the map the player was last in, which the radio and team chat name, e.g. `"BombsiteA"`.
 	 *
 	 * Pawn: `CBasePlayer::m_lastLocation`
 	 */
-	get lastLocation(): string { return memberText(this.id, 195); }
-	set lastLocation(value: string) { setMemberText(this.id, 195, value); }
+	get lastLocation(): string { return memberText(this.id, 196); }
+	set lastLocation(value: string) { setMemberText(this.id, 196, value); }
 
 	/**
 	 * The game time when the player's progress bar (defusing, planting) started; `0` for none.
 	 *
 	 * Pawn: `CBasePlayer::m_progressStart`
 	 */
-	get progressBarStart(): number { return cellFloat(memberCell(this.id, 196)); }
-	set progressBarStart(value: number) { setMemberCell(this.id, 196, <i32>floatCell(value)); }
+	get progressBarStart(): number { return cellFloat(memberCell(this.id, 197)); }
+	set progressBarStart(value: number) { setMemberCell(this.id, 197, <i32>floatCell(value)); }
 
 	/**
 	 * The game time when the player's progress bar fills.
 	 *
 	 * Pawn: `CBasePlayer::m_progressEnd`
 	 */
-	get progressBarEnd(): number { return cellFloat(memberCell(this.id, 197)); }
-	set progressBarEnd(value: number) { setMemberCell(this.id, 197, <i32>floatCell(value)); }
+	get progressBarEnd(): number { return cellFloat(memberCell(this.id, 198)); }
+	set progressBarEnd(value: number) { setMemberCell(this.id, 198, <i32>floatCell(value)); }
 
 	/**
 	 * `true` if the spectator's chase camera follows the target's view rather than turning freely.
 	 *
 	 * Pawn: `CBasePlayer::m_bObserverAutoDirector`
 	 */
-	get observerAutoDirector(): boolean { return memberCell(this.id, 198) != 0; }
-	set observerAutoDirector(value: boolean) { setMemberCell(this.id, 198, value ? 1 : 0); }
+	get observerAutoDirector(): boolean { return memberCell(this.id, 199) != 0; }
+	set observerAutoDirector(value: boolean) { setMemberCell(this.id, 199, value ? 1 : 0); }
 
 	/**
 	 * `true` if the spectator may change his view mode; `false` right after death.
 	 *
 	 * Pawn: `CBasePlayer::m_canSwitchObserverModes`
 	 */
-	get canSwitchObserverModes(): boolean { return memberCell(this.id, 199) != 0; }
-	set canSwitchObserverModes(value: boolean) { setMemberCell(this.id, 199, value ? 1 : 0); }
+	get canSwitchObserverModes(): boolean { return memberCell(this.id, 200) != 0; }
+	set canSwitchObserverModes(value: boolean) { setMemberCell(this.id, 200, value ? 1 : 0); }
 
 	/**
 	 * A Condition Zero leftover; the game does not use it.
 	 *
 	 * Pawn: `CBasePlayer::m_heartBeatTime`
 	 */
-	get heartBeatTime(): number { return cellFloat(memberCell(this.id, 200)); }
-	set heartBeatTime(value: number) { setMemberCell(this.id, 200, <i32>floatCell(value)); }
+	get heartBeatTime(): number { return cellFloat(memberCell(this.id, 201)); }
+	set heartBeatTime(value: number) { setMemberCell(this.id, 201, <i32>floatCell(value)); }
 
 	/**
 	 * A Condition Zero leftover; the game does not use it.
 	 *
 	 * Pawn: `CBasePlayer::m_intenseTimestamp`
 	 */
-	get intenseTimestamp(): number { return cellFloat(memberCell(this.id, 201)); }
-	set intenseTimestamp(value: number) { setMemberCell(this.id, 201, <i32>floatCell(value)); }
+	get intenseTimestamp(): number { return cellFloat(memberCell(this.id, 202)); }
+	set intenseTimestamp(value: number) { setMemberCell(this.id, 202, <i32>floatCell(value)); }
 
 	/**
 	 * A Condition Zero leftover; the game does not use it.
 	 *
 	 * Pawn: `CBasePlayer::m_silentTimestamp`
 	 */
-	get silentTimestamp(): number { return cellFloat(memberCell(this.id, 202)); }
-	set silentTimestamp(value: number) { setMemberCell(this.id, 202, <i32>floatCell(value)); }
+	get silentTimestamp(): number { return cellFloat(memberCell(this.id, 203)); }
+	set silentTimestamp(value: number) { setMemberCell(this.id, 203, <i32>floatCell(value)); }
 
 	/**
 	 * A Condition Zero leftover, one of: `"silent"`, `"calm"`, `"intense"`; the game does not use it.
 	 *
 	 * Pawn: `CBasePlayer::m_musicState`
 	 */
-	get musicState(): MusicState { return musicStateName(memberCell(this.id, 203)); }
+	get musicState(): MusicState { return musicStateName(memberCell(this.id, 204)); }
 	set musicState(value: MusicState) {
 		const cell = musicStateCell(value);
-		if (cell != UNNAMED) setMemberCell(this.id, 203, cell);
+		if (cell != UNNAMED) setMemberCell(this.id, 204, cell);
 	}
 
 	/**
@@ -4802,24 +4872,24 @@ export class PlayerFields extends Entity {
 	 *
 	 * Pawn: `CBasePlayer::m_iLastAccount`
 	 */
-	get lastSentMoney(): number { return memberCell(this.id, 204); }
-	set lastSentMoney(value: number) { setMemberCell(this.id, 204, <i32>value); }
+	get lastSentMoney(): number { return memberCell(this.id, 205); }
+	set lastSentMoney(value: number) { setMemberCell(this.id, 205, <i32>value); }
 
 	/**
 	 * The player's health last sent to the other players' scoreboards.
 	 *
 	 * Pawn: `CBasePlayer::m_iLastClientHealth`
 	 */
-	get lastClientHealth(): number { return memberCell(this.id, 205); }
-	set lastClientHealth(value: number) { setMemberCell(this.id, 205, <i32>value); }
+	get lastClientHealth(): number { return memberCell(this.id, 206); }
+	set lastClientHealth(value: number) { setMemberCell(this.id, 206, <i32>value); }
 
 	/**
 	 * The game time when the player's money and health are next sent to the scoreboards, even unchanged; every 5 seconds.
 	 *
 	 * Pawn: `CBasePlayer::m_tmNextAccountHealthUpdate`
 	 */
-	get nextScoreboardUpdate(): number { return cellFloat(memberCell(this.id, 206)); }
-	set nextScoreboardUpdate(value: number) { setMemberCell(this.id, 206, <i32>floatCell(value)); }
+	get nextScoreboardUpdate(): number { return cellFloat(memberCell(this.id, 207)); }
+	set nextScoreboardUpdate(value: number) { setMemberCell(this.id, 207, <i32>floatCell(value)); }
 
 	/**
 	 * The player's spectator mode, one of: `"none"` - not spectating; `"chaseLocked"` - a camera behind the target that turns with him; `"chaseFree"` - a camera behind the target that turns freely; `"roaming"` - flies freely; `"inEye"` - first person, through the target's eyes; `"mapFree"` - the overview map, moving freely; `"mapChase"` - the overview map, following the target. Setting a mode switches his camera as the game does when he picks it: onto someone he may watch, `"roaming"` when there is nobody; the target is iuser2. Setting `"none"` only clears the field: the game ends spectating when he spawns.
@@ -4924,186 +4994,186 @@ export class GameFields {
 	 *
 	 * Pawn: `CSGameRules::m_bFreezePeriod`
 	 */
-	get isFreezeTime(): boolean { return gameCell(207, m_bFreezePeriod) != 0; }
-	set isFreezeTime(value: boolean) { setGameCell(207, m_bFreezePeriod, value ? 1 : 0); }
+	get isFreezeTime(): boolean { return gameCell(208) != 0; }
+	set isFreezeTime(value: boolean) { setGameCell(208, value ? 1 : 0); }
 
 	/**
 	 * `true` while the bomb lies on the ground, dropped by its carrier.
 	 *
 	 * Pawn: `CSGameRules::m_bBombDropped`
 	 */
-	get bombDropped(): boolean { return gameCell(208, m_bBombDropped) != 0; }
-	set bombDropped(value: boolean) { setGameCell(208, m_bBombDropped, value ? 1 : 0); }
+	get bombDropped(): boolean { return gameCell(209) != 0; }
+	set bombDropped(value: boolean) { setGameCell(209, value ? 1 : 0); }
 
 	/**
 	 * The game's name in the server browser, e.g. `"Counter-Strike"`.
 	 *
 	 * Pawn: `CSGameRules::m_GameDesc`
 	 */
-	get gameName(): string { return reapiGameText(m_GameDesc, "gameName", gameNameHlds); }
-	set gameName(value: string) { setReapiGameText(m_GameDesc, "gameName", value, setGameNameHlds); }
+	get gameName(): string { return regameText("gameName", gameNameHlds); }
+	set gameName(value: string) { setRegameText("gameName", value, setGameNameHlds); }
 
 	/**
 	 * The number of player slots, as the game's voice code counts them.
 	 *
 	 * Pawn: `CSGameRules::m_nMaxPlayers`
 	 */
-	get maxPlayers(): number { return reapiGameCell(m_nMaxPlayers, "maxPlayers", maxPlayersHlds); }
-	set maxPlayers(value: number) { setReapiGameCell(m_nMaxPlayers, "maxPlayers", <i32>value, setMaxPlayersHlds); }
+	get maxPlayers(): number { return regameCell(211, "maxPlayers", maxPlayersHlds); }
+	set maxPlayers(value: number) { setRegameCell(211, "maxPlayers", <i32>value, setMaxPlayersHlds); }
 
 	/**
 	 * The seconds between the game's updates of who hears whom on the voice chat.
 	 *
 	 * Pawn: `CSGameRules::m_UpdateInterval`
 	 */
-	get updateInterval(): number { return cellFloat(reapiGameCell(m_UpdateInterval, "updateInterval")); }
-	set updateInterval(value: number) { setReapiGameCell(m_UpdateInterval, "updateInterval", <i32>floatCell(value)); }
+	get updateInterval(): number { return cellFloat(regameCell(212, "updateInterval")); }
+	set updateInterval(value: number) { setRegameCell(212, "updateInterval", <i32>floatCell(value)); }
 
 	/**
 	 * The game time the next round starts at, after a round's end or a restart; `0` when none is due.
 	 *
 	 * Pawn: `CSGameRules::m_flRestartRoundTime`
 	 */
-	get newRoundTime(): number { return cellFloat(gameCell(209, m_flRestartRoundTime)); }
-	set newRoundTime(value: number) { setGameCell(209, m_flRestartRoundTime, <i32>floatCell(value)); }
+	get newRoundTime(): number { return cellFloat(gameCell(213)); }
+	set newRoundTime(value: number) { setGameCell(213, <i32>floatCell(value)); }
 
 	/**
 	 * The game time of the game's next check whether a side has won; `0` when none is due.
 	 *
 	 * Pawn: `CSGameRules::m_flCheckWinConditions`
 	 */
-	get checkWinConditionsTime(): number { return cellFloat(gameCell(210, m_flCheckWinConditions)); }
-	set checkWinConditionsTime(value: number) { setGameCell(210, m_flCheckWinConditions, <i32>floatCell(value)); }
+	get checkWinConditionsTime(): number { return cellFloat(gameCell(214)); }
+	set checkWinConditionsTime(value: number) { setGameCell(214, <i32>floatCell(value)); }
 
 	/**
 	 * The game time the round's play began: the end of the freeze time.
 	 *
 	 * Pawn: `CSGameRules::m_fRoundStartTime`
 	 */
-	get roundStartTime(): number { return cellFloat(gameCell(211, m_fRoundStartTime)); }
-	set roundStartTime(value: number) { setGameCell(211, m_fRoundStartTime, <i32>floatCell(value)); }
+	get roundStartTime(): number { return cellFloat(gameCell(215)); }
+	set roundStartTime(value: number) { setGameCell(215, <i32>floatCell(value)); }
 
 	/**
 	 * The round's length in seconds; during the freeze time, the freeze time's.
 	 *
 	 * Pawn: `CSGameRules::m_iRoundTime`
 	 */
-	get roundTime(): number { return gameCell(212, m_iRoundTime); }
-	set roundTime(value: number) { setGameCell(212, m_iRoundTime, <i32>value); }
+	get roundTime(): number { return gameCell(216); }
+	set roundTime(value: number) { setGameCell(216, <i32>value); }
 
 	/**
 	 * The round's length in seconds, from `mp_roundtime`.
 	 *
 	 * Pawn: `CSGameRules::m_iRoundTimeSecs`
 	 */
-	get roundTimeSecs(): number { return gameCell(213, m_iRoundTimeSecs); }
-	set roundTimeSecs(value: number) { setGameCell(213, m_iRoundTimeSecs, <i32>value); }
+	get roundTimeSecs(): number { return gameCell(217); }
+	set roundTimeSecs(value: number) { setGameCell(217, <i32>value); }
 
 	/**
 	 * The freeze time's length in seconds, from `mp_freezetime`.
 	 *
 	 * Pawn: `CSGameRules::m_iIntroRoundTime`
 	 */
-	get freezeTime(): number { return gameCell(214, m_iIntroRoundTime); }
-	set freezeTime(value: number) { setGameCell(214, m_iIntroRoundTime, <i32>value); }
+	get freezeTime(): number { return gameCell(218); }
+	set freezeTime(value: number) { setGameCell(218, <i32>value); }
 
 	/**
 	 * The game time the round started, the freeze time included.
 	 *
 	 * Pawn: `CSGameRules::m_fRoundStartTimeReal`
 	 */
-	get freezeStartTime(): number { return cellFloat(gameCell(215, m_fRoundStartTimeReal)); }
-	set freezeStartTime(value: number) { setGameCell(215, m_fRoundStartTimeReal, <i32>floatCell(value)); }
+	get freezeStartTime(): number { return cellFloat(gameCell(219)); }
+	set freezeStartTime(value: number) { setGameCell(219, <i32>floatCell(value)); }
 
 	/**
 	 * The money every terrorist is paid when the next round starts, for how this one went.
 	 *
 	 * Pawn: `CSGameRules::m_iAccountTerrorist`
 	 */
-	get terroristRoundBonus(): number { return gameCell(216, m_iAccountTerrorist); }
-	set terroristRoundBonus(value: number) { setGameCell(216, m_iAccountTerrorist, <i32>value); }
+	get terroristRoundBonus(): number { return gameCell(220); }
+	set terroristRoundBonus(value: number) { setGameCell(220, <i32>value); }
 
 	/**
 	 * The money every counter-terrorist is paid when the next round starts, for how this one went.
 	 *
 	 * Pawn: `CSGameRules::m_iAccountCT`
 	 */
-	get ctRoundBonus(): number { return gameCell(217, m_iAccountCT); }
-	set ctRoundBonus(value: number) { setGameCell(217, m_iAccountCT, <i32>value); }
+	get ctRoundBonus(): number { return gameCell(221); }
+	set ctRoundBonus(value: number) { setGameCell(221, <i32>value); }
 
 	/**
 	 * The number of terrorists, counted when a round ends.
 	 *
 	 * Pawn: `CSGameRules::m_iNumTerrorist`
 	 */
-	get terroristCount(): number { return gameCell(218, m_iNumTerrorist); }
-	set terroristCount(value: number) { setGameCell(218, m_iNumTerrorist, <i32>value); }
+	get terroristCount(): number { return gameCell(222); }
+	set terroristCount(value: number) { setGameCell(222, <i32>value); }
 
 	/**
 	 * The number of counter-terrorists, counted when a round ends.
 	 *
 	 * Pawn: `CSGameRules::m_iNumCT`
 	 */
-	get ctCount(): number { return gameCell(219, m_iNumCT); }
-	set ctCount(value: number) { setGameCell(219, m_iNumCT, <i32>value); }
+	get ctCount(): number { return gameCell(223); }
+	set ctCount(value: number) { setGameCell(223, <i32>value); }
 
 	/**
 	 * The number of terrorists who can spawn in the next round, counted when a round ends.
 	 *
 	 * Pawn: `CSGameRules::m_iNumSpawnableTerrorist`
 	 */
-	get spawnableTerrorists(): number { return gameCell(220, m_iNumSpawnableTerrorist); }
-	set spawnableTerrorists(value: number) { setGameCell(220, m_iNumSpawnableTerrorist, <i32>value); }
+	get spawnableTerrorists(): number { return gameCell(224); }
+	set spawnableTerrorists(value: number) { setGameCell(224, <i32>value); }
 
 	/**
 	 * The number of counter-terrorists who can spawn in the next round, counted when a round ends.
 	 *
 	 * Pawn: `CSGameRules::m_iNumSpawnableCT`
 	 */
-	get spawnableCts(): number { return gameCell(221, m_iNumSpawnableCT); }
-	set spawnableCts(value: number) { setGameCell(221, m_iNumSpawnableCT, <i32>value); }
+	get spawnableCts(): number { return gameCell(225); }
+	set spawnableCts(value: number) { setGameCell(225, <i32>value); }
 
 	/**
 	 * The number of the map's terrorist spawn points.
 	 *
 	 * Pawn: `CSGameRules::m_iSpawnPointCount_Terrorist`
 	 */
-	get spawnPointCountTerrorist(): number { return gameCell(222, m_iSpawnPointCount_Terrorist); }
-	set spawnPointCountTerrorist(value: number) { setGameCell(222, m_iSpawnPointCount_Terrorist, <i32>value); }
+	get spawnPointCountTerrorist(): number { return gameCell(226); }
+	set spawnPointCountTerrorist(value: number) { setGameCell(226, <i32>value); }
 
 	/**
 	 * The number of the map's counter-terrorist spawn points.
 	 *
 	 * Pawn: `CSGameRules::m_iSpawnPointCount_CT`
 	 */
-	get spawnPointCountCt(): number { return gameCell(223, m_iSpawnPointCount_CT); }
-	set spawnPointCountCt(value: number) { setGameCell(223, m_iSpawnPointCount_CT, <i32>value); }
+	get spawnPointCountCt(): number { return gameCell(227); }
+	set spawnPointCountCt(value: number) { setGameCell(227, <i32>value); }
 
 	/**
 	 * The number of hostages rescued this round.
 	 *
 	 * Pawn: `CSGameRules::m_iHostagesRescued`
 	 */
-	get hostagesRescued(): number { return gameCell(224, m_iHostagesRescued); }
-	set hostagesRescued(value: number) { setGameCell(224, m_iHostagesRescued, <i32>value); }
+	get hostagesRescued(): number { return gameCell(228); }
+	set hostagesRescued(value: number) { setGameCell(228, <i32>value); }
 
 	/**
 	 * The number of hostages a counter-terrorist has led away this round.
 	 *
 	 * Pawn: `CSGameRules::m_iHostagesTouched`
 	 */
-	get hostagesTouched(): number { return gameCell(225, m_iHostagesTouched); }
-	set hostagesTouched(value: number) { setGameCell(225, m_iHostagesTouched, <i32>value); }
+	get hostagesTouched(): number { return gameCell(229); }
+	set hostagesTouched(value: number) { setGameCell(229, <i32>value); }
 
 	/**
 	 * The last round's winner, one of `"CT"`, `"TERRORIST"`, `"draw"`, or `"none"` while the round goes on.
 	 *
 	 * Pawn: `CSGameRules::m_iRoundWinStatus`
 	 */
-	get roundWinner(): RoundWinner { return roundWinnerName(gameCell(226, m_iRoundWinStatus)); }
+	get roundWinner(): RoundWinner { return roundWinnerName(gameCell(230)); }
 	set roundWinner(value: RoundWinner) {
 		const cell = roundWinnerCell(value);
-		if (cell != UNNAMED) setGameCell(226, m_iRoundWinStatus, cell);
+		if (cell != UNNAMED) setGameCell(230, cell);
 	}
 
 	/**
@@ -5111,7 +5181,7 @@ export class GameFields {
 	 *
 	 * Pawn: `CSGameRules::m_iNumCTWins`, `rg_update_teamscores`
 	 */
-	get ctWins(): number { return gameCell(3, m_iNumCTWins); }
+	get ctWins(): number { return gameCell(3); }
 	set ctWins(value: number) { setTeamScores(value, this.terroristWins); }
 
 	/**
@@ -5119,7 +5189,7 @@ export class GameFields {
 	 *
 	 * Pawn: `CSGameRules::m_iNumTerroristWins`, `rg_update_teamscores`
 	 */
-	get terroristWins(): number { return gameCell(4, m_iNumTerroristWins); }
+	get terroristWins(): number { return gameCell(4); }
 	set terroristWins(value: number) { setTeamScores(this.ctWins, value); }
 
 	/**
@@ -5127,66 +5197,66 @@ export class GameFields {
 	 *
 	 * Pawn: `CSGameRules::m_bTargetBombed`
 	 */
-	get targetBombed(): boolean { return gameCell(227, m_bTargetBombed) != 0; }
-	set targetBombed(value: boolean) { setGameCell(227, m_bTargetBombed, value ? 1 : 0); }
+	get targetBombed(): boolean { return gameCell(231) != 0; }
+	set targetBombed(value: boolean) { setGameCell(231, value ? 1 : 0); }
 
 	/**
 	 * `true` once the bomb has been defused this round.
 	 *
 	 * Pawn: `CSGameRules::m_bBombDefused`
 	 */
-	get bombDefused(): boolean { return gameCell(228, m_bBombDefused) != 0; }
-	set bombDefused(value: boolean) { setGameCell(228, m_bBombDefused, value ? 1 : 0); }
+	get bombDefused(): boolean { return gameCell(232) != 0; }
+	set bombDefused(value: boolean) { setGameCell(232, value ? 1 : 0); }
 
 	/**
 	 * `true` when the map has a bomb site.
 	 *
 	 * Pawn: `CSGameRules::m_bMapHasBombTarget`
 	 */
-	get mapHasBombTarget(): boolean { return gameCell(229, m_bMapHasBombTarget) != 0; }
-	set mapHasBombTarget(value: boolean) { setGameCell(229, m_bMapHasBombTarget, value ? 1 : 0); }
+	get mapHasBombTarget(): boolean { return gameCell(233) != 0; }
+	set mapHasBombTarget(value: boolean) { setGameCell(233, value ? 1 : 0); }
 
 	/**
 	 * `true` when the map has a bomb zone a planter must stand in.
 	 *
 	 * Pawn: `CSGameRules::m_bMapHasBombZone`
 	 */
-	get mapHasBombZone(): boolean { return gameCell(230, m_bMapHasBombZone) != 0; }
-	set mapHasBombZone(value: boolean) { setGameCell(230, m_bMapHasBombZone, value ? 1 : 0); }
+	get mapHasBombZone(): boolean { return gameCell(234) != 0; }
+	set mapHasBombZone(value: boolean) { setGameCell(234, value ? 1 : 0); }
 
 	/**
 	 * `true` when the map has buy zones of its own.
 	 *
 	 * Pawn: `CSGameRules::m_bMapHasBuyZone`
 	 */
-	get mapHasBuyZone(): boolean { return gameCell(231, m_bMapHasBuyZone) != 0; }
-	set mapHasBuyZone(value: boolean) { setGameCell(231, m_bMapHasBuyZone, value ? 1 : 0); }
+	get mapHasBuyZone(): boolean { return gameCell(235) != 0; }
+	set mapHasBuyZone(value: boolean) { setGameCell(235, value ? 1 : 0); }
 
 	/**
 	 * `true` when the map has a hostage rescue zone.
 	 *
 	 * Pawn: `CSGameRules::m_bMapHasRescueZone`
 	 */
-	get mapHasRescueZone(): boolean { return gameCell(232, m_bMapHasRescueZone) != 0; }
-	set mapHasRescueZone(value: boolean) { setGameCell(232, m_bMapHasRescueZone, value ? 1 : 0); }
+	get mapHasRescueZone(): boolean { return gameCell(236) != 0; }
+	set mapHasRescueZone(value: boolean) { setGameCell(236, value ? 1 : 0); }
 
 	/**
 	 * `true` when the map has an escape zone for the terrorists.
 	 *
 	 * Pawn: `CSGameRules::m_bMapHasEscapeZone`
 	 */
-	get mapHasEscapeZone(): boolean { return gameCell(233, m_bMapHasEscapeZone) != 0; }
-	set mapHasEscapeZone(value: boolean) { setGameCell(233, m_bMapHasEscapeZone, value ? 1 : 0); }
+	get mapHasEscapeZone(): boolean { return gameCell(237) != 0; }
+	set mapHasEscapeZone(value: boolean) { setGameCell(237, value ? 1 : 0); }
 
 	/**
 	 * Whether the map has a VIP safety zone, one of `"yes"`, `"no"`, or `"notChecked"` until the game has looked.
 	 *
 	 * Pawn: `CSGameRules::m_bMapHasVIPSafetyZone`
 	 */
-	get mapHasVipSafetyZone(): VipSafetyZone { return vipSafetyZoneName(gameCell(234, m_bMapHasVIPSafetyZone)); }
+	get mapHasVipSafetyZone(): VipSafetyZone { return vipSafetyZoneName(gameCell(238)); }
 	set mapHasVipSafetyZone(value: VipSafetyZone) {
 		const cell = vipSafetyZoneCell(value);
-		if (cell != UNNAMED) setGameCell(234, m_bMapHasVIPSafetyZone, cell);
+		if (cell != UNNAMED) setGameCell(238, cell);
 	}
 
 	/**
@@ -5194,16 +5264,16 @@ export class GameFields {
 	 *
 	 * Pawn: `CSGameRules::m_bMapHasCameras`
 	 */
-	get mapHasCameras(): boolean { return gameCell(235, m_bMapHasCameras) != 0; }
-	set mapHasCameras(value: boolean) { setGameCell(235, m_bMapHasCameras, value ? 1 : 0); }
+	get mapHasCameras(): boolean { return gameCell(239) != 0; }
+	set mapHasCameras(value: boolean) { setGameCell(239, value ? 1 : 0); }
 
 	/**
 	 * The bomb's timer in seconds, from `mp_c4timer`.
 	 *
 	 * Pawn: `CSGameRules::m_iC4Timer`
 	 */
-	get bombTimer(): number { return gameCell(236, m_iC4Timer); }
-	set bombTimer(value: number) { setGameCell(236, m_iC4Timer, <i32>value); }
+	get bombTimer(): number { return gameCell(240); }
+	set bombTimer(value: number) { setGameCell(240, <i32>value); }
 
 	/**
 	 * The terrorist who got the bomb this round, or `null`. Read only.
@@ -5211,8 +5281,8 @@ export class GameFields {
 	 * Pawn: `CSGameRules::m_iC4Guy`
 	 */
 	get bomber(): Player | null {
-		const index = gameCell(237, m_iC4Guy);
-		return index > 0 ? new Player(index) : null;
+		const index = gameCell(241);
+		return index > 0 ? __playerOf(index) : null;
 	}
 
 	/**
@@ -5220,336 +5290,336 @@ export class GameFields {
 	 *
 	 * Pawn: `CSGameRules::m_iLoserBonus`
 	 */
-	get loserBonus(): number { return gameCell(238, m_iLoserBonus); }
-	set loserBonus(value: number) { setGameCell(238, m_iLoserBonus, <i32>value); }
+	get loserBonus(): number { return gameCell(242); }
+	set loserBonus(value: number) { setGameCell(242, <i32>value); }
 
 	/**
 	 * The number of rounds the counter-terrorists have lost in a row.
 	 *
 	 * Pawn: `CSGameRules::m_iNumConsecutiveCTLoses`
 	 */
-	get ctLossStreak(): number { return gameCell(239, m_iNumConsecutiveCTLoses); }
-	set ctLossStreak(value: number) { setGameCell(239, m_iNumConsecutiveCTLoses, <i32>value); }
+	get ctLossStreak(): number { return gameCell(243); }
+	set ctLossStreak(value: number) { setGameCell(243, <i32>value); }
 
 	/**
 	 * The number of rounds the terrorists have lost in a row.
 	 *
 	 * Pawn: `CSGameRules::m_iNumConsecutiveTerroristLoses`
 	 */
-	get terroristLossStreak(): number { return gameCell(240, m_iNumConsecutiveTerroristLoses); }
-	set terroristLossStreak(value: number) { setGameCell(240, m_iNumConsecutiveTerroristLoses, <i32>value); }
+	get terroristLossStreak(): number { return gameCell(244); }
+	set terroristLossStreak(value: number) { setGameCell(244, <i32>value); }
 
 	/**
 	 * The seconds a player may stand idle before he is kicked, with `mp_autokick` on.
 	 *
 	 * Pawn: `CSGameRules::m_fMaxIdlePeriod`
 	 */
-	get maxIdlePeriod(): number { return cellFloat(gameCell(241, m_fMaxIdlePeriod)); }
-	set maxIdlePeriod(value: number) { setGameCell(241, m_fMaxIdlePeriod, <i32>floatCell(value)); }
+	get maxIdlePeriod(): number { return cellFloat(gameCell(245)); }
+	set maxIdlePeriod(value: number) { setGameCell(245, <i32>floatCell(value)); }
 
 	/**
 	 * The most one side may outnumber the other by, from `mp_limitteams`.
 	 *
 	 * Pawn: `CSGameRules::m_iLimitTeams`
 	 */
-	get limitTeams(): number { return gameCell(242, m_iLimitTeams); }
-	set limitTeams(value: number) { setGameCell(242, m_iLimitTeams, <i32>value); }
+	get limitTeams(): number { return gameCell(246); }
+	set limitTeams(value: number) { setGameCell(246, <i32>value); }
 
 	/**
 	 * `true` once the game has looked the map over for its bomb sites, buy zones and hostages.
 	 *
 	 * Pawn: `CSGameRules::m_bLevelInitialized`
 	 */
-	get mapInitialized(): boolean { return gameCell(243, m_bLevelInitialized) != 0; }
-	set mapInitialized(value: boolean) { setGameCell(243, m_bLevelInitialized, value ? 1 : 0); }
+	get mapInitialized(): boolean { return gameCell(247) != 0; }
+	set mapInitialized(value: boolean) { setGameCell(247, value ? 1 : 0); }
 
 	/**
 	 * `true` from a round's end until the next round starts.
 	 *
 	 * Pawn: `CSGameRules::m_bRoundTerminating`
 	 */
-	get roundEnding(): boolean { return gameCell(244, m_bRoundTerminating) != 0; }
-	set roundEnding(value: boolean) { setGameCell(244, m_bRoundTerminating, value ? 1 : 0); }
+	get roundEnding(): boolean { return gameCell(248) != 0; }
+	set roundEnding(value: boolean) { setGameCell(248, value ? 1 : 0); }
 
 	/**
 	 * `true` when the next restart resets everything, the scores too, as `sv_restart` does.
 	 *
 	 * Pawn: `CSGameRules::m_bCompleteReset`
 	 */
-	get completeReset(): boolean { return gameCell(245, m_bCompleteReset) != 0; }
-	set completeReset(value: boolean) { setGameCell(245, m_bCompleteReset, value ? 1 : 0); }
+	get completeReset(): boolean { return gameCell(249) != 0; }
+	set completeReset(value: boolean) { setGameCell(249, value ? 1 : 0); }
 
 	/**
 	 * The share of terrorists, `0` to `1`, who must escape for them to win on an escape map.
 	 *
 	 * Pawn: `CSGameRules::m_flRequiredEscapeRatio`
 	 */
-	get requiredEscapeRatio(): number { return cellFloat(gameCell(246, m_flRequiredEscapeRatio)); }
-	set requiredEscapeRatio(value: number) { setGameCell(246, m_flRequiredEscapeRatio, <i32>floatCell(value)); }
+	get requiredEscapeRatio(): number { return cellFloat(gameCell(250)); }
+	set requiredEscapeRatio(value: number) { setGameCell(250, <i32>floatCell(value)); }
 
 	/**
 	 * The number of terrorists who can escape, on an escape map.
 	 *
 	 * Pawn: `CSGameRules::m_iNumEscapers`
 	 */
-	get numEscapers(): number { return gameCell(247, m_iNumEscapers); }
-	set numEscapers(value: number) { setGameCell(247, m_iNumEscapers, <i32>value); }
+	get numEscapers(): number { return gameCell(251); }
+	set numEscapers(value: number) { setGameCell(251, <i32>value); }
 
 	/**
 	 * The number of terrorists who have escaped this round.
 	 *
 	 * Pawn: `CSGameRules::m_iHaveEscaped`
 	 */
-	get haveEscaped(): number { return gameCell(248, m_iHaveEscaped); }
-	set haveEscaped(value: number) { setGameCell(248, m_iHaveEscaped, <i32>value); }
+	get haveEscaped(): number { return gameCell(252); }
+	set haveEscaped(value: number) { setGameCell(252, <i32>value); }
 
 	/**
 	 * `true` while the counter-terrorists may not buy.
 	 *
 	 * Pawn: `CSGameRules::m_bCTCantBuy`
 	 */
-	get ctsCantBuy(): boolean { return gameCell(249, m_bCTCantBuy) != 0; }
-	set ctsCantBuy(value: boolean) { setGameCell(249, m_bCTCantBuy, value ? 1 : 0); }
+	get ctsCantBuy(): boolean { return gameCell(253) != 0; }
+	set ctsCantBuy(value: boolean) { setGameCell(253, value ? 1 : 0); }
 
 	/**
 	 * `true` while the terrorists may not buy.
 	 *
 	 * Pawn: `CSGameRules::m_bTCantBuy`
 	 */
-	get terroristsCantBuy(): boolean { return gameCell(250, m_bTCantBuy) != 0; }
-	set terroristsCantBuy(value: boolean) { setGameCell(250, m_bTCantBuy, value ? 1 : 0); }
+	get terroristsCantBuy(): boolean { return gameCell(254) != 0; }
+	set terroristsCantBuy(value: boolean) { setGameCell(254, value ? 1 : 0); }
 
 	/**
 	 * The bomb's blast radius, in units, as the map sets it.
 	 *
 	 * Pawn: `CSGameRules::m_flBombRadius`
 	 */
-	get bombRadius(): number { return cellFloat(gameCell(251, m_flBombRadius)); }
-	set bombRadius(value: number) { setGameCell(251, m_flBombRadius, <i32>floatCell(value)); }
+	get bombRadius(): number { return cellFloat(gameCell(255)); }
+	set bombRadius(value: number) { setGameCell(255, <i32>floatCell(value)); }
 
 	/**
 	 * The number of rounds in a row the same player has been the VIP.
 	 *
 	 * Pawn: `CSGameRules::m_iConsecutiveVIP`
 	 */
-	get consecutiveVip(): number { return gameCell(252, m_iConsecutiveVIP); }
-	set consecutiveVip(value: number) { setGameCell(252, m_iConsecutiveVIP, <i32>value); }
+	get consecutiveVip(): number { return gameCell(256); }
+	set consecutiveVip(value: number) { setGameCell(256, <i32>value); }
 
 	/**
 	 * The number of guns the game has counted lying on the map.
 	 *
 	 * Pawn: `CSGameRules::m_iTotalGunCount`
 	 */
-	get totalGunCount(): number { return gameCell(253, m_iTotalGunCount); }
-	set totalGunCount(value: number) { setGameCell(253, m_iTotalGunCount, <i32>value); }
+	get totalGunCount(): number { return gameCell(257); }
+	set totalGunCount(value: number) { setGameCell(257, <i32>value); }
 
 	/**
 	 * The number of grenades the game has counted lying on the map.
 	 *
 	 * Pawn: `CSGameRules::m_iTotalGrenadeCount`
 	 */
-	get totalGrenadeCount(): number { return gameCell(254, m_iTotalGrenadeCount); }
-	set totalGrenadeCount(value: number) { setGameCell(254, m_iTotalGrenadeCount, <i32>value); }
+	get totalGrenadeCount(): number { return gameCell(258); }
+	set totalGrenadeCount(value: number) { setGameCell(258, <i32>value); }
 
 	/**
 	 * The number of armour pieces the game has counted lying on the map.
 	 *
 	 * Pawn: `CSGameRules::m_iTotalArmourCount`
 	 */
-	get totalArmourCount(): number { return gameCell(255, m_iTotalArmourCount); }
-	set totalArmourCount(value: number) { setGameCell(255, m_iTotalArmourCount, <i32>value); }
+	get totalArmourCount(): number { return gameCell(259); }
+	set totalArmourCount(value: number) { setGameCell(259, <i32>value); }
 
 	/**
 	 * The number of rounds in a row one side has outnumbered the other by more than two; the game balances the sides after enough of them.
 	 *
 	 * Pawn: `CSGameRules::m_iUnBalancedRounds`
 	 */
-	get unbalancedRounds(): number { return gameCell(256, m_iUnBalancedRounds); }
-	set unbalancedRounds(value: number) { setGameCell(256, m_iUnBalancedRounds, <i32>value); }
+	get unbalancedRounds(): number { return gameCell(260); }
+	set unbalancedRounds(value: number) { setGameCell(260, <i32>value); }
 
 	/**
 	 * The number of escape rounds played in a row; the sides swap after 8.
 	 *
 	 * Pawn: `CSGameRules::m_iNumEscapeRounds`
 	 */
-	get numEscapeRounds(): number { return gameCell(257, m_iNumEscapeRounds); }
-	set numEscapeRounds(value: number) { setGameCell(257, m_iNumEscapeRounds, <i32>value); }
+	get numEscapeRounds(): number { return gameCell(261); }
+	set numEscapeRounds(value: number) { setGameCell(261, <i32>value); }
 
 	/**
 	 * The number of the map the last map vote picked.
 	 *
 	 * Pawn: `CSGameRules::m_iLastPick`
 	 */
-	get lastPick(): number { return gameCell(258, m_iLastPick); }
-	set lastPick(value: number) { setGameCell(258, m_iLastPick, <i32>value); }
+	get lastPick(): number { return gameCell(262); }
+	set lastPick(value: number) { setGameCell(262, <i32>value); }
 
 	/**
 	 * The map's time limit, from `mp_timelimit`.
 	 *
 	 * Pawn: `CSGameRules::m_iMaxMapTime`
 	 */
-	get maxMapTime(): number { return gameCell(259, m_iMaxMapTime); }
-	set maxMapTime(value: number) { setGameCell(259, m_iMaxMapTime, <i32>value); }
+	get maxMapTime(): number { return gameCell(263); }
+	set maxMapTime(value: number) { setGameCell(263, <i32>value); }
 
 	/**
 	 * The number of rounds the map lasts, from `mp_maxrounds`; `0` for no limit.
 	 *
 	 * Pawn: `CSGameRules::m_iMaxRounds`
 	 */
-	get maxRounds(): number { return gameCell(260, m_iMaxRounds); }
-	set maxRounds(value: number) { setGameCell(260, m_iMaxRounds, <i32>value); }
+	get maxRounds(): number { return gameCell(264); }
+	set maxRounds(value: number) { setGameCell(264, <i32>value); }
 
 	/**
 	 * The number of rounds played on the map.
 	 *
 	 * Pawn: `CSGameRules::m_iTotalRoundsPlayed`
 	 */
-	get totalRoundsPlayed(): number { return gameCell(261, m_iTotalRoundsPlayed); }
-	set totalRoundsPlayed(value: number) { setGameCell(261, m_iTotalRoundsPlayed, <i32>value); }
+	get totalRoundsPlayed(): number { return gameCell(265); }
+	set totalRoundsPlayed(value: number) { setGameCell(265, <i32>value); }
 
 	/**
 	 * The number of rounds a side must win to end the map, from `mp_winlimit`; `0` for no limit.
 	 *
 	 * Pawn: `CSGameRules::m_iMaxRoundsWon`
 	 */
-	get maxRoundsWon(): number { return gameCell(262, m_iMaxRoundsWon); }
-	set maxRoundsWon(value: number) { setGameCell(262, m_iMaxRoundsWon, <i32>value); }
+	get maxRoundsWon(): number { return gameCell(266); }
+	set maxRoundsWon(value: number) { setGameCell(266, <i32>value); }
 
 	/**
 	 * The value of `allow_spectators` the game remembers to notice when it changes.
 	 *
 	 * Pawn: `CSGameRules::m_iStoredSpectValue`
 	 */
-	get storedSpectValue(): number { return gameCell(263, m_iStoredSpectValue); }
-	set storedSpectValue(value: number) { setGameCell(263, m_iStoredSpectValue, <i32>value); }
+	get storedSpectValue(): number { return gameCell(267); }
+	set storedSpectValue(value: number) { setGameCell(267, <i32>value); }
 
 	/**
 	 * The value of `mp_forcecamera` the game remembers to notice when it changes.
 	 *
 	 * Pawn: `CSGameRules::m_flForceCameraValue`
 	 */
-	get forceCamera(): number { return cellFloat(gameCell(264, m_flForceCameraValue)); }
-	set forceCamera(value: number) { setGameCell(264, m_flForceCameraValue, <i32>floatCell(value)); }
+	get forceCamera(): number { return cellFloat(gameCell(268)); }
+	set forceCamera(value: number) { setGameCell(268, <i32>floatCell(value)); }
 
 	/**
 	 * The value of `mp_forcechasecam` the game remembers to notice when it changes.
 	 *
 	 * Pawn: `CSGameRules::m_flForceChaseCamValue`
 	 */
-	get forceChaseCam(): number { return cellFloat(gameCell(265, m_flForceChaseCamValue)); }
-	set forceChaseCam(value: number) { setGameCell(265, m_flForceChaseCamValue, <i32>floatCell(value)); }
+	get forceChaseCam(): number { return cellFloat(gameCell(269)); }
+	set forceChaseCam(value: number) { setGameCell(269, <i32>floatCell(value)); }
 
 	/**
 	 * The value of `mp_fadetoblack` the game remembers to notice when it changes.
 	 *
 	 * Pawn: `CSGameRules::m_flFadeToBlackValue`
 	 */
-	get fadeToBlack(): number { return cellFloat(gameCell(266, m_flFadeToBlackValue)); }
-	set fadeToBlack(value: number) { setGameCell(266, m_flFadeToBlackValue, <i32>floatCell(value)); }
+	get fadeToBlack(): number { return cellFloat(gameCell(270)); }
+	set fadeToBlack(value: number) { setGameCell(270, <i32>floatCell(value)); }
 
 	/**
 	 * The VIP on an assassination map, a player `id`; `0` for none.
 	 *
 	 * Pawn: `CSGameRules::m_pVIP`
 	 */
-	get vip(): number { return gameCell(267, m_pVIP); }
-	set vip(value: number) { setGameCell(267, m_pVIP, <i32>value); }
+	get vip(): number { return gameCell(271); }
+	set vip(value: number) { setGameCell(271, <i32>value); }
 
 	/**
 	 * The game time the intermission at the map's end is over and the next map loads.
 	 *
 	 * Pawn: `CSGameRules::m_flIntermissionEndTime`
 	 */
-	get intermissionEndTime(): number { return cellFloat(gameCell(268, m_flIntermissionEndTime)); }
-	set intermissionEndTime(value: number) { setGameCell(268, m_flIntermissionEndTime, <i32>floatCell(value)); }
+	get intermissionEndTime(): number { return cellFloat(gameCell(272)); }
+	set intermissionEndTime(value: number) { setGameCell(272, <i32>floatCell(value)); }
 
 	/**
 	 * The game time the intermission at the map's end began.
 	 *
 	 * Pawn: `CSGameRules::m_flIntermissionStartTime`
 	 */
-	get intermissionStartTime(): number { return cellFloat(gameCell(269, m_flIntermissionStartTime)); }
-	set intermissionStartTime(value: number) { setGameCell(269, m_flIntermissionStartTime, <i32>floatCell(value)); }
+	get intermissionStartTime(): number { return cellFloat(gameCell(273)); }
+	set intermissionStartTime(value: number) { setGameCell(273, <i32>floatCell(value)); }
 
 	/**
 	 * `true` once a player has pressed a button to end the intermission early.
 	 *
 	 * Pawn: `CSGameRules::m_iEndIntermissionButtonHit`
 	 */
-	get intermissionSkipped(): boolean { return gameCell(270, m_iEndIntermissionButtonHit) != 0; }
-	set intermissionSkipped(value: boolean) { setGameCell(270, m_iEndIntermissionButtonHit, value ? 1 : 0); }
+	get intermissionSkipped(): boolean { return gameCell(274) != 0; }
+	set intermissionSkipped(value: boolean) { setGameCell(274, value ? 1 : 0); }
 
 	/**
 	 * The game time of the game's next periodic check of its limits and cvars.
 	 *
 	 * Pawn: `CSGameRules::m_tmNextPeriodicThink`
 	 */
-	get nextPeriodicThink(): number { return cellFloat(gameCell(271, m_tmNextPeriodicThink)); }
-	set nextPeriodicThink(value: number) { setGameCell(271, m_tmNextPeriodicThink, <i32>floatCell(value)); }
+	get nextPeriodicThink(): number { return cellFloat(gameCell(275)); }
+	set nextPeriodicThink(value: number) { setGameCell(275, <i32>floatCell(value)); }
 
 	/**
 	 * `true` once the game has begun: both sides have had players. Until then a round ends with “Game Commencing”.
 	 *
 	 * Pawn: `CSGameRules::m_bGameStarted`
 	 */
-	get gameStarted(): boolean { return gameCell(272, m_bGameStarted) != 0; }
-	set gameStarted(value: boolean) { setGameCell(272, m_bGameStarted, value ? 1 : 0); }
+	get gameStarted(): boolean { return gameCell(276) != 0; }
+	set gameStarted(value: boolean) { setGameCell(276, value ? 1 : 0); }
 
 	/**
 	 * `true` when the next round starts without respawning the players.
 	 *
 	 * Pawn: `CSGameRules::m_bSkipSpawn`
 	 */
-	get skipSpawn(): boolean { return gameCell(273, m_bSkipSpawn) != 0; }
-	set skipSpawn(value: boolean) { setGameCell(273, m_bSkipSpawn, value ? 1 : 0); }
+	get skipSpawn(): boolean { return gameCell(277) != 0; }
+	set skipSpawn(value: boolean) { setGameCell(277, value ? 1 : 0); }
 
 	/**
 	 * `true` while a joining player is not shown the team menu.
 	 *
 	 * Pawn: `CSGameRules::m_bSkipShowMenu`
 	 */
-	get skipShowMenu(): boolean { return reapiGameCell(m_bSkipShowMenu, "skipShowMenu") != 0; }
-	set skipShowMenu(value: boolean) { setReapiGameCell(m_bSkipShowMenu, "skipShowMenu", value ? 1 : 0); }
+	get skipShowMenu(): boolean { return regameCell(278, "skipShowMenu") != 0; }
+	set skipShowMenu(value: boolean) { setRegameCell(278, "skipShowMenu", value ? 1 : 0); }
 
 	/**
 	 * `true` while the game waits for players because a side is empty.
 	 *
 	 * Pawn: `CSGameRules::m_bNeededPlayers`
 	 */
-	get neededPlayers(): boolean { return reapiGameCell(m_bNeededPlayers, "neededPlayers") != 0; }
-	set neededPlayers(value: boolean) { setReapiGameCell(m_bNeededPlayers, "neededPlayers", value ? 1 : 0); }
+	get neededPlayers(): boolean { return regameCell(279, "neededPlayers") != 0; }
+	set neededPlayers(value: boolean) { setRegameCell(279, "neededPlayers", value ? 1 : 0); }
 
 	/**
 	 * The share of terrorists, `0` to `1`, who have escaped this round.
 	 *
 	 * Pawn: `CSGameRules::m_flEscapeRatio`
 	 */
-	get escapeRatio(): number { return cellFloat(reapiGameCell(m_flEscapeRatio, "escapeRatio")); }
-	set escapeRatio(value: number) { setReapiGameCell(m_flEscapeRatio, "escapeRatio", <i32>floatCell(value)); }
+	get escapeRatio(): number { return cellFloat(regameCell(280, "escapeRatio")); }
+	set escapeRatio(value: number) { setRegameCell(280, "escapeRatio", <i32>floatCell(value)); }
 
 	/**
 	 * The game time the map ends by `mp_timelimit`; `0` for no limit.
 	 *
 	 * Pawn: `CSGameRules::m_flTimeLimit`
 	 */
-	get timeLimit(): number { return cellFloat(reapiGameCell(m_flTimeLimit, "timeLimit", timeLimitHlds)); }
-	set timeLimit(value: number) { setReapiGameCell(m_flTimeLimit, "timeLimit", <i32>floatCell(value), setTimeLimitHlds); }
+	get timeLimit(): number { return cellFloat(regameCell(281, "timeLimit", timeLimitHlds)); }
+	set timeLimit(value: number) { setRegameCell(281, "timeLimit", <i32>floatCell(value), setTimeLimitHlds); }
 
 	/**
 	 * The game time the game began, after “Game Commencing”.
 	 *
 	 * Pawn: `CSGameRules::m_flGameStartTime`
 	 */
-	get gameStartTime(): number { return cellFloat(reapiGameCell(m_flGameStartTime, "gameStartTime", gameStartTimeHlds)); }
-	set gameStartTime(value: number) { setReapiGameCell(m_flGameStartTime, "gameStartTime", <i32>floatCell(value), setGameStartTimeHlds); }
+	get gameStartTime(): number { return cellFloat(regameCell(282, "gameStartTime", gameStartTimeHlds)); }
+	set gameStartTime(value: number) { setRegameCell(282, "gameStartTime", <i32>floatCell(value), setGameStartTimeHlds); }
 
 	/**
 	 * `true` when the sides were balanced at this round's start.
 	 *
 	 * Pawn: `CSGameRules::m_bTeamBalanced`
 	 */
-	get teamBalanced(): boolean { return reapiGameCell(m_bTeamBalanced, "teamBalanced") != 0; }
-	set teamBalanced(value: boolean) { setReapiGameCell(m_bTeamBalanced, "teamBalanced", value ? 1 : 0); }
+	get teamBalanced(): boolean { return regameCell(283, "teamBalanced") != 0; }
+	set teamBalanced(value: boolean) { setRegameCell(283, "teamBalanced", value ? 1 : 0); }
 }
 
 /** What a weapon is, by the name CS gives it without the WEAPON_ prefix. */
@@ -5640,7 +5710,7 @@ export class Weapon extends Entity {
 	 *
 	 * Pawn: `pev->classname`, `get_weaponname`
 	 */
-	get classname(): WeaponName { return entity_get_string(this.id, EV_SZ_classname) as WeaponName; }
+	get classname(): WeaponName { return keptText(this.id, 0, EV_SZ_classname) as WeaponName; }
 	set classname(value: WeaponName) { entity_set_string(this.id, EV_SZ_classname, value); }
 
 	/**
@@ -5649,8 +5719,8 @@ export class Weapon extends Entity {
 	 * Pawn: `CBasePlayerItem::m_pPlayer`
 	 */
 	get player(): Player | null {
-		const index = memberCell(this.id, 274);
-		return index > 0 ? new Player(index) : null;
+		const index = memberCell(this.id, 284);
+		return index > 0 ? __playerOf(index) : null;
 	}
 
 	/**
@@ -5668,232 +5738,232 @@ export class Weapon extends Entity {
 	 *
 	 * Pawn: `CBasePlayerWeapon::m_iPlayEmptySound` (reapi `m_Weapon_iPlayEmptySound`)
 	 */
-	get playEmptySound(): number { return memberCell(this.id, 275); }
-	set playEmptySound(value: number) { setMemberCell(this.id, 275, <i32>value); }
+	get playEmptySound(): number { return memberCell(this.id, 285); }
+	set playEmptySound(value: number) { setMemberCell(this.id, 285, <i32>value); }
 
 	/**
 	 * The weapon's “firing on empty” mark: `1` while the player holds attack with an empty clip.
 	 *
 	 * Pawn: `CBasePlayerWeapon::m_fFireOnEmpty` (reapi `m_Weapon_fFireOnEmpty`)
 	 */
-	get fireOnEmpty(): number { return memberCell(this.id, 276); }
-	set fireOnEmpty(value: number) { setMemberCell(this.id, 276, <i32>value); }
+	get fireOnEmpty(): number { return memberCell(this.id, 286); }
+	set fireOnEmpty(value: number) { setMemberCell(this.id, 286, <i32>value); }
 
 	/**
 	 * The time until the weapon can fire again, in seconds, counting down by itself: about `0.1` after an AK-47 shot, `1.45` after an AWP one.
 	 *
 	 * Pawn: `CBasePlayerWeapon::m_flNextPrimaryAttack` (reapi `m_Weapon_flNextPrimaryAttack`)
 	 */
-	get nextPrimaryAttack(): number { return cellFloat(memberCell(this.id, 277)); }
-	set nextPrimaryAttack(value: number) { setMemberCell(this.id, 277, <i32>floatCell(value)); }
+	get nextPrimaryAttack(): number { return cellFloat(memberCell(this.id, 287)); }
+	set nextPrimaryAttack(value: number) { setMemberCell(this.id, 287, <i32>floatCell(value)); }
 
 	/**
 	 * The time until the weapon's secondary attack (zoom, silencer, burst mode) works again, in seconds, counting down by itself.
 	 *
 	 * Pawn: `CBasePlayerWeapon::m_flNextSecondaryAttack` (reapi `m_Weapon_flNextSecondaryAttack`)
 	 */
-	get nextSecondaryAttack(): number { return cellFloat(memberCell(this.id, 278)); }
-	set nextSecondaryAttack(value: number) { setMemberCell(this.id, 278, <i32>floatCell(value)); }
+	get nextSecondaryAttack(): number { return cellFloat(memberCell(this.id, 288)); }
+	set nextSecondaryAttack(value: number) { setMemberCell(this.id, 288, <i32>floatCell(value)); }
 
 	/**
 	 * The time until the weapon plays its idle animation, in seconds, counting down by itself.
 	 *
 	 * Pawn: `CBasePlayerWeapon::m_flTimeWeaponIdle` (reapi `m_Weapon_flTimeWeaponIdle`)
 	 */
-	get nextIdle(): number { return cellFloat(memberCell(this.id, 279)); }
-	set nextIdle(value: number) { setMemberCell(this.id, 279, <i32>floatCell(value)); }
+	get nextIdle(): number { return cellFloat(memberCell(this.id, 289)); }
+	set nextIdle(value: number) { setMemberCell(this.id, 289, <i32>floatCell(value)); }
 
 	/**
 	 * The weapon's ammo kind — the slot of the player's ammo it takes from; `-1` for none (a knife).
 	 *
 	 * Pawn: `CBasePlayerWeapon::m_iPrimaryAmmoType` (reapi `m_Weapon_iPrimaryAmmoType`)
 	 */
-	get ammoType(): number { return memberCell(this.id, 280); }
-	set ammoType(value: number) { setMemberCell(this.id, 280, <i32>value); }
+	get ammoType(): number { return memberCell(this.id, 290); }
+	set ammoType(value: number) { setMemberCell(this.id, 290, <i32>value); }
 
 	/**
 	 * The weapon's secondary ammo slot; CS weapons have none (`-1`).
 	 *
 	 * Pawn: `CBasePlayerWeapon::m_iSecondaryAmmoType` (reapi `m_Weapon_iSecondaryAmmoType`)
 	 */
-	get secondaryAmmoType(): number { return memberCell(this.id, 281); }
-	set secondaryAmmoType(value: number) { setMemberCell(this.id, 281, <i32>value); }
+	get secondaryAmmoType(): number { return memberCell(this.id, 291); }
+	set secondaryAmmoType(value: number) { setMemberCell(this.id, 291, <i32>value); }
 
 	/**
 	 * The rounds in the weapon's magazine: `30` in a full AK-47; `-1` for the knife, which has none.
 	 *
 	 * Pawn: `CBasePlayerWeapon::m_iClip` (reapi `m_Weapon_iClip`)
 	 */
-	get clip(): number { return memberCell(this.id, 282); }
-	set clip(value: number) { setMemberCell(this.id, 282, <i32>value); }
+	get clip(): number { return memberCell(this.id, 292); }
+	set clip(value: number) { setMemberCell(this.id, 292, <i32>value); }
 
 	/**
 	 * The clip last sent to the player's HUD; when it differs from clip, the game sends the new one.
 	 *
 	 * Pawn: `CBasePlayerWeapon::m_iClientClip` (reapi `m_Weapon_iClientClip`)
 	 */
-	get clipSent(): number { return memberCell(this.id, 283); }
-	set clipSent(value: number) { setMemberCell(this.id, 283, <i32>value); }
+	get clipSent(): number { return memberCell(this.id, 293); }
+	set clipSent(value: number) { setMemberCell(this.id, 293, <i32>value); }
 
 	/**
 	 * The weapon's state (held or not) last sent to the player's HUD.
 	 *
 	 * Pawn: `CBasePlayerWeapon::m_iClientWeaponState` (reapi `m_Weapon_iClientWeaponState`)
 	 */
-	get clientWeaponState(): number { return memberCell(this.id, 284); }
-	set clientWeaponState(value: number) { setMemberCell(this.id, 284, <i32>value); }
+	get clientWeaponState(): number { return memberCell(this.id, 294); }
+	set clientWeaponState(value: number) { setMemberCell(this.id, 294, <i32>value); }
 
 	/**
 	 * The weapon's reload mark: `1` while it is reloading.
 	 *
 	 * Pawn: `CBasePlayerWeapon::m_fInReload` (reapi `m_Weapon_fInReload`)
 	 */
-	get isReloading(): number { return memberCell(this.id, 285); }
-	set isReloading(value: number) { setMemberCell(this.id, 285, <i32>value); }
+	get isReloading(): number { return memberCell(this.id, 295); }
+	set isReloading(value: number) { setMemberCell(this.id, 295, <i32>value); }
 
 	/**
 	 * The shotgun's shell-by-shell reload stage: `0` not reloading, `1` starting, `2` putting a shell in.
 	 *
 	 * Pawn: `CBasePlayerWeapon::m_fInSpecialReload` (reapi `m_Weapon_fInSpecialReload`)
 	 */
-	get shotgunReloadStage(): number { return memberCell(this.id, 286); }
-	set shotgunReloadStage(value: number) { setMemberCell(this.id, 286, <i32>value); }
+	get shotgunReloadStage(): number { return memberCell(this.id, 296); }
+	set shotgunReloadStage(value: number) { setMemberCell(this.id, 296, <i32>value); }
 
 	/**
 	 * The ammo the weapon gives when first picked up; `0` for one dropped by a player (only its clip).
 	 *
 	 * Pawn: `CBasePlayerWeapon::m_iDefaultAmmo` (reapi `m_Weapon_iDefaultAmmo`)
 	 */
-	get defaultAmmo(): number { return memberCell(this.id, 287); }
-	set defaultAmmo(value: number) { setMemberCell(this.id, 287, <i32>value); }
+	get defaultAmmo(): number { return memberCell(this.id, 297); }
+	set defaultAmmo(value: number) { setMemberCell(this.id, 297, <i32>value); }
 
 	/**
 	 * The shell casing model the weapon throws out (precached).
 	 *
 	 * Pawn: `CBasePlayerWeapon::m_iShellId` (reapi `m_Weapon_iShellId`)
 	 */
-	get shellId(): number { return memberCell(this.id, 288); }
-	set shellId(value: number) { setMemberCell(this.id, 288, <i32>value); }
+	get shellId(): number { return memberCell(this.id, 298); }
+	set shellId(value: number) { setMemberCell(this.id, 298, <i32>value); }
 
 	/**
 	 * `true` from a shot until the attack button is let go; this way tapping the button does not keep single-shot accuracy.
 	 *
 	 * Pawn: `CBasePlayerWeapon::m_bDelayFire` (reapi `m_Weapon_bDelayFire`)
 	 */
-	get delayFire(): boolean { return memberCell(this.id, 289) != 0; }
-	set delayFire(value: boolean) { setMemberCell(this.id, 289, value ? 1 : 0); }
+	get delayFire(): boolean { return memberCell(this.id, 299) != 0; }
+	set delayFire(value: boolean) { setMemberCell(this.id, 299, value ? 1 : 0); }
 
 	/**
 	 * The side the weapon's recoil pulls to next, left or right; it flips from time to time.
 	 *
 	 * Pawn: `CBasePlayerWeapon::m_iDirection` (reapi `m_Weapon_iDirection`)
 	 */
-	get direction(): number { return memberCell(this.id, 290); }
-	set direction(value: number) { setMemberCell(this.id, 290, <i32>value); }
+	get direction(): number { return memberCell(this.id, 300); }
+	set direction(value: number) { setMemberCell(this.id, 300, <i32>value); }
 
 	/**
 	 * The weapon's flag meant for a second silencer. CS does not use the field.
 	 *
 	 * Pawn: `CBasePlayerWeapon::m_bSecondarySilencerOn` (reapi `m_Weapon_bSecondarySilencerOn`)
 	 */
-	get secondarySilencerOn(): boolean { return memberCell(this.id, 291) != 0; }
-	set secondarySilencerOn(value: boolean) { setMemberCell(this.id, 291, value ? 1 : 0); }
+	get secondarySilencerOn(): boolean { return memberCell(this.id, 301) != 0; }
+	set secondarySilencerOn(value: boolean) { setMemberCell(this.id, 301, value ? 1 : 0); }
 
 	/**
 	 * The weapon's current inaccuracy: it grows as it fires and settles back; each weapon has its own range (`0.2` for a fresh AK-47).
 	 *
 	 * Pawn: `CBasePlayerWeapon::m_flAccuracy` (reapi `m_Weapon_flAccuracy`)
 	 */
-	get accuracy(): number { return cellFloat(memberCell(this.id, 292)); }
-	set accuracy(value: number) { setMemberCell(this.id, 292, <i32>floatCell(value)); }
+	get accuracy(): number { return cellFloat(memberCell(this.id, 302)); }
+	set accuracy(value: number) { setMemberCell(this.id, 302, <i32>floatCell(value)); }
 
 	/**
 	 * The shots in the weapon's current burst; the recoil grows with it, and it drops back once the player stops firing.
 	 *
 	 * Pawn: `CBasePlayerWeapon::m_iShotsFired` (reapi `m_Weapon_iShotsFired`)
 	 */
-	get shotsFired(): number { return memberCell(this.id, 293); }
-	set shotsFired(value: number) { setMemberCell(this.id, 293, <i32>value); }
+	get shotsFired(): number { return memberCell(this.id, 303); }
+	set shotsFired(value: number) { setMemberCell(this.id, 303, <i32>value); }
 
 	/**
 	 * The game time of the next round in the Glock's burst; `0` when not bursting.
 	 *
 	 * Pawn: `CBasePlayerWeapon::m_flGlock18Shoot` (reapi `m_Weapon_flGlock18Shoot`)
 	 */
-	get glockNextBurstShot(): number { return cellFloat(memberCell(this.id, 294)); }
-	set glockNextBurstShot(value: number) { setMemberCell(this.id, 294, <i32>floatCell(value)); }
+	get glockNextBurstShot(): number { return cellFloat(memberCell(this.id, 304)); }
+	set glockNextBurstShot(value: number) { setMemberCell(this.id, 304, <i32>floatCell(value)); }
 
 	/**
 	 * The rounds the Glock has fired in the current burst.
 	 *
 	 * Pawn: `CBasePlayerWeapon::m_iGlock18ShotsFired` (reapi `m_Weapon_iGlock18ShotsFired`)
 	 */
-	get glockBurstShots(): number { return memberCell(this.id, 295); }
-	set glockBurstShots(value: number) { setMemberCell(this.id, 295, <i32>value); }
+	get glockBurstShots(): number { return memberCell(this.id, 305); }
+	set glockBurstShots(value: number) { setMemberCell(this.id, 305, <i32>value); }
 
 	/**
 	 * The game time of the next round in the FAMAS's burst; `0` when not bursting.
 	 *
 	 * Pawn: `CBasePlayerWeapon::m_flFamasShoot` (reapi `m_Weapon_flFamasShoot`)
 	 */
-	get famasNextBurstShot(): number { return cellFloat(memberCell(this.id, 296)); }
-	set famasNextBurstShot(value: number) { setMemberCell(this.id, 296, <i32>floatCell(value)); }
+	get famasNextBurstShot(): number { return cellFloat(memberCell(this.id, 306)); }
+	set famasNextBurstShot(value: number) { setMemberCell(this.id, 306, <i32>floatCell(value)); }
 
 	/**
 	 * The rounds the FAMAS has fired in the current burst.
 	 *
 	 * Pawn: `CBasePlayerWeapon::m_iFamasShotsFired` (reapi `m_Weapon_iFamasShotsFired`)
 	 */
-	get famasBurstShots(): number { return memberCell(this.id, 297); }
-	set famasBurstShots(value: number) { setMemberCell(this.id, 297, <i32>value); }
+	get famasBurstShots(): number { return memberCell(this.id, 307); }
+	set famasBurstShots(value: number) { setMemberCell(this.id, 307, <i32>value); }
 
 	/**
 	 * The spread of the FAMAS's burst, kept for its later rounds.
 	 *
 	 * Pawn: `CBasePlayerWeapon::m_fBurstSpread` (reapi `m_Weapon_fBurstSpread`)
 	 */
-	get burstSpread(): number { return cellFloat(memberCell(this.id, 298)); }
-	set burstSpread(value: number) { setMemberCell(this.id, 298, <i32>floatCell(value)); }
+	get burstSpread(): number { return cellFloat(memberCell(this.id, 308)); }
+	set burstSpread(value: number) { setMemberCell(this.id, 308, <i32>floatCell(value)); }
 
 	/**
 	 * The weapon's modes, a list of any of: `"uspSilenced"` - the USP's silencer is on, `"glock18Burst"` - the Glock fires bursts, `"m4a1Silenced"` - the M4A1's silencer is on, `"eliteLeft"` - the Elites fire the left gun next, `"famasBurst"` - the FAMAS fires bursts, `"shieldDrawn"` - the shield is up.
 	 *
 	 * Pawn: `CBasePlayerWeapon::m_iWeaponState` (reapi `m_Weapon_iWeaponState`), `WPNSTATE_*`
 	 */
-	get weaponState(): WeaponState[] { return flagList<WeaponState>(new MemberFlags(this.id, 299), WEAPON_STATE); }
-	set weaponState(values: WeaponState[]) { setMemberCell(this.id, 299, WEAPON_STATE.maskOf(values)); }
+	get weaponState(): WeaponState[] { return flagList<WeaponState>(new MemberFlags(this.id, 309), WEAPON_STATE); }
+	set weaponState(values: WeaponState[]) { setMemberCell(this.id, 309, WEAPON_STATE.maskOf(values)); }
 
 	/**
 	 * The time until the shotgun's next shell goes in during its reload, in seconds, counting down.
 	 *
 	 * Pawn: `CBasePlayerWeapon::m_flNextReload` (reapi `m_Weapon_flNextReload`)
 	 */
-	get nextReload(): number { return cellFloat(memberCell(this.id, 300)); }
-	set nextReload(value: number) { setMemberCell(this.id, 300, <i32>floatCell(value)); }
+	get nextReload(): number { return cellFloat(memberCell(this.id, 310)); }
+	set nextReload(value: number) { setMemberCell(this.id, 310, <i32>floatCell(value)); }
 
 	/**
 	 * The game time when `shotsFired` next goes down by one after the player stops firing.
 	 *
 	 * Pawn: `CBasePlayerWeapon::m_flDecreaseShotsFired` (reapi `m_Weapon_flDecreaseShotsFired`)
 	 */
-	get recoilResetTime(): number { return cellFloat(memberCell(this.id, 301)); }
-	set recoilResetTime(value: number) { setMemberCell(this.id, 301, <i32>floatCell(value)); }
+	get recoilResetTime(): number { return cellFloat(memberCell(this.id, 311)); }
+	set recoilResetTime(value: number) { setMemberCell(this.id, 311, <i32>floatCell(value)); }
 
 	/**
 	 * The delay between the weapon's last two shots, in seconds; the game uses it to keep the fire rate even.
 	 *
 	 * Pawn: `CBasePlayerWeapon::m_flPrevPrimaryAttack` (reapi `m_Weapon_flPrevPrimaryAttack`)
 	 */
-	get prevPrimaryAttack(): number { return cellFloat(memberCell(this.id, 302)); }
-	set prevPrimaryAttack(value: number) { setMemberCell(this.id, 302, <i32>floatCell(value)); }
+	get prevPrimaryAttack(): number { return cellFloat(memberCell(this.id, 312)); }
+	set prevPrimaryAttack(value: number) { setMemberCell(this.id, 312, <i32>floatCell(value)); }
 
 	/**
 	 * The game time of the weapon's last shot; `0` before the first one.
 	 *
 	 * Pawn: `CBasePlayerWeapon::m_flLastFireTime` (reapi `m_Weapon_flLastFireTime`)
 	 */
-	get lastFireTime(): number { return cellFloat(memberCell(this.id, 303)); }
-	set lastFireTime(value: number) { setMemberCell(this.id, 303, <i32>floatCell(value)); }
+	get lastFireTime(): number { return cellFloat(memberCell(this.id, 313)); }
+	set lastFireTime(value: number) { setMemberCell(this.id, 313, <i32>floatCell(value)); }
 
 	/**
 	 * Gives the weapon to the player, as picking it up does; `true` when he took it.