Coming from Swiftly

using SwiftlyS2.Shared.Plugins;
using SwiftlyS2.Shared;

namespace MyPlugin;

[PluginMetadata(Id = "MyPlugin", Version = "1.0.0", Name = "My Plugin", Author = "Author", Description = "My first plugin")]
public partial class MyPlugin : BasePlugin
{
    public MyPlugin(ISwiftlyCore core) : base(core)
    {
    }

    public override void Load(bool hotReload)
    {
        Core.Logger.LogInformation("Plugin loaded. Hot reload: {HotReload}", hotReload);
    }

    public override void Unload()
    {
    }
}

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

let loads = 0;

export function OnPluginStart(): void {
	const prev = previous() as { loads: number } | undefined; // undefined on a first load
	loads = (prev?.loads ?? 0) + 1;
	console.log('plugin loaded, hot reload:', prev !== undefined);
}

export function OnPluginState(): unknown {
	return { loads }; // serialized and revived as the next previous()
}

export function OnPluginEnd(): void {
	// best-effort cleanup; the host already tears down commands, hooks, and timers
}

[Command("hello", permission: "myplugin.admin")]
public void OnHelloCommand(ICommandContext context)
{
    if (!context.IsSentByPlayer)
    {
        context.Reply("This command can only be used by players!");
        return;
    }
    context.Reply($"Hello, {context.Sender!.Name}!");
}

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

export function OnPluginStart(): void {
	command.admin('hello', ADMFLAG.GENERIC, (cmd) => {
		if (cmd.callerSlot < 0) {
			cmd.reply('This command can only be used by players!');
			return HookResult.Handled;
		}
		cmd.reply(`Hello, ${Clients.fromSlot(cmd.callerSlot)?.name ?? 'player'}!`);
		return HookResult.Handled;
	});
}

[GameEventHandler(HookMode.Pre)]
public HookResult OnPlayerDeathPre(EventPlayerDeath @event)
{
    return @event.Headshot ? HookResult.Stop : HookResult.Continue;
}

[GameEventHandler(HookMode.Post)]
public HookResult OnPlayerDeath(EventPlayerDeath @event)
{
    if (@event.AttackerPlayer is { } attacker && @event.UserIdPlayer is { } victim)
        Console.WriteLine($"{attacker.Name} killed {victim.Name} with {@event.Weapon}");
    return HookResult.Continue;
}

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

export function OnPluginStart(): void {
	hook.onPre('player_death', (ev) => {
		if (ev.getBool('headshot')) return HookResult.Handled; // clients do not receive it
	});

	hook.on('player_death', (ev) => {
		const attacker = Clients.fromSlot(ev.getPlayerSlot('attacker'));
		const victim = Clients.fromSlot(ev.getPlayerSlot('userid'));
		if (attacker && victim) {
			console.log(`${attacker.name} killed ${victim.name} with ${ev.getString('weapon')}`);
		}
	});
}

var tips = Core.Scheduler.RepeatBySeconds(30.0f, () => Core.PlayerManager.SendChat("Tip: type !help"));
Core.Scheduler.DelayBySeconds(2.0f, () => Console.WriteLine("Executed after 2 seconds."));
Core.Scheduler.NextTick(() => Console.WriteLine("Runs on next tick."));

tips.Cancel();

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

export function OnPluginStart(): void {
	const tips = every(30_000, () => Chat.toAll('Tip: type !help'));
	after(2_000, () => console.log('Executed after 2 seconds.'));

	// later: tips.kill();
}

async function countdown(): Promise<void> {
	for (let i = 3; i > 0; i--) {
		Chat.toAll(`${i}...`);
		await delay(1000);
	}
	await nextFrame();
	Chat.toAll('Go!');
}

foreach (var player in Core.PlayerManager.GetAllPlayers())
{
    if (!player.IsValid || !player.IsAlive || player.PlayerPawn == null) continue;
    player.SendChat($"Your SteamID is {player.SteamID}");
}

Core.PlayerManager.GetPlayer(0)?.Respawn();

import { Chat } from '@s2script/sdk';
import { Player } from '@s2script/cs2';

export function OnPluginStart(): void {
	for (const player of Player.all()) {
		const pawn = player.pawn; // null when dead or absent
		if (!pawn?.isValid) continue;
		pawn.health = 100; // generated schema field; the write notifies the engine
		Chat.toSlot(player.slot, `Your SteamID is ${player.steamId}`);
	}

	Player.fromSlot(0)?.respawn();
}

public class MainConfig
{
    public bool Enabled { get; set; } = true;
}

Core.Configuration
    .InitializeJsonWithModel<MainConfig>("config.jsonc", "Main")
    .Configure(builder =>
        builder.AddJsonFile(Core.Configuration.GetConfigPath("config.jsonc"), optional: false, reloadOnChange: true));

// resources/translations/en.jsonc: { "welcome.message": "[green]Welcome, {0}!" }
var localizer = Core.Translation.GetPlayerLocalizer(player);
player.SendChat(localizer["welcome.message", player.Name]);

{
	"s2script": {
		"config": {
			"enabled": { "type": "bool", "default": true }
		}
	}
}

{
	"Welcome": "{green}Welcome, {1}!"
}

import { config, translations, Translations } from '@s2script/sdk';
import type { Client } from '@s2script/sdk';

export function OnPluginStart(): void {
	translations.load('myplugin');
	config.onChange(() => console.log('enabled =', config.getBool('enabled')));
}

export function OnClientPostAdminCheck(client: Client): void {
	if (!config.getBool('enabled')) return;
	client.chat(Translations.translate(client.slot, 'Welcome', client.name));
}