Основы

События игры

То, что происходит в игре, — игрок получает урон, возрождается, умирает, покупает оружие, бросает гранату, раунд заканчивается, — это события на game. Обработчик слышит событие до того, как игра что-то сделает, и может пропустить его, изменить, остановить или ответить вместо игры:

// без урона по своим
game
.
addEventListener
("takeDamage", (
event
) => {
if (
event
.
attacker
.
team
==
event
.
player
.
team
)
event
.
preventDefault
();
}); // двойной урон с ножа
game
.
addEventListener
("takeDamage", onTakeDamage);
function onTakeDamage(
event
: TakeDamageEvent) {
const
weapon
=
event
.
attacker
.
activeItem
;
if (
weapon
&&
weapon
.
kind
== "knife")
event
.
damage
=
event
.
damage
* 2;
} // игра спрашивает, плагин отвечает: игроки слышат только свою команду
game
.
addEventListener
("canPlayerHearPlayer", (
event
) =>
event
.
listener
.
team
==
event
.
sender
.
team
);

События игры — это собственные функции игры, которые amxts перехватывает сам: хукчейны ReGameDLL и ReHLDS и функции сущности в её классе (функции Ham Sandwich). Ни ReAPI, ни модуль Ham Sandwich для них не нужны. game.addEventListener работает так же, как server.addEventListener (Плагин): имя задаёт тип event, редактор дополняет имена и подчёркивает опечатку, а game.removeEventListener с той же функцией снимает обработчик. Когда снят последний обработчик, событие перестаёт приходить в плагин, пока обработчик не добавят снова.

Что может обработчик

ЧтобыНапишите
игра шла дальшеничего не возвращайте
остановить действие игрыevent.preventDefault()
изменить то, что получит играприсвойте поле: event.damage = 10
ответить вместо игрыверните ответ: return true
остановить игру и все обработчики после этогоevent.stopImmediatePropagation()

Изменённое поле получат игра и обработчики после этого; если прочитать поле после записи, оно даст новое значение.

Возвращённое значение — ответ на вопрос игры: «слышит ли этот игрок того?», «сколько урона от падения?», «можно ли ему это купить?», — и свой код игра уже не выполняет. У ответа тип события (boolean, number, Player, Entity): вернуть другой — ошибка и в редакторе, и в сборке. Событие, чья функция в игре ничего не отвечает, ответа не принимает.

preventDefault() останавливает действие игры без ответа: урон не наносится, стартовое оружие не выдаётся. Там, где игра ждёт ответ, она получает 0 или false.

Обработчик отвечает всегда или никогда
Функция возвращает значение либо на всех путях, либо ни на одном. Обработчик, который должен отвечать лишь иногда, ничего не возвращает и вызывает event.preventDefault() там, где нужно остановить игру, — или отвечает всегда, повторяя правило самой игры для остальных случаев.
Плагины на Pawn на том же событии
С ReAPI обработчик того же хукчейна в плагине на Pawn до игры срабатывает раньше обработчиков amxts, а после игры — позже: то, что плагин на Pawn заблокировал до игры, ни до одного обработчика amxts не доходит, а обработчики на Pawn после игры слышат и то, что заблокировал обработчик amxts. Хук Ham Sandwich плагина на Pawn и хук amxts на функции сущности вызываются один внутри другого: тот, что поставлен позже, до игры срабатывает первым, а после игры — последним.

После того, как игра сработала

game
.
addEventListener
("fallDamage", (
event
) =>
event
.
result
/ 2, true); // вдвое меньше урона от падения
game
.
addEventListener
("playerSpawn", (
event
) => {
event
.
player
.
give
("weapon_deagle");
}, true);

С true третьим аргументом — или { post: true }, это то же самое — обработчик выполняется после функции игры. event.result — то, что игра ответила, а возвращённое значение его заменяет. Менять поля здесь бесполезно: игра их уже использовала. Чтобы снять такой обработчик, передайте true и в removeEventListener.

Касания

game
.
addEventListener
("touch", onTouch, {
toucher
: "player",
touched
: "player" });
function onTouch(
event
: TouchEvent) {
const
player
= new
Player
(
event
.
toucher
.
id
);
const
below
= new
Player
(
event
.
touched
.
id
);
if (
player
.
groundEntity
==
below
.
id
)
console
.
log
(`${
player
.
name
} стоит на ${
below
.
name
}`);
}

"touch" — касание двух сущностей: event.toucher вошла в event.touched, обе — Entity. Касание случается каждый кадр у каждого игрока, который на чём-то стоит, поэтому третий аргумент называет классы, о которых обработчик, — toucher, touched или оба, — и до плагина доходят только эти касания: сервер отсеивает их раньше. Класс, который не задан, — любой класс. event.preventDefault() блокирует касание. Два игрока, коснувшиеся друг друга, — это два касания, по одному в каждую сторону.

Плагины на Pawn на том же касании
register_touch и pfn_touch плагина на Pawn слышат касание после обработчиков amxts, в том числе заблокированное ими.

Что видит каждый игрок с v0.3

game
.
addEventListener
("entityState", (
event
) => {
if (
event
.
player
.
team
!= "CT") {
event
.
preventDefault
(); // метка, которую видят только CT
return; }
event
.
renderFx
= "glowShell"; // и для них она светится
event
.
renderColor
= [0, 160, 255];
event
.
renderAmount
= 10;
}, {
classname
: "myplugin_marker" });

"entityState" — то, что сервер отправляет одному игроку об одной видимой ему сущности, каждый кадр: event.player — кто получает, event.entity — о чём. Его поля — origin, angles, renderMode, renderAmount, renderColor, renderFx, effects, modelIndex, body, skin и анимация модели: sequence с v0.3.3, gaitSequence с v0.3.3, frame с v0.3.3, frameRate с v0.3.3, animTime с v0.3.3, ducking с v0.3.3, solid с v0.3.3 — то, что видит этот игрок, и запись поля меняет его только для него; сама сущность остаётся как есть. event.preventDefault() скрывает сущность от него.

Это происходит для каждой сущности, которую видит каждый игрок, каждый кадр, поэтому третий аргумент называет класс, о котором слушатель, — { classname: "player" }, — и до плагина доходят только они. Сервер без слушателей entityState ничего за это не платит.

Анимацию клиент проигрывает дальше сам: от frame в момент animTime, со скоростью frameRate. frameRate, равный 0, держит модель в позе, которую называет frame, поэтому сохранённая и отправленная снова поза замораживает модель для одного игрока, пока остальные видят её в движении:

interface Pose { 
sequence
: number;
gaitSequence
: number;
frame
: number; }
let
watcher
= 0; // игрок, который заморозил остальных, по id
const
poses
= new
Map
<number, Pose>(); // поза, в которой замер каждый, по id
game
.
addEventListener
("entityState", (
event
) => {
if (
event
.
player
.
id
!=
watcher
) return;
const
id
=
event
.
entity
.
id
;
let
pose
=
poses
.
get
(
id
);
if (
pose
== null) {
pose
= {
sequence
:
event
.
sequence
,
gaitSequence
:
event
.
gaitSequence
,
frame
:
event
.
frame
};
poses
.
set
(
id
,
pose
);
}
event
.
sequence
=
pose
.
sequence
; // поза, в которой он их заморозил
event
.
gaitSequence
=
pose
.
gaitSequence
;
event
.
frame
=
pose
.
frame
;
event
.
frameRate
= 0; // стоит на месте, не играется дальше
}, {
classname
: "player" });
Один кадр за раз
То, что записал слушатель, держится один кадр для одного игрока: в следующем кадре сущность отправляется как есть, и слушатель срабатывает снова. Слушатель, который скрывает сущность, скрывает её в каждом кадре, где срабатывает.

Что игрок получает о себе с v0.3.3

game
.
addEventListener
("clientData", (
event
) => {
if (
event
.
player
.
flags
.
includes
("onGround")) return;
event
.
maxSpeed
= 200; // клиент предсказывает его медленнее в воздухе
});

"clientData" — то, что сервер отправляет клиенту игрока о самом игроке, каждый кадр: event.player — кто получает. Его поля — nextAttack, fov, weaponAnim, maxSpeed, origin, velocity, punchAngle, viewOffset, flags — то, с чем клиент предсказывает движение игрока и его оружие и от чего рисует его взгляд, и запись поля меняет его только для его клиента; сам игрок остаётся как есть. nextAttack — секунды до его следующей атаки, как их отсчитывает клиент: клиент запускает его оружие — выстрелы и анимации — только при 0 и меньше.

Взгляд игрока клиент рисует тоже по этим полям: глаза — в origin плюс viewOffset, повёрнуты на punchAngle — отброс от выстрела или попадания — и покачиваются по величине velocity вдоль земли. flags — те же имена, что у player.flags; "ducking" среди них — игрок присел.

Это происходит для каждого игрока каждый кадр. Сервер без слушателей clientData ничего за это не платит.

Зритель, который смотрит глазами игрока, получает данные этого игрока: его взгляд качается и дёргается вместе со взглядом игрока. Слушатель может удержать его неподвижным:

let 
paused
= false; // повтор, который показывает myplugin, на паузе
game
.
addEventListener
("clientData", (
event
) => {
if (!
paused
||
event
.
player
.
observerMode
!= "inEye") return;
event
.
velocity
= [0, 0, 0]; // без покачивания от движения игрока
event
.
punchAngle
= [0, 0, 0]; // и без отброса от его выстрелов
});

Вид оружия в руках

Одна модель от первого лица может хранить несколько видов оружия в группах тел (body) — нож с несколькими раскрасками. weapon.viewBody выбирает тот, что видно в руках:

game
.
addEventListener
("defaultDeploy", (
event
) => {
if (
event
.
weapon
.
classname
!= "weapon_knife") return;
event
.
viewModel
= "models/myplugin/v_knife.mdl";
event
.
weapon
.
viewBody
= 2; // третья раскраска модели
});

Пока оружие у него в руках, каждая его анимация — доставание, покой, удар — приходит с сервера с этим телом, и клиент их не предсказывает: клиент сам предсказывает анимации своего оружия и рисует их без тела. Задавайте viewBody при каждом доставании, как делает слушатель defaultDeploy выше; 0 — такое же тело модели, как и прочие, и удерживает оружие так же. Когда оружие покидает его руки — убрано, выброшено, отобрано — модуль отпускает тело.

Модуль держит в такт и сам клиент: клиент заново проигрывает анимацию, которую ему называют текущей, со своим телом, если она не последняя сыгранная им самим, — поэтому модуль называет ему анимацию доставания и сразу после собственной анимации клиента ещё раз шлёт доставание с телом. Слушатель clientData выполняется после этого и может поменять weaponAnim.

Зритель, который смотрит его глазами, видит оружие с тем же телом: модуль шлёт зрителю каждую его анимацию и так же держит в такт клиент зрителя.

Анимации с сервера
С viewBody анимации оружия в руках приходят с сервера, с опозданием на его пинг. Оружие, выстрелы которого клиент рисует сам, теряет их для владельца: звук и вспышка его собственных выстрелов — дело его клиента, а тот больше не запускает оружие. viewBody — для оружия вроде ножа.

Откуда видит игрок с v0.3.3

const 
replays
= new
Map
<number, number[]>(); // где повтор myplugin, который смотрит каждый игрок, по id
game
.
addEventListener
("visibility", (
event
) => {
const
point
=
replays
.
get
(
event
.
player
.
id
);
if (
point
!= null)
event
.
addOrigin
(
point
); // ему отправят и то, что видно оттуда
});

"visibility" — откуда сервер смотрит за игрока каждый кадр: он отправляет ему сущности, которые видны из event.origin, и для них вызываются обработчики entityState. event.origin — его глаза, глаза игрока, за которым он наблюдает зрителем, или его view.

Плагин, который показывает игроку место далеко от его собственных глаз, — повтор, камеру, которую рисует его клиент, — добавляет это место через event.addOrigin(point): ему отправляется то, что видно из любой из точек, и стены, двери и платформы вокруг этого места до него доходят. Его собственные глаза остаются: зрителю отправляется игрок, за которым он наблюдает, только пока этого игрока видно, — без них модель наблюдаемого игрока пропадает от третьего лица, а от первого ломается его вид.

Запись event.origin, наоборот, переносит первую точку — ему больше не отправляется то, что видно только из его глаз. И то и другое действует только на этот кадр; его вид и сам игрок остаются как были. За кадр одному игроку можно добавить до 15 точек; дальше addOrigin точку не добавляет.

Это происходит для каждого игрока каждый кадр. Сервер без обработчиков visibility за это не платит, а каждая добавленная точка стоит серверу примерно столько же, сколько расчёт собственной точки игрока.

Один класс сущностей

game
.
addEventListener
("primaryAttack", onSlash, {
classname
: "weapon_knife" });
function onSlash(
event
: PrimaryAttackEvent) {
const
knife
=
event
.
weapon
;
knife
.
secondaryAttack
(); // вместо этого правый клик; на нём срабатывают обработчики всех плагинов
event
.
preventDefault
(); // а левый — нет
}
game
.
addEventListener
("takeDamage", (
event
) => {
console
.
log
(`${
event
.
entity
.
classname
} took ${
event
.
damage
}`);
}, {
classname
: "func_breakable" });

Атака оружия, использование двери, «мысль» сущности — события одного класса сущностей: его называет classname в третьем аргументе, и до плагина доходят только его сущности — сервер отсеивает остальные раньше. { classname, post: true } слушает после того, как игра сработала.

Событие об игроке — takeDamage, killed, spawn — без classname относится к игроку, а с ним — к другому классу: event.player — игрок, event.entity — сущность названного класса. Событие об оружии — canDeploy, itemPostFrame — без classname относится ко всему оружию, с ним — к одному классу. Событию только об одном классе сущностей — primaryAttack, deploy, think, use — нужен classname. Поле такого события можно присвоить там, где игра его принимает обратно, — сущность и вектор тоже.

События функции сущности
Функция сущности перехватывается по одному классу сущностей: обработчик события только об одном классе без classname не добавляется, и консоль об этом говорит. stopImmediatePropagation() там блокирует функцию игры и обработчики amxts после этого; хук Ham Sandwich плагина на Pawn на этой функции всё равно срабатывает.
Сервер без ReGameDLL
На сервере без ReGameDLL — обычном HLDS — событие игрока тоже перехватывается в классе игрока, а событие оружия без classname — в классе каждого оружия: обработчик пишется так же и слышит то же, и к нему относится то, что сказано выше. События, которые есть только у ReGameDLL и ReHLDS, приходят там от других хуков, некоторые — не целиком (сервер без ReGameDLL).

Те же функции — методы сущности: игра выполняет их так же, как сама, и обработчики всех плагинов об этом слышат:

knife.deploy();                          // снова в руках: модель и анимация
knife.deploy({ 
hooks
: false }); // только функция игры, без обработчиков
player
.
jump
();
door.use(
player
,
player
, "toggle", 0);
trap.touch(
player
); // телепорт или урон ловушки — на нём
МетодУ кого
spawn, activate, think, use, blocked, heal, killed, restart, touch с v0.3.1у любой сущности
addFrags, addTeamScore, addItem, removeItem, giveAmmo, jump, duckу игрока
deploy, holster, drop, primaryAttack, secondaryAttack, reload, weaponIdle, retireWeapon, addToPlayer, attachToPlayer, extractAmmo, extractClipAmmo, resetEmptySound, sendWeaponAnimу оружия

entity.touch(toucher) выполняет касание сущности на toucher, как игра выполняет его, когда toucher входит в неё: его слышат событие touch и обработчики Ham Sandwich, а register_touch плагина на Pawn — нет.

Движение игрока с v0.3

game
.
addEventListener
("airMove", (
event
) => {
if (
event
.
touchCount
> 0)
console
.
log
(`${
event
.
player
.
name
} во что-то врезался в воздухе`);
});

У событий движения игрока — move, airMove, jumpMovement, duckMovement, ladderMove и остальных — есть ещё два поля: event.touchCount, сколько всего игрок задел за это движение (пол, стену, другого игрока), и event.frameTime, длина кадра движения в секундах.

move, всё движение игрока целиком, слышно и на обычном HLDS с v0.3.1, с его полями и preventDefault(); остальным событиям движения нужен ReGameDLL.

Что есть у события

  • Поля — данные события с типами: event.damage — number, event.damageType — Damage[] (флаги), текст — string. Поле называется словами: event.trace, event.info, event.direction, event.start; подсказка называет параметр так, как его называет ReAPI.
  • Сущности — объекты: игрок — Player, оружие — Weapon, всё остальное — Entity. event.attacker.team, event.player.health.
  • event.player — игрок, о котором событие: тот, кто получает урон, возрождается, прыгает, ослеплён.
  • event.result в обработчике, который выполняется после игры, — ответ игры.

Наведите на имя события — подсказка скажет, что это за событие, на поле — что в нём лежит. Последняя строка подсказки называет его так, как его зовут ReAPI и Ham Sandwich (Pawn: `RG_CBasePlayer_TakeDamage`, `Ham_TakeDamage` ).

Событие читается, пока работает обработчик
Поле читается из вызова игры в тот момент, когда его читают, а следующий вызов того же события отдаёт тот же объект. Сохраняйте нужное, а не само событие: const victim = event.player до await или setTimeout.

С чего начать

СобытиеКогдаОтвет
takeDamageигрок вот-вот получит урон: player, attacker, inflictor, damage, damageType; чтобы изменить урон, присвойте event.damagenumber
traceAttackвыстрел попал в игрока, до урона-
playerKilled¹игрока убили: victim, killer, inflictor-
playerSpawn¹игрок возродился-
giveDefaultItems¹игра выдаёт возродившемуся игроку стартовое оружие-
newRound¹начинается новый раунд-
roundStart¹закончилось время заморозки в начале раунда-
roundEnd¹раунд заканчивается: winner, reason, delayboolean
buyWeapon¹игрок покупает оружие: weaponEntity: купленное оружие
itemRestricted¹игра спрашивает, запрещён ли игроку предметboolean: true запрещает
canPlayerHearPlayer¹игра спрашивает, слышит ли listener игрока sender в голосовом чатеboolean
fallDamage¹игра считает урон от паденияnumber
addMoney¹меняются деньги игрока: amount, reason-
chooseTeam¹игрок выбирает команду в меню: choicenumber
throwHeGrenade¹игрок бросает осколочную гранатуEntity
playerBlind¹флешка ослепляет игрока: fadeTime, fadeHold, alpha-

¹ На сервере без ReGameDLL слышно не всё: сервер без ReGameDLL.

Все события, их около 250, показывает редактор.

Событие называется по тому, что делает игра, в camelCase, какой бы модуль его ни слышал: RG_CBasePlayer_TakeDamage и Ham_TakeDamage — оба "takeDamage", RG_CSGameRules_PlayerSpawn — "playerSpawn" (появление игрока в раунде), а RG_CBasePlayer_Spawn — "spawn", Ham_Weapon_PrimaryAttack — "primaryAttack". Тип события — имя в PascalCase с Event: TakeDamageEvent, PrimaryAttackEvent.

canPlayerHearPlayer игра спрашивает, только пока sv_alltalk равен 0: с включённым alltalk она не спрашивает никого. Чтобы заглушить игрока при любом alltalk, есть player.muted (Игроки).

Перечисления и флаги — имена

Поле, в котором лежит одно значение из фиксированного набора, — это имя, а поле с битовыми флагами — массив имён:

game
.
addEventListener
("roundEnd", (
event
) => {
if (
event
.
reason
== "targetSaved")
console
.
log
("точку отстояли");
if (
event
.
winner
== "CT")
console
.
log
("победил спецназ");
});
game
.
addEventListener
("showVguiMenu", (
event
) => {
if (
event
.
menu
== "team")
event
.
preventDefault
();
});
game
.
addEventListener
("sendDeathMessage", (
event
) => {
if (
event
.
rarity
.
includes
("headshot"))
console
.
log
("в голову");
});
СобытиеПолеИмена
roundEndwinnerRoundWinner: "TERRORIST", "CT", "draw", "none"
roundEndreasonRoundEndReason: "ctsWin", "terroristsWin", "targetSaved", "targetBomb", "bombDefused", "endDraw", "gameRestart", "none", …
roundEnddelayсекунды до следующего раунда
canSwitchTeamteamTeam
chooseTeamchoiceTeamChoice: "TERRORIST", "CT", "VIP", "auto", "SPECTATOR"
buyWeaponweaponWeaponKind, в тех же именах, что weapon.kind: "ak47", "awp", …
addMoneyreasonRewardReason: "roundBonus", "enemyKilled", …
itemRestrictedrestrictionItemRestriction: "buying", "touched", "equipped"
itemRestricteditemItemKind: оружие по виду ("awp", "hegrenade", …) или "kevlar", "assault", "defusekit", "nvg", …
painlastHitGroupHitGroup: "head", "chest", "stomach", "leftArm", … — как их называет player.lastHitGroup
setAnimationanimationPlayerAnimation: "idle", "walk", "jump", "attack1", "reload", …
addResourceresourceTypeResourceType: "sound", "model", "decal", "generic", "eventscript", …
gameEventgameEventBotEvent: "playerDied", "bombPlanted", …
showVguiMenumenuVguiMenu: "team", "classT", "classCT", "buy", …
sendDeathMessageflagsDeathMessageFlag[]: "position", "assistant", "killRarity"
sendDeathMessagerarityKillRarity[]: "headshot", "noScope", "penetrated", "inAir", …

Присвоенное имя меняет значение, которое получит игра: event.reason = "terroristsWin". Значение, для которого нет имени, — его передал другой плагин или мод, — читается как "unknown" ("none" у RoundWinner и WeaponKind, "UNASSIGNED" у Team), а присваивание "unknown" оставляет поле таким, каким его передала игра. Флаги без имени при присваивании массива флагов сохраняются.

Сервер без ReGameDLL с v0.2

У ReGameDLL и ReHLDS есть собственные события — появление игрока в раунде, начало и конец раунда, деньги, покупки, — amxts слышит их через их хукчейны. На сервере без них — HLDS от Valve с AMX Mod X — большую часть из них слышно так, как их слышит там плагин на Pawn: новый раунд — по сообщению HLTV, конец заморозки и конец раунда — по логу игры, появление и смерть — через функции игрока, деньги — по сообщению Money, покупку — через cstrike. Плагин пишется так же; способ amxts выбирает один раз, когда сервер стартует.

Функции правил игры — fallDamage, canHaveItem, canRespawn и остальные их вопросы, а также playerSpawn, playerKilled, newRound, deathNotice и остальные, которые так называет таблица ниже, — слышны там с v0.3.2 так же, как с ReGameDLL: их обработчики вызываются до того, как игра действует, а их ответы, поля и preventDefault() работают. Так же слышны addMoney и giveDefaultItems с v0.3.2. Для них amxts перехватывает собственную функцию игры: на Linux всегда, на Windows — в сборках игры Valve, которые он знает, — той, что ставит steam, и её ветке steam_legacy.

Чего такое событие там дать не может, сказано в таблице ниже и в подсказке редактора к событию. Обработчик, который всё равно этого просит, — preventDefault(), ответ, запись поля, — это одна строка в консоли сервера, один раз на событие; поле, которое событию нечем заполнить, читается как 0, "", null или мир.

СобытиеНа сервере без ReGameDLL
addMoneyreason читается как "none"; слышно, как с ReGameDLL, там, где gamedata AMX Mod X находит функцию игры; в остальных случаях слышно, когда игра уже сделала своё, поэтому preventDefault() и запись поля ничего не делают; amount — на сколько сдвинулись его деньги с тех пор, как игра в последний раз их ему прислала
becomeBomberСлышно, когда игра уже сделала своё, поэтому preventDefault() и запись поля ничего не делают; ответ ничего не делает
becomeVipСлышно, когда игра уже сделала своё, поэтому preventDefault() и запись поля ничего не делают
buyAmmoСлышно, когда игра проверяет покупку, для предмета, который называет команда покупки или меню покупки: preventDefault() отменяет её; weapon читается как мир, blinkMoney — как true; ответ ничего не делает
buyItemСлышно, когда игра проверяет покупку, для предмета, который называет команда покупки или меню покупки: preventDefault() отменяет её; слышно для предметов меню снаряжения; ответ ничего не делает
buyWeaponСлышно, когда игра проверяет покупку, для предмета, который называет команда покупки или меню покупки: preventDefault() отменяет её; event.result читается как null; ответ ничего не делает
canHaveItemСлышно, как с ReGameDLL, на Linux, а на Windows — со сборкой игры Valve, которую amxts знает; в остальных случаях его ничто не слышит
canPlayerHearPlayerСпрашивается, когда игра сообщает движку, кто кого слышит, — и при включённом sv_alltalk, и для игрока, заглушившего другого: ответ перекрывает и то и другое
canRespawnСлышно, как с ReGameDLL, на Linux, а на Windows — со сборкой игры Valve, которую amxts знает; в остальных случаях его ничто не слышит
canTakeDamageСлышно, как с ReGameDLL, на Linux, а на Windows — со сборкой игры Valve, которую amxts знает; в остальных случаях его ничто не слышит
changeLevelСлышно, как с ReGameDLL, на Linux, а на Windows — со сборкой игры Valve, которую amxts знает; в остальных случаях preventDefault() ничего не делает
changeNameСлышно, когда игра уже сделала своё, поэтому preventDefault() и запись поля ничего не делают; info читается как ""; ответ ничего не делает
checkWinConditionsСлышно, как с ReGameDLL, на Linux, а на Windows — со сборкой игры Valve, которую amxts знает; в остальных случаях его ничто не слышит
chooseAppearanceСлышно по команде игрока: preventDefault() её отменяет; модель, которую игра выбирает сама, не слышна
chooseTeamСлышно по команде игрока: preventDefault() её отменяет; ответ ничего не делает, а команда, которую игра выбирает сама, не слышна
clientConnectedСлышно, когда игра уже сделала своё, поэтому preventDefault() и запись поля ничего не делают
connectClientСлышно, когда игра уже сделала своё, поэтому preventDefault() и запись поля ничего не делают; слышно, когда игрока уже пустили
deathNoticeСлышно, как с ReGameDLL, на Linux, а на Windows — со сборкой игры Valve, которую amxts знает; в остальных случаях слышно, когда уходит сообщение о смерти: preventDefault() ничего не делает, а inflictor читается как мир
defuseBombEndСлышно, когда игра уже сделала своё, поэтому preventDefault() и запись поля ничего не делают; слышно, только когда бомба обезврежена, а не когда разминирование прервано
defuseBombStartСлышно, когда игра уже сделала своё, поэтому preventDefault() и запись поля ничего не делают
disconnectClientСлышно, когда игра уже сделала своё, поэтому preventDefault() и запись поля ничего не делают; crash читается как false, а reason — причина, которую узнал AMX Mod X
dropPlayerItemСлышно по команде игрока drop: preventDefault() её отменяет; event.result читается как null, а выброс, который игра делает сама, не слышен
dropWeaponsOnDeathСлышно, как с ReGameDLL, на Linux, а на Windows — со сборкой игры Valve, которую amxts знает; в остальных случаях его ничто не слышит
explodeBombСлышно, когда игра уже сделала своё, поэтому preventDefault() и запись поля ничего не делают; trace и damageType читаются как 0
fallDamageСлышно, как с ReGameDLL, на Linux, а на Windows — со сборкой игры Valve, которую amxts знает; в остальных случаях его ничто не слышит
gameThinkСлышно, как с ReGameDLL, на Linux, а на Windows — со сборкой игры Valve, которую amxts знает; в остальных случаях слышно, когда игра уже сделала своё, поэтому preventDefault() и запись поля ничего не делают
getNextBestWeaponСлышно, как с ReGameDLL, на Linux, а на Windows — со сборкой игры Valve, которую amxts знает; в остальных случаях его ничто не слышит
gibSpawnСлышно, когда игра уже сделала своё, поэтому preventDefault() и запись поля ничего не делают
giveBombОтвет ничего не делает; слышно, как с ReGameDLL, на Linux, а на Windows — со сборкой игры Valve, которую amxts знает; в остальных случаях слышно, когда игра уже сделала своё, поэтому preventDefault() и запись поля ничего не делают
giveDefaultItemsСлышно, как с ReGameDLL, там, где gamedata AMX Mod X находит функцию игры; в остальных случаях его ничто не слышит
intermissionСлышно, как с ReGameDLL, на Linux, а на Windows — со сборкой игры Valve, которую amxts знает; в остальных случаях слышно, когда игра уже сделала своё, поэтому preventDefault() и запись поля ничего не делают
itemRestrictedСпрашивается только про "buying", когда игрок просит покупку: ответ true запрещает покупку, false оставляет решение игре
mapResetСлышно, как с ReGameDLL, на Linux, а на Windows — со сборкой игры Valve, которую amxts знает; в остальных случаях слышно, когда игра уже сделала своё, поэтому preventDefault() и запись поля ничего не делают
newRoundСлышно, как с ReGameDLL, на Linux, а на Windows — со сборкой игры Valve, которую amxts знает; в остальных случаях слышно при перезапуске раунда — обработчики «до» игры, когда она объявляет раунд, обработчики «после» — когда её игроки возродились, — но preventDefault() ничего не делает
plantBombСлышно, когда игра уже сделала своё, поэтому preventDefault() и запись поля ничего не делают; слышно, когда бомба получает модель; ответ ничего не делает
playerBlindСлышно, когда игра уже сделала своё, поэтому preventDefault() и запись поля ничего не делают; inflictor и attacker читаются как мир, color — нулевым
playerGotWeaponСлышно, как с ReGameDLL, на Linux, а на Windows — со сборкой игры Valve, которую amxts знает; в остальных случаях слышно, когда игра уже сделала своё, поэтому preventDefault() и запись поля ничего не делают
playerKilledСлышно, как с ReGameDLL, на Linux, а на Windows — со сборкой игры Valve, которую amxts знает; в остальных случаях слышно, когда игра уже сделала своё, поэтому preventDefault() и запись поля ничего не делают
playerSpawnСлышно, как с ReGameDLL, на Linux, а на Windows — со сборкой игры Valve, которую amxts знает; в остальных случаях слышно, когда игра уже сделала своё, поэтому preventDefault() и запись поля ничего не делают
precacheFilepreventDefault() пропускает прекэш, и он отвечает 0; ответ и запись file ничего не делают
precacheModelpreventDefault() пропускает прекэш, и он отвечает 0; ответ и запись file ничего не делают
precacheSoundpreventDefault() пропускает прекэш, и он отвечает 0; ответ и запись file ничего не делают
removeGunsСлышно, как с ReGameDLL, на Linux, а на Windows — со сборкой игры Valve, которую amxts знает; в остальных случаях его ничто не слышит
roundEndСлышно, когда игра уже сделала своё, поэтому preventDefault() и запись поля ничего не делают; ответ ничего не делает; delay — 5 секунд оригинальной игры, 3 для "gameCommence", если его не задал game.endRound
roundStartСлышно, когда игра уже сделала своё, поэтому preventDefault() и запись поля ничего не делают
sendDeathMessagepreventDefault() отменяет сообщение; assister и inflictor читаются как мир, flags пуст, в rarity бывает только "headshot"; запись поля ничего не делает
sendUserInfoСлышно, как с ReHLDS, на Linux, а на Windows — со сборкой HLDS, которую amxts знает; в остальных случаях его ничто не слышит. receiver — null, когда движок отправляет всем клиентам сразу
setModelpreventDefault() не даёт модели встать; запись modelName ничего не делает
shouldSwitchWeaponСлышно, как с ReGameDLL, на Linux, а на Windows — со сборкой игры Valve, которую amxts знает; в остальных случаях его ничто не слышит
showVguiMenuСлышно, когда меню уходит игроку с включёнными VGUI-меню (не боту): preventDefault() его отменяет; oldMenu читается как "", запись поля ничего не делает
spawnSpotСлышно, как с ReGameDLL, на Linux, а на Windows — со сборкой игры Valve, которую amxts знает; в остальных случаях его ничто не слышит
startSoundСлышно для звуков, которые игра проигрывает через EmitSound движка: preventDefault() его отменяет, recipients выбирает игроков; запись поля ничего не делает
throwFlashbangСлышно, когда игра уже сделала своё, поэтому preventDefault() и запись поля ничего не делают; слышно, когда граната получает модель
throwGrenadeСлышно, когда игра уже сделала своё, поэтому preventDefault() и запись поля ничего не делают; слышно, когда граната получает модель, а eventIndex читается как 0
throwHeGrenadeСлышно, когда игра уже сделала своё, поэтому preventDefault() и запись поля ничего не делают; слышно, когда граната получает модель, а eventIndex читается как 0
throwSmokeGrenadeСлышно, когда игра уже сделала своё, поэтому preventDefault() и запись поля ничего не делают; слышно, когда граната получает модель, а eventIndex читается как 0
userInfoChangeСлышно, как с ReGameDLL, на Linux, а на Windows — со сборкой игры Valve, которую amxts знает; в остальных случаях слышно, когда игра уже сделала своё, поэтому preventDefault() и запись поля ничего не делают; info читается как ""
Другая сборка игры на Windows
С mp.dll, которую amxts не знает, — сборкой игры Valve, с которой его не сверяли, — amxts не перехватывает функции правил игры: консоль сервера говорит об этом один раз, а их события слышно так, как таблица говорит для этого случая.

Порядок раунда — как у игры: newRound до того, как игроки возродятся, их playerSpawn, newRound после игры, когда они живы, roundStart, roundEnd.

События, которые без ReGameDLL никто не слышит
Остальные события ReGameDLL и ReHLDS — вопросы правил игры, которые оригинальная игра задаёт внутри своего кода (teamFull, teamStacked, balanceTeams) или только на старте карты (checkMapConditions), движение игрока (jumpMovement, airMove, …), собственные события движка (printf, addResource, …) и взрывы гранат — на обычном HLDS не слышит никто. Обработчик такого события не вызывается никогда: консоль говорит об этом один раз, когда его добавляют, об этом говорит подсказка редактора к событию, а проект с target: "hlds" его не собирает. Слушайте событие, которое там слышно, — chooseTeam для места в команде.

Конец раунда

game
.
endRound
({
winner
: "TERRORIST" }); // победа террористов; следующий раунд через 5 с
game
.
endRound
({
winner
: "CT",
delay
: 3 });
game
.
endRound
({
winner
: "draw",
message
: "Никто не победил" });
game
.
endRound
({
winner
: "none",
message
: "" }); // никому очко не идёт, без сообщения
НастройкаЗначение
winner"TERRORIST", "CT", "draw" или "none" — кому очко, и обычные для такого конца сообщение и звук
delayсекунды до следующего раунда; по умолчанию 5
messageсообщение посреди экрана или игровой текст вроде "#Terrorists_Win" вместо обычного; "" — без сообщения
soundзвук рации, например "terwin", вместо обычного; "" — без звука
dispatchtrue сообщает об этом конце раунда так, как будто раунд закончила сама игра: обработчикам roundEnd плагинов amxts, хукам сообщений всех плагинов (сообщение и звук) и logevent-ам плагинов на Pawn (строки лога о конце раунда). По умолчанию false: иначе обработчик roundEnd, который заканчивает раунд, вызывал бы сам себя

Перезапуск раунда с v0.3

game
.
completeReset
= true; // и счёт с нуля, как после sv_restart
game
.
restartRound
(); // раунд начинается заново сразу
game
.
checkWinConditions
(); // после ручных перестановок: выигран ли раунд?
game
.
swapTeams
(); // стороны поменялись местами, и их счёт тоже
game
.
balanceTeams
(); // стороны выровнены, как это делает mp_autoteambalance
if (
game
.
timeLeft
< 60)
server
.
command
("say Осталась минута");

game.restartRound() начинает раунд заново сразу, как это делает игра при перезапуске раунда: все на точках появления с деньгами и оружием раунда, карта очищена; счёт остаётся, если перед этим не поставить game.completeReset. Это слышат обработчики newRound всех плагинов. game.checkWinConditions() просит игру проверить, не выигран ли раунд, и завершить его, если выигран, как она проверяет после смерти: для случая, когда плагин перевёл игроков между сторонами или убил их. Оба работают одинаково на любом сервере, и на обычном HLDS тоже.

game.swapTeams() меняет стороны местами вместе с их счётом, как игра в середине матча. game.balanceTeams() выравнивает их, как игра в начале раунда с mp_autoteambalance: из большей стороны — игроки, пришедшие последними, не больше четырёх. game.timeLeft — секунды до конца карты по её лимиту времени, Infinity, если лимита нет.

server
.
addEventListener
("log", (
event
) => {
// World triggered "Round_Draw" (CT "3") (T "3") if (
event
.args[0] == "World triggered")
console
.
log
(`мир: ${
event
.args[1]}`);
});

Серверное событие "log" слышит каждую строку, которую игра пишет в свой лог, — начало и конец раунда, убийство, заложенную бомбу: event.text целиком, без даты, и event.args по частям, как её делит AMX Mod X: текст в кавычках, текст в скобках и слова между ними — каждое отдельной частью.

Правила игры

if (
game
.
isFreezeTime
)
console
.
log
("раунд ещё не начался");
game
.
isFreezeTime
= false; // закончилась — для собственных проверок игры
game
.
ctWins
= 0; // счёт, на таблице сразу
if (
game
.
roundWinner
== "CT")
console
.
log
("последний раунд взял спецназ");

Собственное состояние игры — заморозка, счёт, время раунда, что есть на карте — это поля game, типизированные так же, как поля игрока: число, булево значение, текст, победитель раунда именем. Имена — слова игрока для члена: m_bFreezePeriod — это isFreezeTime, m_iNumCTWins — ctWins, m_iRoundWinStatus — roundWinner, остальные редактор показывает вместе со значением и именем члена. Записанный счёт команды — ctWins, terroristWins — сразу виден на таблице, как когда игра засчитывает раунд.

gameName — имя игры в списке серверов, и запись меняет его там.

Сервер без ReGameDLL
ReGameDLL добавляет к правилам игры поля, которые сервер без него хранит в другом месте или не хранит вовсе. timeLimit и gameStartTime считаются из mp_timelimit и оставшегося времени AMX Mod X, которое идёт с объявления рестарта, а запись timeLimit меняет mp_timelimit. neededPlayers и escapeRatioс v0.3.2 читаются из счётчиков, которые ведёт игра, — spawnableTerrorists и spawnableCts, haveEscaped и numEscapers, — а запись ничего не делает. teamBalanced и skipShowMenu — собственные поля ReGameDLL, true только пока его балансировка переводит игрока и пока игрок входит по его mp_auto_join_team: без него они читаются как 0 и не записываются. Консоль говорит об этом один раз.

Async-обработчики

Обработчик может быть async и ждать внутри через await (async). То, что он вернёт до первого await, — его ответ игре. После await игра уже пошла дальше: обработчик ещё может действовать — написать в чат, выдать предмет, — но то, что он вернёт, до игры уже не дойдёт.

Ограничения

  • Поле-вектор записывается целиком. event.direction = new Vector(0, 0, 1) поворачивает выстрел traceAttack; event.direction.z = 1 меняет копию, и игра её не увидит.
  • Сообщения клиентам слышны через server.addMessageListener (Сообщения); временные эффекты — это эффекты.