V1 API-Schnittstelle#

Diese Seite geht ausführlich auf alle SDK-Anforderungen und Funktionen ein, die bereitgestellt werden. Ein vollständiges Beispiel-Plugin ist zu finden hier.

Merkmale#

• Logging-Schnittstelle
• GSC-Funktion und Methodenregistrierung
• Kundenbefehlsregistrierung
• Event-Rückrufe
• Thread-Scheduler

Einstiegspunkt#

Der wichtigste Teil deines Plugins ist die Einrichtung des Einstiegspunkts. Ohne eine korrekte Implementierung wird dein Plugin nicht geladen. Der folgende Codeausschnitt kann als Mindestbeispiel zur Einrichtung des Einstiegspunkts verwendet werden.

#include "plutonium-sdk/plutonium_sdk.hpp"

std::unique_ptr<plutonium::sdk::plugin> plugin_;
class plugin_impl : public plutonium::sdk::plugin
{
public:
    const char* plugin_name() override
    {
        return "Plutonium SDK Example";
    }

    void on_startup(plutonium::sdk::iinterface* interface_ptr, plutonium::sdk::game game) override
    {
        // startup code
    }

    void on_shutdown() override
    {
        // shutdown code
    }
};

PLUTONIUM_API plutonium::sdk::plugin* on_initialize()
{
    return (plugin_ = std::make_unique<plugin_impl>()).get();
}

BOOL APIENTRY DllMain(HMODULE, DWORD, LPVOID)
{
    return TRUE;
}

Das plugin_name(), on_startup() und on_shutdown() Methoden müssen implementiert werden, damit Ihr Plugin von Plutonium als gültig gilt.

• on_startup: Ausgeführt nachdem alle Plutonium-Patches aufgetragen wurden, bevor der WinMain des Spiels aufgerufen wird
• on_shutdown: Wird ausgeführt, wenn das Plugin entladen wird

Das on_initialize Die Funktion dient als Einstiegspunkt für dein Plugin. Diese Funktion ist der Weg, wie Plutonium die Implementierung des Plugin-SDKs entdeckt. Ihre Implementierung muss genau dieser Signatur folgen.

Die Plugin-Oberfläche bietet außerdem eine optionale is_game_supported() Methode. Standardmäßig versuchen alle von Plutonium unterstützten Spiele, das Plugin zu laden. Du kannst mit dieser Methode entscheiden, ob du dein Plugin laden willst, wenn es nur einen Titel unterstützt.

Holzeinschlag#

Die Logging-Schnittstelle wird verwendet, um Nachrichten zurück ins Plutonium-Konsolenfenster zu drucken.

void on_startup(plutonium::sdk::iinterface* interface_ptr, plutonium::sdk::game game) override
{
    interface_ptr->logging()->info("Plugin Starting Up!");
}

• Info: Druckt Informationsnachricht ohne Ausfärbung
• WARN: Druckt Warnmeldungen mit gelbem Text
• Fehler: Druckt die Fehlermeldung mit rotem Text

GSC#

Die GSC-Schnittstelle wird verwendet, um benutzerdefinierte Methoden und Funktionen in der GSC-VM zu registrieren. Diese Methoden können dann einfach aus einem auf dem Server geladenen GSC-Skript aufgerufen werden.

HAFTUNGSAUSSCHLUSSWenn es in IW5 verwendet wird, führt das Löschen deines Plugins wahrscheinlich zum Absturz des Spiels. Das Entladen wird auf T4, T5 und T6 mit individuellen GSC-Einbauten unterstützt.

void test_method_builtin(plutonium::sdk::types::entref entity)
{

}

void test_function_builtin()
{

}

void on_startup(plutonium::sdk::iinterface* interface_ptr, plutonium::sdk::game game) override
{
    interface_ptr->gsc()->register_function("testFunction", test_function_builtin);
    interface_ptr->gsc()->register_method("testMethod", test_method_builtin);
}

GSC-Nutzung:

init()
{
    testFunction();

    level thread onPlayerConnect();
}

onPlayerConnect()
{
    for(;;)
    {
        level waittill( "connected", player );

        player testMethod();
    }
}

Kommandos#

Die Client-Befehlsschnittstelle wird verwendet, um einen benutzerdefinierten Handler für einen bestimmten Befehl zu registrieren, der von einem Client an den Server gesendet wird.

void client_command_function_test(int client_num)
{

}

void on_startup(plutonium::sdk::iinterface* interface_ptr, plutonium::sdk::game game) override
{
    interface_ptr->client_command()->register_client_command("testClientCommand", client_command_function_test);
}

Rückrufe#

Die Rückruf-Oberfläche ermöglicht es deinem Plugin, benachrichtigt zu werden, wenn generische Spielereignisse auftreten. Diese Ereignisse können dann verwendet werden, um benutzerdefinierte Logik hinzuzufügen, die zu einem bestimmten Zeitpunkt ausgeführt werden muss.

• on_dvar_init() - Das Dvar-System des Spiels ist initialisiert und bereit, Dvars zu registrieren
• on_after_dvar_init() - Die meisten Spiel-Dvars sind registriert und die Haupt-Thread-Schleife steht kurz bevor, zu beginnen
• on_game_init(int levelTime, int-Neustart) - Der Spielserver wird initialisiert
  • levelTime – Die Zeit, in der der Server läuft
  • Neustart – Gibt an, ob diese Initialisierung auf einen Server-Neustart zurückzuführen ist (d. h. map_restart)
• on_game_shutdown(int freeScripts) - Der Spielserver wird abgeschaltet
  • freeScripts – Gibt an, ob die Spielskripte kostenlos sein werden (also kein map_restart)
• on_player_pre_connect(int clientNum) - Ein Client verbindet sich zum ersten Mal mit dem Server
• on_player_connect(int clientNum) - Ein Client verbindet sich mit dem Server
  • Dieses Ereignis tritt auf, wenn ein Kunde nach einem map_restart wieder Kontakt aufnimmt!
• on_player_disconnect(int clientNum) - Ein Client trennt sich vom Server
• on_scripts_load() - Der Server beginnt, GSC-Skripte zu laden.
• on_scripts_execute() - Der Server beginnt, GSC-Skripte auszuführen.

Scheduler#

Die Scheduler-Oberfläche ermöglicht es deinem Plugin, Code zu einem bestimmten Zeitpunkt auf einem bestimmten Spiele-Thread auszuführen.

Threads:

• main – Der Hauptthread der ausführbaren Datei des Spiels. Dieser Thread ist immer aktiv
• Game – Der Spiel-/Server-Thread. Dieser Thread wird nur ausgeführt, wenn eine Karte gerade geladen und abgespielt wird

Zeitpläne:

• on_frame – Dieser Callback wird bei jedem Frame des gewählten Threads ausgeführt.
• einmal – Dieser Callback wird einmal im nächsten Frame des gewählten Threads ausgeführt.
• Verzögerung – Dieser Rückruf wird auf dem gewählten Thread nach einer festgelegten Anzahl von Millisekunden ausgeführt
• every - Dieser Callback wird nach einer bestimmten Anzahl von Millisekunden auf dem gewählten Thread ausgeführt und basierend auf der Auswertung des Callbacks neu geplant, um erneut ausgeführt zu werden.

scheduler::evaluation callback()
{
    // code
    return scheduler::reschedule;
}

void on_startup(plutonium::sdk::iinterface* interface_ptr, plutonium::sdk::game game) override
{
    // execute a callback on the game thread every 1000ms
    interface_ptr->scheduler()->every(callback, 1000, scheduler::thread::game);
}