Ü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:
Sprachen:
- ActionScript (Adobe Flash, AIR)
- C#
- D
- Java
- JavaScript
- Python
- Rust
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.