Steamworks-Dokumentation
Steamworks-API – Übersicht

Übersicht

Mit der Steamworks-API kann Ihr Spiel durch Zugriff auf alle über die API bereitgestellten zugrunde liegenden Systeme sämtliche Steam-Funktionen optimal nutzen. Hierzu zählen beispielsweise: Spiel pausieren, wenn der Benutzer das Steam-Overlay öffnet, Freunde zum Spielen einladen, dem Spieler das Freischalten von Steam-Errungenschaften ermöglichen, Spieler in den Steam-Bestenlisten gegeneinander antreten lassen und mehr.

Im Dokumentationsartikel Steamworks-API-Referenz sind alle in der API unterstützten Schnittstellen, Funktionen, Rückrufe und Datentypen katalogisiert und dokumentiert.

Für die Veröffentlichung Ihres Produkts auf Steam ist die Integration der Steamworks-API nicht erforderlich. Sie wird aber dringend empfohlen, da Sie damit viele Interaktionen umsetzen können, die von Steam-Nutzern erwartet werden.

Erste Schritte

HINWEIS: Die Steamworks-API unterstützt offiziell C++ bei Verwendung von Microsoft Visual Studio 2008 oder höher unter Microsoft Windows, GCC 4.6 und höher sowie Clang 3.0 und höher unter macOS und SteamOS/Linux. Wenn Sie eine Drittanbieter-Engine oder eine andere Programmiersprache als C++ verwenden, lesen Sie zunächst im Dokumentationsartikel Unterstützung von kommerziellen Engines und Nicht-C++-Sprachen nach, ob zusätzliche Anleitungen für Ihre gewählte Engine oder Programmiersprache vorliegen. In einigen Fällen können Sie möglicherweise viele der folgenden Schritte überspringen.

  • Wenn Sie es noch nicht getan haben, laden Sie das Steamworks-SDK herunter und dekomprimieren Sie diese Datei.
  • Kopieren Sie den Headers-Ordner public/steam der Steamworks-API an einen geeigneten Speicherort im Quellverzeichnisbaum Ihrer Anwendung.
  • Kopieren Sie die relevanten Redistributables aus redistributable_bin an einen geeigneten Speicherort in Ihrem Projektordner.
    • Windows
      Sie benötigen eine steam_api[64].lib-Verknüpfung in Ihrem Visual Studio-Projekt. Ziel der Verknüpfung kann entweder die primäre ausführbare Datei oder ein Modul sein, das Steam verwendet. So können Sie auf die Funktionalität von steam_api[64].dll zugreifen, die über die Steamworks-API-Header bereitgestellt wird. Weitere Informationen: Verknüpfen einer ausführbaren Datei mit einer DLL (MSDN)

      Sie müssen außerdem die steam_api[64].dll in Ihrem Laufzeitverzeichnis bereitstellen (neben der ausführbaren Datei Ihres Programms oder in Ihrem DLL-Suchpfad).
    • macOS
      libsteam_api.dylib bietet sowohl die x86- als auch die x64-Version der Steam-API. Sie müssen in Ihrem Xcode-Projekt eine Verknüpfung zu dieser Datei erstellen und sie gemeinsam mit Ihrer ausführbaren Datei bereitstellen.
      Weitere Informationen: Verwenden von dynamischen Bibliotheken.
    • Linux
      Eine Verknüpfung zur Datei libsteam_api.so muss erstellt und gemeinsam mit Ihrer ausführbaren Datei bereitgestellt werden.

Initialisieren und Beenden

SteamAPI_Init

Sobald Sie die Steamworks-API in Ihrem Projekt eingerichtet haben, kann diese durch Aufruf von SteamAPI_Init zur Initialisierung der API verwendet werden. Der globale Status wird dadurch eingerichtet und die Schnittstellenzeiger werden gefüllt, auf die über die dem Namen der Schnittstelle entsprechenden globalen Funktionen zugegriffen wird. Diese Funktion MUSS aufgerufen und erfolgreich ausgeführt werden, bevor Sie auf eine der Steamworks-Schnittstellen zugreifen können!

Die Steamworks-API kann nicht initialisiert werden, wenn der API die App-ID Ihres Spiels nicht bekannt ist. Wenn Sie Ihre Anwendung aus Steam heraus starten, ist die App-ID automatisch verfügbar. Während der Entwicklung müssen Sie die App-ID über eine Textdatei an Steam übergeben. Erstellen Sie im Verzeichnis Ihrer ausführbaren Datei eine Textdatei namens steam_appid.txt, die nur die App-ID und keine weiteren Informationen enthält. Hierdurch wird der von Steam angegebene Wert überschrieben. Liefern Sie diese Datei nicht mit Ihren Builds mit. Beispiel:
480

Der Rückgabewert false gibt eine der folgenden Bedingungen an:
  • Der Steam-Client wird nicht ausgeführt. Damit die Implementierungen der verschiedenen Steamworks-Schnittstellen bereitgestellt werden können, muss der Steam-Client ausgeführt werden.
  • Der Steam-Client konnte die App-ID des Spiels nicht ermitteln. Wenn Sie Ihre Anwendung direkt über die ausführbare Datei oder den Debugger ausführen, muss sich im Spielverzeichnis neben der EXE-Datei auch eine steam_appid.txt-Datei befinden, in der ausschließlich die App-ID enthalten ist. Steam sucht im aktuellen Arbeitsverzeichnis nach dieser Datei. Wenn die ausführbare Datei über ein anderes Verzeichnis ausgeführt wird, müssen Sie ggf. die steam_appid.txt-Datei verschieben.
  • Ihre Anwendung wird nicht im selben Benutzerkontext des Betriebssystems wie der Steam-Client ausgeführt, beispielsweise unter einer anderen Benutzer- oder Administratorzugriffsebene.
  • Stellen Sie sicher, dass Sie im derzeit aktiven Steam-Account eine Lizenz für die App-ID besitzen. Ihr Spiel muss in der Steam-Bibliothek angezeigt werden.
  • Ihre App-ID ist nicht vollständig eingerichtet, d. h. in Release State: Unavailable, oder Standardpakete fehlen.
Sollten Sie Probleme bei der Initialisierung haben, finden Sie in der Debuggen der Steamworks-API-Dokumentation zahlreiche Informationen zum Debuggen der Steamworks-API.

SteamAPI_RestartAppIfNecessary

SteamAPI_RestartAppIfNecessary prüft, ob die ausführbare Datei über Steam gestartet wurde, andernfalls startet sie über Steam neu.

Dies ist optional, wird aber dringend empfohlen, da der mit Ihrer Anwendung verknüpfte Steam-Kontext (einschließlich der App-ID) nicht eingerichtet wird, wenn der Benutzer die ausführbare Datei direkt startet. Wenn dies der Fall ist, schlägt SteamAPI_Init fehl und Sie können die Steamworks-API nicht verwenden.
Wenn Sie diese Funktion verwenden, sollte dies der erste Steamworks-Funktionsaufruf sein, unmittelbar vor dem Aufruf von SteamAPI_Init.

Wenn true zurückgegeben wird, wird der Steam-Client ggf. gestartet und das Spiel über den Steam-Client neu gestartet. In diesem Fall sollten Sie Ihren Prozess so schnell wie möglich beenden. Durch diese Funktion wird steam://run/<AppID> aufgerufen, sodass möglicherweise nicht exakt dieselbe ausführbare Datei neu gestartet wird, die diese Funktion aufgerufen hat (beispielsweise, wenn Sie sie vom Debugger gestartet haben). Diese Funktion führt den Neustart stets mit der im Ordner Ihrer Steam-Bibliothek vorhandenen Version aus.

Ansonsten, wenn false zurückgegeben wird, wurde Ihr Spiel durch den Steam-Client gestartet und es sind keine weiteren Aktionen erforderlich. Ein Ausnahmefall ist beispielsweise die Rückgabe von false, wenn eine steam_appid.txt-Datei vorhanden ist. So können Sie entwickeln und testen, ohne dass Ihr Spiel über den Steam-Client gestartet werden muss. Vergessen Sie nicht, die steam_appid.txt-Datei zu löschen, wenn Sie das Spiel in Ihr Steam-Depot hochladen!

HINWEIS: Wenn Sie den Steam DRM-Wrapper für Ihre primäre ausführbare Datei verwenden, ist diese Prüfung nicht erforderlich, da der DRM-Wrapper sie intern ausführt.

SteamAPI_Shutdown

Wenn Sie mit der Verwendung der Steamworks-API fertig sind, sollten Sie SteamAPI_Shutdown aufrufen, um die von Ihrer Anwendung genutzten Ressourcen in Steam wieder freizugeben. Rufen Sie diese Funktion nach Möglichkeit beim Beenden des Prozesses auf.

Das Steam-Overlay wird dabei nicht von Ihrem Spiel getrennt, da nicht gewährleistet werden kann, dass Ihre Render-API es nicht mehr benötigt.

Steamworks-Schnittstellen

Die Steamworks-API umfasst mehrere Schnittstellen, die jeweils einen bestimmten begrenzten Funktionsumfang bereitstellen.

Nachdem Steamworks erfolgreich initialisiert wurde, können Sie diese Schnittstellen über deren globale Funktionen aufrufen. Die Funktionen haben immer denselben Namen wie die zugehörige Schnittstelle. So können Sie ISteamApps über den SteamApps()-Akzessor und ISteamFriends über SteamFriends() aufrufen.

Mit diesen Schnittstellen können Sie Aufrufe wie den folgenden ausführen:
// Ruft den Steam-Namen des aktuellen Benutzers ab. const char *name = SteamFriends()->GetPersonaName();

Die vollständige Liste der Schnittstellen finden Sie in der Steamworks-API-Referenz oder in den Header-Dateien der Steamworks-API.

Rückrufe

Rückrufe sind einer der wichtigsten Aspekte von Steamworks. Sie ermöglichen den asynchronen Abruf von Steam-Daten, ohne dass Ihr Spiel unterbrochen werden muss. Sie sollen eine einfache, ressourcenschonende, typsichere und threadsichere Methode bereitstellen, um asynchrone Ereignisse für beliebige als Listener registrierte Objekte auszulösen.

Ausgelöst werden Rückrufe normalerweise durch Ereignisse auf Steam, zum Beispiel wenn ein Freund sich an- oder abmeldet, oder durch asynchrone Ergebniswerte einiger API-Funktionen. Jeder Rückruf besteht aus einer Struktur mit einem eindeutigen Bezeichner und einem kleinen Datensatz. Rückrufe werden in den ISteam*.h-Header-Dateien deklariert und mit der nächst zugehörigen Schnittstelle gruppiert.

Damit eine Struktur oder Klasse einen Rückruf überwachen kann, muss in ihrer Deklaration das Makro STEAM_CALLBACK( :classname, :functionname, :callbackname ) verwendet werden.
  • :classname muss der Name der Struktur oder Klasse sein, in der Sie dies definieren. (z. B. CGameManager)
  • :functionname ist der Name der Funktion, die dieser Rückruf empfängt. (z. B. OnGameOverlayActivated)
  • :callbackname ist der Name des Rückrufs. (z. B. GameOverlayActivated_t)
Dies definiert eine lokale Memberfunktion für diese Klasse, für die automatisch der Prototyp void :functionname( :callbackname *pCallback ) erstellt wird. Die Erstellung einer neuen Objektinstanz führt zur Selbstregistrierung dieser Funktion als Listener in der Steamworks-API. Bei Zerstörung des Objekts wird dessen Registrierung aufgehoben.

HINWEIS: Stellen Sie sicher, dass Steam vor der Erstellung von Objekten als Listener für Rückrufe initialisiert wurde.

SteamAPI_RunCallbacks muss aufgerufen werden, damit Rückrufe mit registrierten Listenern kommunizieren können. Es empfiehlt sich, diesen Aufruf regelmäßig auszuführen. Je mehr Zeit zwischen den Aufrufen liegt, desto größer wird die Latenz zwischen dem Empfang von Ereignissen und Ergebnissen aus der Steamworks-API. Die meisten Spiele rufen diese Funktion einmal pro gerendertem Frame auf. Wir empfehlen dringend eine Frequenz von mindestens einmal pro Sekunde. Dieser Aufruf ruft alle registrierten Listener-Funktionen im Kontext des Threads auf, von dem aus SteamAPI_RunCallbacks aufgerufen wurde.

Beispiel

Sie werden höchstwahrscheinlich den Rückruf ISteamFriends::GameOverlayActivated_t verwenden. Wie der Name schon sagt, erhalten Sie mit jeder Aktivierung bzw. Deaktivierung von Steam-Overlay durch den Nutzer einen Rückruf.

class CGameManager { private: STEAM_CALLBACK( CGameManager, OnGameOverlayActivated, GameOverlayActivated_t ); }; void CGameManager::OnGameOverlayActivated( GameOverlayActivated_t* pCallback ) { if ( pCallback->m_bActive ) printf( "Steam overlay now active\n" ); else printf( "Steam overlay now inactive\n" ); }

Ein beliebter und empfohlener Anwendungsfall für den Rückruf von ISteamFriends::GameOverlayActivated_t ist das Pausieren des Spiels beim Öffnen des Overlays.

CallResults

Viele Steamworks-Methoden verwenden Aufrufergebnisse anstelle von Rückrufen, um Ergebnisse eines Funktionsaufrufs asynchron zurückzugeben. Der Unterschied zwischen einem Rückruf und Aufrufergebnissen liegt darin, dass Rückrufe an alle Listener übertragen werden, wogegen Aufrufergebnisse nur an einen bestimmten Listener adressiert sind. Wie jeder Rückruf muss Ihr Spiel SteamAPI_RunCallbacks aufrufen, um Aufrufergebnisse an die zugehörigen Listener weiterzuleiten.

Sie erkennen eine Funktion, die ein Aufrufergebnis zurückgibt, an deren Rückgabewert. Wenn SteamAPICall_t zurückgegeben wird und ein CALL_RESULT()-Attribut enthalten ist, muss eine Registrierung durchgeführt werden, damit das Aufrufergebnis empfangen werden kann.

HINWEIS: Rückrufe und Aufrufergebnisse sind nicht austauschbar. Ein Ereignis wird stets durch eine der beiden Methoden übermittelt, niemals durch beide. Stellen Sie stets sicher, dass Sie die Registrierung für den korrekten Ereignistyp durchführen.

Aufrufergebnisse müssen mit dem CCallResult-Typ als Mitglieder einer Struktur/Klasse erstellt werden; außerdem müssen Sie die Memberfunktion erstellen, die der Rückruf empfangen soll.
void func( :callresultname *pCallback, bool bIOFailure ); CCallResult< :classname, :callresultname > m_callresultname;
  • :classname muss der Name der Struktur oder Klasse sein, in der Sie dies definieren. (z. B. CGameManager)
  • :callresultname ist der Name des Rückrufs. (z. B. NumberOfCurrentPlayers_t)

Sie können die Funktionen, Funktionsparameter und den CCallResult-Typ völlig frei benennen.

Beispiel

Das folgende Beispiel zeigt die Verwendung der ISteamUserStats::GetNumberOfCurrentPlayers-API, die ein Aufrufergebnis von ISteamUserStats::NumberOfCurrentPlayers_t generiert.
// In Ihrer Klassendefinition class CGameManager { public: void GetNumberOfCurrentPlayers(); private: void OnGetNumberOfCurrentPlayers( NumberOfCurrentPlayers_t *pCallback, bool bIOFailure ); CCallResult< CGameManager, NumberOfCurrentPlayers_t > m_NumberOfCurrentPlayersCallResult; }; // Macht eine asynchrone Anfrage nach der Anzahl gleichzeitiger Spieler. void CGameManager::GetNumberOfCurrentPlayers() { printf( "Getting Number of Current Players\n" ); SteamAPICall_t hSteamAPICall = SteamUserStats()->GetNumberOfCurrentPlayers(); m_NumberOfCurrentPlayersCallResult.Set( hSteamAPICall, this, &CGameManager::OnGetNumberOfCurrentPlayers ); } // Wird aufgerufen, wenn SteamUserStats()->GetNumberOfCurrentPlayers() asynchron ausgibt, nachdem SteamAPI_RunCallbacks() aufgerufen wurde. void CGameManager::OnGetNumberOfCurrentPlayers( NumberOfCurrentPlayers_t *pCallback, bool bIOFailure ) { if ( bIOFailure || !pCallback->m_bSuccess ) { printf( "NumberOfCurrentPlayers_t failed!\n" ); return; } printf( "Number of players currently playing: %d\n", pCallback->m_cPlayers ); }

HINWEIS: Wenn Sie das CCallResult-System nicht nutzen können, können Sie den Status eines Aufrufergebnisses möglicherweise mit ISteamUtils::IsAPICallCompleted, ISteamUtils::GetAPICallResult und ISteamUtils::GetAPICallFailureReason verfolgen.

Manueller Rückrufversand

Die zur Registrierung von Rückrufen verwendeten Klassen und Markos sind in C++ praktisch. Des Weiteren gibt es auch einen Mechanismus niedrigeren Niveaus zur Abhandlung von Rückrufen. Dieser Mechanismus verhält sich eher wie eine Windows-Event-Schleife. Statt eine einzelne Funktion, die alle Rückrufe und Rückrufergebnisse an aktive Listeners sendet, wird der nächste verfügbare Rückruf in einer Schleife abgefangen und unter Verwendung des gewünschten Mechanismus versendet. Der manuelle Versandmodus ist insbesondere für Verknüpfungsebenen nützlich, die die Steamworks-SDK für andere Sprachen als C++ zugänglich machen. Für weitere Informationen lesen Sie SteamAPI_ManualDispatch_Init() in steam_api.h.

Steam-Spielserver

Die Steamworks-API bietet Unterstützung für die Ausführung von Spielservern und herkömmlichen Clients. Im Kontext der Steamworks-API ist ein Spielserver eine Entität im System, mit der sich Benutzer verbinden, um Mehrspielerspiele zu spielen. Hierbei kann es sich um eine Internetverbindung zu einem Remote-Spielserver oder um eine lokale Verbindung zu einem Spielserver handeln, der im selben Prozess wie der Client ausgeführt wird. Spielserver haben ihre eigene Gruppe von API-Funktionen und eine eindeutige Steam-ID, über die sie von anderen Benutzern referenziert werden.

Um die Steam-Spielserver-API zu verwenden, müssen Sie zunächst steam_gameserver.h statt steam_api.h hinzufügen.

Die Initialisierung und Verwendung der Spielserver-API erfolgt fast identisch zur normalen API:

Nachdem Sie den Spielserver initialisiert haben, haben Sie Zugriff auf die beiden exklusiv für Spielserver vorbehaltenen Schnittstellen ISteamGameServer und ISteamGameServerStats.

Außerdem können Sie vom Spielserver aus auf die folgenden normalen Schnittstellen zugreifen:
  • ISteamClient, Zugriff über die globale Schnittstelle: SteamGameServerClient()
  • ISteamUtils, Zugriff über die globale Schnittstelle: SteamGameServerUtils()
  • ISteamNetworking, Zugriff über die globale Schnittstelle: SteamGameServerNetworking()
  • ISteamHTTP, Zugriff über die globale Schnittstelle: SteamGameServerHTTP()
  • ISteamUGC, Zugriff über die globale Schnittstelle: SteamGameServerUGC()
  • ISteamApps, Zugriff über die globale Schnittstelle: SteamGameServerApps()

Wenn Sie einen dedizierten Spielserver (d. h. ohne Clientkomponente) ausführen, müssen Sie lediglich die Spielserver-APIs initialisieren, ohne die normale Benutzer-API initialisieren zu müssen.

Ein ausführliches Beispiel zur Verwendung der Spielserver-API finden Sie unter Steamworks-API-Beispielanwendung (SpaceWar).

Im Gegensatz zu einem Spiel wird ein dedizierter Server üblicherweise in einer Umgebung eingesetzt, in der kein Steam-Client installiert wurde, der die neuesten Steamwork-Binärdateien zur Verfügung stellt. Zur Aktualisierung der Steam-Binärdaten eines dedizierten Servers auf den neuesten Stand müssen Sie die Redistributables für dedizierte Server zu Ihrer Anwendung hinzufügen. Melden Sie sich bei partner.steamgames.com an und greifen Sie auf die technischen Einstellungen Ihrer Anwendung zu. Rufen Sie dann „Installation/Redistributables“ auf und überprüfen Sie die „Redistributables für dedizierte Server“.

Unterstützung von kommerziellen Engines und Nicht-C++-Sprachen

Wenn Sie eine kommerzielle Spiel-Engine oder eine andere Sprache als C oder C++ verwenden, müssen Sie zunächst ermitteln, inwieweit die Steamworks-API Unterstützung dafür bietet.
Für einige Engines ist native Unterstützung integriert, für andere benötigen Sie möglicherweise eine Lösung eines Drittanbieters.

Wenn für Ihre Engine keine native Unterstützung bereitgestellt wird, können Sie über die Steam-Web-API auf viele der von Steam unterstützten Features zugreifen.

Unabhängig davon, wie das Steamworks-SDK in Ihrer Engine implementiert ist, benötigen Sie das aktuellste Steamworks-SDK, um Ihre Anwendung auf Steam hochzuladen.

HINWEIS: Wenn Teile der von Ihnen auf Steam veröffentlichten Software unter einer eingeschränkten Open-Source-Lizenz verfügbar sind, lesen Sie bitte den Abschnitt Vertrieb von Open-Source-Anwendungen auf Steam.

Im Folgenden finden Sie einige der üblichen Engines, mit denen Spiele häufig auf Steam veröffentlicht werden, sowie die zugehörige Dokumentation zu deren Verwendung mit dem Steamworks-SDK.

HINWEIS: Diese Engines bzw. Drittanbieterlösungen werden in keiner Form von Valve unterstützt oder empfohlen. Diese Liste ist nach Namen sortiert und ist keinesfalls vollständig. Sie stellt lediglich einen Ausgangspunkt dar. Nur Engines mit nativer Unterstützung oder einer den Richtlinien entsprechenden Drittanbieterlösung sind aufgelistet. Drittanbieterlösungen werden nur aufgelistet, wenn sie angemessen aktuell zur neuesten Version des Steamworks-SDK bleiben, unter einer frei verfügbaren Lizenz angeboten werden (siehe Vertrieb von Open-Source-Anwendungen auf Steam) und ein eigenes Thema im Steamworks-Diskussionsforum besitzen. Wir empfehlen, die Community zu befragen, um die für Ihr Setup optimale Option zu ermitteln.

Engines:

EngineNative Unterstützung?Information
CRYENGINE ✔️
GameMaker Studio 2 ✔️ Verwendung der Steamworks-SDK mit GameMaker: Studio
Godot Third Party: GodotSteam - Steamworks Developer Discussions support thread
Haxe Drittanbieter: SteamWrapUnterstützungsthread im Steamworks-Entwicklerdiskussionsforum
Leadwerks Game Engine ✔️ Leadwerks-API-Referenz › Steamworks
RPG Maker MV Drittanbieter: GreenworksUnterstützungsthread im Steamworks-Entwicklerdiskussionsforum
Source 2013 ✔️ Vertrieb von Spielen und Mods für die Source-Engine
Unity Drittanbieter: Facepunch.SteamworksUnterstützungsthread im Steamworks-Entwicklerdiskussionsforum
Drittanbieter: http://steamworks.github.ioUnterstützungsthread im Steamworks-Entwicklerdiskussionsforum
Unreal Engine 4 ✔️ Online Subsystem Steam
Visionaire Studio ✔️ Auf Steam veröffentlichen

Sprachen:

Flache Schnittstelle zur Verknüpfung mit anderen Sprachen

Die SDK verfügt über einige Funktionen, die die Erstellung von Verknüpfungsebenen für andere Sprachen erleichtern.

  • steam_api_flat.h deklariert einen Satz von „flachen“ Funktionen, die die Schnittstellenfunktionen der SDK spiegeln. Hierbei handelt es sich um keinen reinen C-Code, es werden aber eine einfache C-Verknüpfung und Aufrufkonventionen verwendet, die die gemeinsame Funktionsweise mit anderen Sprachen vereinfachen. Diese Funktionen werden von steam_api[64][.dll/.so/dylib] exportiert.
  • steam_api.json beschreibt (fast alle) Schnittstellen, Typen und Funktionen des SDK. Diese Datei ist dazu gedacht, von einem automatisierten Prozess zur Generierung der Verknüpfungsebene verwendet zu werden. Wir hoffen, dass dies dabei hilft, 95 % der Arbeit zu automatisieren, jedoch gibt es noch immer einige Sonderfälle, die manuell behandelt werden müssen. Insbesondere müssen CSteamID and CGameID von Ihrer Verknüpfungsebene besonders behandelt werden, um Effizienz zu garantieren.

Technische Details

Steam stellt Ihrer Anwendung mit verschiedenen Techniken seine Funktionalität bereit. Genaues Verständnis der Funktionsweise der Steamworks-API ist zwar nicht erforderlich, doch es ist im Prinzip recht einfach und kann hilfreich bei der Planung Ihrer Spielprogrammierung mit Berücksichtigung der Steam-Integration sein.

Verknüpfung mit steam_api[64][.dll/.so/dylib] ermöglicht Ihnen Zugriff auf eine kleine Anzahl an C-Funktionen, die das S_API-Makro vorangestellt haben. Diese Funktionen werden alle in steam_api.h und steam_gameserver.h bereitgestellt. Das steam_api-Modul selbst ist sehr klein und stellt nur die Grundfunktionalität zum Initialisieren und Herunterfahren der Steamworks-API bereit.

Wenn die Steamworks-API initialisiert wird, sucht sie aktiv nach ausgeführten Steam-Client-Prozessen und lädt steamclient.dll aus diesem Pfad. steamclient.dll ist im Wesentlichen die Kern-Engine des Steam-Clients. Die zur Ausführung von Steam erforderlichen Informationen sind dort enthalten und werden dort verwaltet. Die UI des Steam-Clients verwendet ähnliche Funktionen wie die hier bereitgestellten, um auf die von steamclient.dll zur Verfügung gestellten Daten zuzugreifen. Da sich diese Daten im Steam-Prozess befinden, werden alle Aufrufe der Steam-API transparent gemarshallt und über einen RPC/IPC-Mechanismus gesendet. (Eine prozessübergreifende Pipe, ISteamClient::HSteamPipe).

Der Steam-Prozess hält über steamclient.dll eine konstante Verbindung mit den Steam-Backendservern aufrecht. Über diese Verbindung erfolgt sämtliche Kommunikation hinsichtlich Authentifizierung, Spielsuche, Freundeslisten und VAC. Die Verbindung kann unterbrochen werden, wenn der Benutzer ein Netzwerkproblem hat oder der Steam-Server aktualisiert wird. Rückrufe werden an alle laufenden Anwendungen gesendet, wenn die Verbindung unterbrochen oder wiederhergestellt wird. Der Steam-Client versucht automatisch, die Verbindung wiederherzustellen, und Clients, die eine Anwendung ausführen, erhalten Priorität. Daher liegt die typische bis zur Wiederherstellung benötigte Zeit bei weniger als 10 Sekunden, auch wenn es in seltenen Fällen bis zu 5 Minuten dauern kann.

Die Steamworks-API wird über einen COM-ähnlichen Mechanismus versioniert, bei dem ein Zeichenfolgenname und eine Version einer Schnittstelle an steamclient.dll übergeben werden, die dann die korrekte Version der Schnittstelle an die aufrufende Methode zurückgibt. steamclient.dll enthält eine Reihe von Adaptern für alle veröffentlichten Versionen einer Schnittstelle, durch die die alten Aufrufe dem Kontext der neuesten Schnittstellen entsprechend weitergeleitet oder neu interpretiert werden. Die Adapter sind im Steam-Client integriert, sodass sie im Fall von Problemen einfach aktualisiert werden können.