Coming from CounterStrikeSharp

public class GreeterPlugin : BasePlugin
{
    public override string ModuleName => "Greeter";
    public override string ModuleVersion => "1.0.0";

    private int _greeted;

    public override void Load(bool hotReload)
    {
        RegisterListener<Listeners.OnMapStart>(mapName =>
            Logger.LogInformation("Map {Map}", mapName));

        RegisterListener<Listeners.OnClientAuthorized>((slot, steamId) =>
        {
            _greeted++;
            Utilities.GetPlayerFromSlot(slot)?.PrintToChat("Welcome!");
        });
    }

    public override void Unload(bool hotReload) { }
}

import { previous } from '@s2script/sdk';
import type { Client } from '@s2script/sdk';

let greeted = 0;

export function OnPluginStart(): void {
	const prev = previous() as { greeted: number } | undefined;
	greeted = prev?.greeted ?? 0; // survives a hot reload
}

export function OnMapStart(mapName: string): void {
	console.log('map', mapName);
}

export function OnClientPostAdminCheck(client: Client): void {
	greeted++;
	client.chat('Welcome!');
}

export function OnPluginState(): unknown {
	return { greeted }; // handed to the next instance as previous()
}

export function OnPluginEnd(): void {
	// optional; commands, hooks and timers are removed for you
}

[ConsoleCommand("css_slay", "Slay a player by userid")]
[CommandHelper(minArgs: 1, usage: "<userid>", whoCanExecute: CommandUsage.CLIENT_AND_SERVER)]
[RequiresPermissions("@css/slay")]
public void OnSlay(CCSPlayerController? caller, CommandInfo info)
{
    var target = Utilities.GetPlayerFromUserid(int.Parse(info.GetArg(1)));
    target?.PlayerPawn.Value?.CommitSuicide(false, true);
    info.ReplyToCommand("Slayed.");
}

import { command, ADMFLAG, HookResult } from '@s2script/sdk';
import { Player } from '@s2script/cs2';

export function OnPluginStart(): void {
	command.admin('sm_slay', ADMFLAG.SLAY, (cmd) => {
		if (cmd.argCount < 1) {
			cmd.reply('Usage: sm_slay <target>');
			return HookResult.Handled;
		}
		const targets = Player.target(cmd.arg(0), cmd.callerSlot); // #userid, name, @all, @me
		for (const target of targets) target.pawn?.slay();
		cmd.reply(`Slayed ${targets.length} player(s).`);
		return HookResult.Handled;
	});
}

[GameEventHandler(HookMode.Pre)]
public HookResult OnPlayerDeathPre(EventPlayerDeath @event, GameEventInfo info)
{
    if (!@event.Headshot)
    {
        info.DontBroadcast = true;
    }
    return HookResult.Continue;
}

[GameEventHandler]
public HookResult OnRoundStart(EventRoundStart @event, GameEventInfo info)
{
    Logger.LogInformation("Round start, timelimit {Timelimit}", @event.Timelimit);
    return HookResult.Continue;
}

import { hook, HookResult } from '@s2script/sdk';

export function OnPluginStart(): void {
	hook.onPre('player_death', (ev) => {
		if (!ev.getBool('headshot')) {
			return HookResult.Handled; // clients do not get the event; the server still processes it
		}
		return HookResult.Continue;
	});

	hook.on('round_start', (ev) => {
		console.log('round start, timelimit', ev.getInt('timelimit'));
	});
}

public override void Load(bool hotReload)
{
    AddTimer(60.0f, () => Server.PrintToChatAll("Type !help for commands"), TimerFlags.REPEAT);
    AddTimer(3.0f, () => Server.PrintToChatAll("3 seconds after load"));
}

[GameEventHandler]
public HookResult OnRoundStart(EventRoundStart @event, GameEventInfo info)
{
    AddTimer(5.0f, () => Server.PrintToChatAll("5 seconds into the round"));
    return HookResult.Continue;
}

import { hook, Chat } from '@s2script/sdk';
import { after, every, delay } from '@s2script/sdk/timers';
import type { Timer } from '@s2script/sdk/timers';

let tips: Timer | undefined;

async function announceLater(): Promise<void> {
	await delay(5_000);
	Chat.toAll('5 seconds into the round');
}

export function OnPluginStart(): void {
	tips = every(60_000, () => Chat.toAll('Type !help for commands'));
	after(3_000, () => Chat.toAll('3 seconds after load'));

	hook.on('round_start', () => {
		void announceLater();
	});
}

[ConsoleCommand("css_heal", "Set your health to 100")]
public void OnHeal(CCSPlayerController? player, CommandInfo info)
{
    var pawn = player?.PlayerPawn.Value;
    if (pawn == null || !pawn.IsValid) return;

    pawn.Health = 100;
    Utilities.SetStateChanged(pawn, "CBaseEntity", "m_iHealth");
}

import { command, HookResult } from '@s2script/sdk';
import { Pawn } from '@s2script/cs2';

export function OnPluginStart(): void {
	command('heal', (cmd) => {
		const pawn = Pawn.forSlot(cmd.callerSlot);
		if (!pawn?.isValid) {
			cmd.reply('You need to be alive.');
			return HookResult.Handled;
		}
		pawn.health = 100; // m_iHealth; the network update is sent for you
		return HookResult.Handled;
	});
}

public class SampleConfig : BasePluginConfig
{
    [JsonPropertyName("ChatPrefix")] public string ChatPrefix { get; set; } = "My Cool Plugin";
    [JsonPropertyName("ChatInterval")] public float ChatInterval { get; set; } = 60;
}

public class WithConfigPlugin : BasePlugin, IPluginConfig<SampleConfig>
{
    public override string ModuleName => "Example: With Config";
    public override string ModuleVersion => "1.0.0";

    public SampleConfig Config { get; set; }

    public void OnConfigParsed(SampleConfig config)
    {
        if (config.ChatInterval > 60) config.ChatInterval = 60;
        Config = config;
    }
}

{
	"s2script": {
		"config": {
			"chat_prefix": {
				"type": "string",
				"default": "My Cool Plugin",
				"description": "Chat prefix"
			},
			"chat_interval": { "type": "float", "default": 60 }
		}
	}
}

import { config } from '@s2script/sdk';

function chatInterval(): number {
	return Math.min(config.getFloat('chat_interval'), 60); // validate on read
}

export function OnPluginStart(): void {
	console.log(config.getString('chat_prefix'), chatInterval());

	config.onChange(() => {
		console.log('config reloaded, interval =', chatInterval());
	});
}