Messages

The server tells each client what to draw and play through messages: a chat line, a HUD icon, the round clock, a death notice. A plugin hears a message before it leaves, reads it, changes it or stops it:

server
.
addMessageListener
("death", (
event
) => {
    if (
event
.
headshot
) 
print
(0, `${
event
.
killer
?.
name
} - headshot - ${
event
.
victim
?.
name
}`);
});

server
.
addMessageListener
("text", (
event
) => {
    if (
event
.
text
 == "#Round_Draw") 
event
.
preventDefault
();   // the client does not get it
});

server
.
addMessageListener
("team", (
event
) => {
    if (
event
.
team
 == "SPECTATOR") 
console
.
log
(`${
event
.
target
?.
name
} watches`);
});

server
.
addMessageListener
("roundTime", (
event
) => {
    
event
.
seconds
 = 90;                                         // the clock shows 90
});

server.removeMessageListener("death", listener) stops it: pass the same name and the same function that were added. Only the messages listened for reach the plugin.

A message's name is written out as a string, and the editor lists the names, each with what the game uses the message for and the game's own name of it: death is the game's DeathMsg, chat its SayText. The table at the end of the page has them all.

A few of the game's messages are one thing to a plugin, and one name hears them all: progressBar is BarTime and BarTime2, which only adds where the bar starts. The event has the fields of every one of them, and event.name says which one came; a field the message that came does not carry reads as 0, null or empty, and assigning it changes nothing - startPercent is 0 on a BarTime.

server
.
addMessageListener
("progressBar", (
event
) => {
    
console
.
log
(`${
event
.
name
}: ${
event
.
seconds
} s from ${
event
.
startPercent
}%`);
});

The event

event.player is the player the message goes to, null for one sent to everyone, so a player the message is about is a field of its own: target, or its role - killer, victim, sender. preventDefault() stops the message. event.name is the game's name of the message, "DeathMsg" for death.

The game writes each message in a layout of its own, and a message whose layout is known - almost every one Counter-Strike sends - has a field for each of its arguments, named and typed: a player is a Player (null for none), a flag a boolean, a team a Team, a weapon a WeaponKind, a mask an array of names, a time in seconds. The editor lists them. Assigning a field changes what the client gets: event.team = "CT".

server
.
addMessageListener
("hideWeapon", (
event
) => {
    
event
.
flags
 = 
event
.
flags
.
concat
(["money"]);               // the money is hidden too
});

A message whose layout is not known - a bot's progress, the tutor's texts - is read by the place of its arguments, through event.args, which every message has for what its fields leave out:

server
.
addMessageListener
("botProgress", (
event
) => {
    
console
.
log
(`${
event
.
args
.
length
} ${
event
.
args
.
number
(0)}`);
});

event.args.number(i) and event.args.text(i) read the argument at i, 0 for the first; isText(i) tells which it is; setNumber(i, value) and setText(i, value) change it.

An argument the message did not write - statusIcon's colour when it hides the icon, the params of a text that takes none - reads as 0 or empty, and assigning it changes nothing. A name the game has no message for is a build error.

Every message