gpg:: TurnBasedMultiplayerManager
#include <turn_based_multiplayer_manager.h>
Ruft TurnBasedMatch
-Objekte ab, ändert sie und erstellt sie.
Zusammenfassung
Öffentliche Typen |
|
---|---|
MatchInboxUICallback
|
typedef.std::function< void(const MatchInboxUIResponse &)>
Definiert einen Callback, der einen MatchInboxUIResponse von ShowMatchInboxUI empfangen kann. |
MultiplayerStatusCallback
|
typedef.std::function< void(MultiplayerStatus)>
Definiert einen Callback, mit dem ein MultiplayerStatus empfangen werden kann. |
PlayerSelectUICallback
|
typedef.std::function< void(const PlayerSelectUIResponse &)>
Definiert einen Callback, der einen PlayerSelectUIResponse von ShowPlayerSelectUI empfangen kann. |
TurnBasedMatchCallback
|
typedef.std::function< void(const TurnBasedMatchResponse &)>
Definiert einen Callback, der verwendet werden kann, um ein TurnBasedMatchResponse aus einem der rundenbasierten Mehrspieleroperationen zu empfangen. |
TurnBasedMatchesCallback
|
typedef.std::function< void(const TurnBasedMatchesResponse &)>
Definiert einen Callback, der ein TurnBasedMatchesResponse aus einem der rundenbasierten Mehrspieleroperationen empfangen kann. |
Öffentliche statische Attribute |
|
---|---|
kAutomatchingParticipant
|
const MultiplayerParticipant
Ein Teilnehmer, der an Methoden übergeben werden kann, die einen "nächsten
Teilnehmende“.
|
Öffentliche Funktionen |
|
---|---|
AcceptInvitation(const MultiplayerInvitation & invitation, TurnBasedMatchCallback callback)
|
void
Nimmt
MultiplayerInvitation asynchron an und gibt das Ergebnis über TurnBasedMatchCallback zurück. |
AcceptInvitationBlocking(Timeout timeout, const MultiplayerInvitation & invitation)
|
Die Version von AcceptInvitation wird blockiert.
|
AcceptInvitationBlocking(const MultiplayerInvitation & invitation)
|
Überlastung von AcceptInvitationBlocking mit einem standardmäßigen Zeitlimit von 10 Jahren
|
CancelMatch(const TurnBasedMatch & match, MultiplayerStatusCallback callback)
|
void
Bricht eine Übereinstimmung asynchron ab.
|
CancelMatchBlocking(Timeout timeout, const TurnBasedMatch & match)
|
Version von CancelMatch wird blockiert.
|
CancelMatchBlocking(const TurnBasedMatch & match)
|
Überlastung von CancelMatch, das ein Standardzeitlimit von 10 Jahren verwendet.
|
ConfirmPendingCompletion(const TurnBasedMatch & match, TurnBasedMatchCallback callback)
|
void
Bestätigt die Ergebnisse einer bereits beendeten Spielrunde, die noch nicht lokal abgeschlossen wurde.
|
ConfirmPendingCompletionBlocking(Timeout timeout, const TurnBasedMatch & match)
|
Version von ConfirmPendingCompletion wird blockiert.
|
ConfirmPendingCompletionBlocking(const TurnBasedMatch & match)
|
Überlastung von ConfirmPendingCompletionBlocking mit einer Standardzeitüberschreitung von 10 Jahren.
|
CreateTurnBasedMatch(const gpg::TurnBasedMatchConfig & config, TurnBasedMatchCallback callback)
|
void
Erstellt mithilfe des angegebenen
TurnBasedMatchConfig asynchron ein TurnBasedMatch -Objekt. |
CreateTurnBasedMatchBlocking(Timeout timeout, const gpg::TurnBasedMatchConfig & config)
|
Diese Version von CreateTurnBasedMatch wird blockiert.
|
CreateTurnBasedMatchBlocking(const gpg::TurnBasedMatchConfig & config)
|
Überlastung von CreateTurnBasedMatchBlocking mit einer Standardzeitüberschreitung von 10 Jahren.
|
DeclineInvitation(const MultiplayerInvitation & invitation)
|
void
Lehnt einen
MultiplayerInvitation zu einem TurnBasedMatch ab. |
DismissInvitation(const MultiplayerInvitation & invitation)
|
void
Verwirft einen
MultiplayerInvitation in einen TurnBasedMatch . |
DismissMatch(const TurnBasedMatch & match)
|
void
Schließt ein
TurnBasedMatch . |
FetchMatch(const std::string & match_id, TurnBasedMatchCallback callback)
|
void
Ruft asynchron eine bestimmte Übereinstimmung nach ID ab
|
FetchMatchBlocking(Timeout timeout, const std::string & match_id)
|
Blockierende Version von FetchMatch.
|
FetchMatchBlocking(const std::string & match_id)
|
Überlastung von FetchMatchBlocking mit einer Standardzeitüberschreitung von 10 Jahren.
|
FetchMatches(TurnBasedMatchesCallback callback)
|
void
Ruft asynchron
TurnBasedMatch - und Invitation -Objekte für den aktuellen Spieler ab |
FetchMatchesBlocking(Timeout timeout)
|
Blockierende Version von FetchMatches.
|
FetchMatchesBlocking()
|
Überlastung von FetchMatchesBlocking mit einer Standardzeitüberschreitung von 10 Jahren.
|
FinishMatchDuringMyTurn(const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, TurnBasedMatchCallback callback)
|
void
Beendet die angegebene Übereinstimmung asynchron.
|
FinishMatchDuringMyTurnBlocking(Timeout timeout, const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results)
|
Version von FinishMatchDuringMyTurn wird blockiert.
|
FinishMatchDuringMyTurnBlocking(const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results)
|
Überlastung von FinishMatchDuringMyTurnBlocking mit einer Standardzeitüberschreitung von 10 Jahren.
|
LeaveMatchDuringMyTurn(const TurnBasedMatch & match, const MultiplayerParticipant & next_participant, MultiplayerStatusCallback callback)
|
void
Verlässt asynchron ein Spiel, während der lokale Teilnehmer an der Reihe ist.
|
LeaveMatchDuringMyTurnBlocking(Timeout timeout, const TurnBasedMatch & match, const MultiplayerParticipant & next_participant)
|
Die Version von LeaveMatchDuringMyTurn wird blockiert.
|
LeaveMatchDuringMyTurnBlocking(const TurnBasedMatch & match, const MultiplayerParticipant & next_participant)
|
Überlastung von LeaveMatchDuringMyTurnBlocking mit einem standardmäßigen Zeitlimit von 10 Jahren.
|
LeaveMatchDuringTheirTurn(const TurnBasedMatch & match, MultiplayerStatusCallback callback)
|
void
Beendet asynchron ein Spiel, während ein anderer Teilnehmer an der Reihe ist.
|
LeaveMatchDuringTheirTurnBlocking(Timeout timeout, const TurnBasedMatch & match)
|
Die Version von LeaveMatchDuringTheirTurn wird blockiert.
|
LeaveMatchDuringTheirTurnBlocking(const TurnBasedMatch & match)
|
Überlastung von LeaveMatchDuringTheirTurnBlocking mit einem standardmäßigen Zeitlimit von 10 Jahren.
|
Rematch(const TurnBasedMatch & match, TurnBasedMatchCallback callback)
|
void
Gleicht eine Übereinstimmung mit dem Status MatchStatus::COMPLETED noch einmal ab.
|
RematchBlocking(Timeout timeout, const TurnBasedMatch & match)
|
Die Version von Rematch wird blockiert.
|
RematchBlocking(const TurnBasedMatch & match)
|
Überlastung von RematchBlocking mit einem standardmäßigen Zeitlimit von 10 Jahren.
|
ShowMatchInboxUI(MatchInboxUICallback callback)
|
void
Zeigt asynchron die Benutzeroberfläche des Posteingangs für Spiele an, über die der Spieler ein Spiel oder eine Einladung auswählen kann.
|
ShowMatchInboxUIBlocking(Timeout timeout)
|
Version von ShowMatchInboxUI wird blockiert.
|
ShowMatchInboxUIBlocking()
|
Überlastung von ShowMatchInboxUIBlocking, die eine Standardzeitüberschreitung von 10 Jahren verwendet.
|
ShowPlayerSelectUI(uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch, PlayerSelectUICallback callback)
|
void
Zeigt asynchron die Benutzeroberfläche zur Spielerauswahl an, sodass der Spieler andere Spieler zum Spielen auswählen kann.
|
ShowPlayerSelectUIBlocking(Timeout timeout, uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch)
|
Version von ShowPlayerSelectUI wird blockiert.
|
ShowPlayerSelectUIBlocking(uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch)
|
Überlastung von ShowPlayerSelectUIBlocking, das eine Standardzeitüberschreitung von 10 Jahren verwendet.
|
SynchronizeData()
|
void
Erzwingt eine Synchronisierung der TBMP-Übereinstimmungsdaten mit dem Server.
|
TakeMyTurn(const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant, TurnBasedMatchCallback callback)
|
void
Nimmt asynchron den örtlichen Teilnehmer an der Reihe.
|
TakeMyTurnBlocking(Timeout timeout, const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant)
|
Version von TakeMyTurn wird blockiert.
|
TakeMyTurnBlocking(const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant)
|
Überlastung von TakeMyTurnBlocking mit einem standardmäßigen Zeitlimit von 10 Jahren.
|
Strukturen |
|
---|---|
gpg:: |
|
gpg:: |
|
gpg:: |
|
gpg:: |
|
Öffentliche Typen
MatchInboxUICallback
std::function< void(const MatchInboxUIResponse &)> MatchInboxUICallback
Definiert einen Callback, der einen MatchInboxUIResponse
von ShowMatchInboxUI
empfangen kann.
MultiplayerStatusCallback
std::function< void(MultiplayerStatus)> MultiplayerStatusCallback
Definiert einen Callback, mit dem ein MultiplayerStatus empfangen werden kann.
Wird von den Funktionen „LeaveMatch“ und „CancelMatch“ verwendet.
PlayerSelectUICallback
std::function< void(const PlayerSelectUIResponse &)> PlayerSelectUICallback
Definiert einen Callback, der einen PlayerSelectUIResponse
von ShowPlayerSelectUI
empfangen kann.
TurnBasedMatchCallback
std::function< void(const TurnBasedMatchResponse &)> TurnBasedMatchCallback
Definiert einen Callback, der verwendet werden kann, um ein TurnBasedMatchResponse
aus einem der rundenbasierten Mehrspieleroperationen zu empfangen.
TurnBasedMatchesCallback
std::function< void(const TurnBasedMatchesResponse &)> TurnBasedMatchesCallback
Definiert einen Callback, der ein TurnBasedMatchesResponse
aus einem der rundenbasierten Mehrspieleroperationen empfangen kann.
Öffentliche statische Attribute
kAutomatchingParticipant
const MultiplayerParticipant kAutomatchingParticipant
Ein Teilnehmer, der an Methoden übergeben werden kann, die einen "nächsten Teilnehmende“.
Dadurch wird über die automatische Zuordnung der nächste Teilnehmer ausgewählt. „kAutomatchingParticipant“ kann nur dann an eine Funktion übergeben werden, wenn TurnBasedMatch::AutomatchingSlotsAvailable für die entsprechende Übereinstimmung größer als 0 ist.
Öffentliche Funktionen
AcceptInvitation
void AcceptInvitation( const MultiplayerInvitation & invitation, TurnBasedMatchCallback callback )
Nimmt MultiplayerInvitation
asynchron an und gibt das Ergebnis über TurnBasedMatchCallback
zurück.
Wenn der Vorgang erfolgreich ist, hat die über den Callback zurückgegebene TurnBasedMatch
den Status TurnBasedMatchState::MY_TURN
.
AcceptInvitationBlocking
TurnBasedMatchResponse AcceptInvitationBlocking( Timeout timeout, const MultiplayerInvitation & invitation )
Die Version von AcceptInvitation wird blockiert.
Ermöglicht dem Aufrufer, ein Zeitlimit in ms anzugeben. Nach Ablauf der angegebenen Zeit gibt die Funktion ERROR_TIMEOUT
zurück.
AcceptInvitationBlocking
TurnBasedMatchResponse AcceptInvitationBlocking( const MultiplayerInvitation & invitation )
Überlastung von AcceptInvitationBlocking mit einem standardmäßigen Zeitlimit von 10 Jahren
CancelMatch
void CancelMatch( const TurnBasedMatch & match, MultiplayerStatusCallback callback )
Bricht eine Übereinstimmung asynchron ab.
Der über MultiplayerStatusCallback
zurückgegebene Status gibt an, ob der Vorgang erfolgreich war. Der Übereinstimmungsstatus muss EINLADEN, THEIR_TURN oder MY_TURN sein, damit diese Funktion verwendet werden kann.
CancelMatchBlocking
MultiplayerStatus CancelMatchBlocking( Timeout timeout, const TurnBasedMatch & match )
Version von CancelMatch wird blockiert.
Ermöglicht dem Aufrufer, ein Zeitlimit in ms anzugeben. Nach Ablauf der angegebenen Zeit gibt die Funktion ERROR_TIMEOUT
zurück.
CancelMatchBlocking
MultiplayerStatus CancelMatchBlocking( const TurnBasedMatch & match )
Überlastung von CancelMatch, das ein Standardzeitlimit von 10 Jahren verwendet.
ConfirmPendingCompletion
void ConfirmPendingCompletion( const TurnBasedMatch & match, TurnBasedMatchCallback callback )
Bestätigt die Ergebnisse einer bereits abgeschlossenen Übereinstimmung, die noch nicht lokal abgeschlossen wurde.
Diese Funktion kann nur aufgerufen werden, wenn TurnBasedMatch::Status()
MatchStatus::PENDING_COMPLETION
zurückgibt.
Details | |||||
---|---|---|---|---|---|
Parameter |
|
ConfirmPendingCompletionBlocking
TurnBasedMatchResponse ConfirmPendingCompletionBlocking( Timeout timeout, const TurnBasedMatch & match )
Version von ConfirmPendingCompletion wird blockiert.
Ermöglicht dem Aufrufer, ein Zeitlimit in ms anzugeben. Nach Ablauf der angegebenen Zeit gibt die Funktion ERROR_TIMEOUT
zurück.
ConfirmPendingCompletionBlocking
TurnBasedMatchResponse ConfirmPendingCompletionBlocking( const TurnBasedMatch & match )
Überlastung von ConfirmPendingCompletionBlocking mit einer Standardzeitüberschreitung von 10 Jahren.
CreateTurnBasedMatch
void CreateTurnBasedMatch( const gpg::TurnBasedMatchConfig & config, TurnBasedMatchCallback callback )
Erstellt mithilfe des angegebenen TurnBasedMatchConfig
asynchron ein TurnBasedMatch
-Objekt.
Wenn die Erstellung erfolgreich ist, gibt diese Funktion das TurnBasedMatch
über die angegebene TurnBasedMatchCallback
zurück. Eine neu erstellte TurnBasedMatch
beginnt immer mit dem Status TurnBasedMatchState::MY_TURN
.
CreateTurnBasedMatchBlocking
TurnBasedMatchResponse CreateTurnBasedMatchBlocking( Timeout timeout, const gpg::TurnBasedMatchConfig & config )
Diese Version von CreateTurnBasedMatch wird blockiert.
Ermöglicht dem Aufrufer, ein Zeitlimit in ms anzugeben. Nach Ablauf der angegebenen Zeit gibt die Funktion ERROR_TIMEOUT
zurück.
CreateTurnBasedMatchBlocking
TurnBasedMatchResponse CreateTurnBasedMatchBlocking( const gpg::TurnBasedMatchConfig & config )
Überlastung von CreateTurnBasedMatchBlocking mit einer Standardzeitüberschreitung von 10 Jahren.
DeclineInvitation
void DeclineInvitation( const MultiplayerInvitation & invitation )
Lehnt einen MultiplayerInvitation
zu einem TurnBasedMatch
ab.
Dadurch wird das Spiel für die anderen Teilnehmer abgebrochen und vom Gerät des lokalen Spielers entfernt.
DismissInvitation
void DismissInvitation( const MultiplayerInvitation & invitation )
Verwirft einen MultiplayerInvitation
in einen TurnBasedMatch
.
Dadurch wird der sichtbare Status von TurnBasedMatch
für die anderen Teilnehmer nicht geändert, aber TurnBasedMatch
wird vom Gerät des lokalen Players entfernt.
DismissMatch
void DismissMatch( const TurnBasedMatch & match )
Schließt ein TurnBasedMatch
.
Dadurch wird der sichtbare Status von TurnBasedMatch
für die anderen Teilnehmer nicht geändert, aber TurnBasedMatch
wird vom Gerät des lokalen Players entfernt.
FetchMatch
void FetchMatch( const std::string & match_id, TurnBasedMatchCallback callback )
Ruft asynchron eine bestimmte Übereinstimmung nach ID ab
Das Ergebnis dieses Vorgangs wird über TurnBasedMatchCallback
zurückgegeben.
FetchMatchBlocking
TurnBasedMatchResponse FetchMatchBlocking( Timeout timeout, const std::string & match_id )
Blockierende Version von FetchMatch.
Ermöglicht dem Aufrufer, ein Zeitlimit in ms anzugeben. Nach Ablauf der angegebenen Zeit gibt die Funktion ERROR_TIMEOUT
zurück.
FetchMatchBlocking
TurnBasedMatchResponse FetchMatchBlocking( const std::string & match_id )
Überlastung von FetchMatchBlocking mit einer Standardzeitüberschreitung von 10 Jahren.
FetchMatches
void FetchMatches( TurnBasedMatchesCallback callback )
Ruft asynchron TurnBasedMatch
- und Invitation
-Objekte für den aktuellen Spieler ab
Es werden alle aktiven und bis zu zehn abgeschlossenen Übereinstimmungen zurückgegeben.
FetchMatchesBlocking
TurnBasedMatchesResponse FetchMatchesBlocking( Timeout timeout )
Blockierende Version von FetchMatches.
Ermöglicht dem Aufrufer, ein Zeitlimit in ms anzugeben. Nach Ablauf der angegebenen Zeit gibt die Funktion ERROR_TIMEOUT
zurück.
FetchMatchesBlocking
TurnBasedMatchesResponse FetchMatchesBlocking()
Überlastung von FetchMatchesBlocking mit einer Standardzeitüberschreitung von 10 Jahren.
FinishMatchDuringMyTurn
void FinishMatchDuringMyTurn( const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, TurnBasedMatchCallback callback )
Beendet die angegebene Übereinstimmung asynchron.
Diese Funktion kann in der letzten Runde des Spiels statt TakeMyTurn verwendet werden. Ermöglicht dem Aufrufer, einen Endwert für match_data
sowie eine Reihe von Endwerten für ParticipantResults
anzugeben. Nach Abschluss dieses Vorgangs wird die aktualisierte Übereinstimmung über die bereitgestellte TurnBasedMatchCallback.
zurückgegeben. Diese Funktion kann nur aufgerufen werden, wenn TurnBasedMatch::Status()
den Wert MatchStatus::MY_TURN.
zurückgibt.
Details | |||||||||
---|---|---|---|---|---|---|---|---|---|
Parameter |
|
FinishMatchDuringMyTurnBlocking
TurnBasedMatchResponse FinishMatchDuringMyTurnBlocking( Timeout timeout, const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results )
Version von FinishMatchDuringMyTurn wird blockiert.
Ermöglicht dem Aufrufer, ein Zeitlimit in ms anzugeben. Nach Ablauf der angegebenen Zeit gibt die Funktion ERROR_TIMEOUT
zurück.
FinishMatchDuringMyTurnBlocking
TurnBasedMatchResponse FinishMatchDuringMyTurnBlocking( const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results )
Überlastung von FinishMatchDuringMyTurnBlocking mit einer Standardzeitüberschreitung von 10 Jahren.
LeaveMatchDuringMyTurn
void LeaveMatchDuringMyTurn( const TurnBasedMatch & match, const MultiplayerParticipant & next_participant, MultiplayerStatusCallback callback )
Verlässt asynchron ein Spiel, während der lokale Teilnehmer an der Reihe ist.
Die über TurnBasedMatchCallback
zurückgegebene Antwort enthält den Status des Spiels, nachdem der lokale Spieler gegangen ist. Wenn bei dieser Abfahrt das Spiel mit weniger als zwei Teilnehmern endet, wird das Spiel abgebrochen. match.Status()
muss MatchStatus::MY_TURN
zurückgeben, damit diese Funktion verwendet werden kann.
Details | |||||||
---|---|---|---|---|---|---|---|
Parameter |
|
LeaveMatchDuringMyTurnBlocking
MultiplayerStatus LeaveMatchDuringMyTurnBlocking( Timeout timeout, const TurnBasedMatch & match, const MultiplayerParticipant & next_participant )
Die Version von LeaveMatchDuringMyTurn wird blockiert.
Ermöglicht dem Aufrufer, ein Zeitlimit in ms anzugeben. Nach Ablauf der angegebenen Zeit gibt die Funktion ERROR_TIMEOUT
zurück.
LeaveMatchDuringMyTurnBlocking
MultiplayerStatus LeaveMatchDuringMyTurnBlocking( const TurnBasedMatch & match, const MultiplayerParticipant & next_participant )
Überlastung von LeaveMatchDuringMyTurnBlocking mit einem standardmäßigen Zeitlimit von 10 Jahren.
LeaveMatchDuringTheirTurn
void LeaveMatchDuringTheirTurn( const TurnBasedMatch & match, MultiplayerStatusCallback callback )
Beendet asynchron ein Spiel, während ein anderer Teilnehmer an der Reihe ist.
Die über MultiplayerStatusCallback
zurückgegebene Antwort enthält, ob der lokale Teilnehmer das Spiel erfolgreich verlassen hat. Wenn bei dieser Abfahrt das Spiel mit weniger als zwei Teilnehmern endet, wird das Spiel abgebrochen. match.Status()
muss MatchStatus::THEIR_TURN
zurückgeben, damit diese Funktion verwendet werden kann.
LeaveMatchDuringTheirTurnBlocking
MultiplayerStatus LeaveMatchDuringTheirTurnBlocking( Timeout timeout, const TurnBasedMatch & match )
Die Version von LeaveMatchDuringTheirTurn wird blockiert.
Ermöglicht dem Aufrufer, ein Zeitlimit in ms anzugeben. Nach Ablauf der angegebenen Zeit gibt die Funktion ERROR_TIMEOUT
zurück.
LeaveMatchDuringTheirTurnBlocking
MultiplayerStatus LeaveMatchDuringTheirTurnBlocking( const TurnBasedMatch & match )
Überlastung von LeaveMatchDuringTheirTurnBlocking mit einem standardmäßigen Zeitlimit von 10 Jahren.
Revanche
void Rematch( const TurnBasedMatch & match, TurnBasedMatchCallback callback )
Gleicht eine Übereinstimmung mit dem Status MatchStatus::COMPLETED noch einmal ab.
Wenn eine Revanche möglich ist, erhält TurnBasedMatchCallback
die neue Übereinstimmung.
Details | |||||
---|---|---|---|---|---|
Parameter |
|
RematchBlocking
TurnBasedMatchResponse RematchBlocking( Timeout timeout, const TurnBasedMatch & match )
Die Version von Rematch wird blockiert.
Ermöglicht dem Aufrufer, ein Zeitlimit in ms anzugeben. Nach Ablauf der angegebenen Zeit gibt die Funktion ERROR_TIMEOUT
zurück.
RematchBlocking
TurnBasedMatchResponse RematchBlocking( const TurnBasedMatch & match )
Überlastung von RematchBlocking mit einem standardmäßigen Zeitlimit von 10 Jahren.
ShowMatchInboxUI
void ShowMatchInboxUI( MatchInboxUICallback callback )
Zeigt asynchron die Benutzeroberfläche des Posteingangs für Spiele an, über die der Spieler ein Spiel oder eine Einladung auswählen kann.
Nach Abschluss wird die ausgewählte Übereinstimmung oder Einladung über MatchInboxUICallback
zurückgegeben.
ShowMatchInboxUIBlocking
MatchInboxUIResponse ShowMatchInboxUIBlocking( Timeout timeout )
Version von ShowMatchInboxUI wird blockiert.
Ermöglicht dem Aufrufer, ein Zeitlimit in ms anzugeben. Nach Ablauf der angegebenen Zeit gibt die Funktion ERROR_TIMEOUT
zurück.
ShowMatchInboxUIBlocking
MatchInboxUIResponse ShowMatchInboxUIBlocking()
Überlastung von ShowMatchInboxUIBlocking, das eine Standardzeitüberschreitung von 10 Jahren verwendet.
ShowPlayerSelectUI
void ShowPlayerSelectUI( uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch, PlayerSelectUICallback callback )
Zeigt asynchron die Benutzeroberfläche zur Spielerauswahl an, sodass der Spieler andere Spieler zum Spielen auswählen kann.
Nach Abschluss werden die ausgewählten Spieler über PlayerSelectUICallback
zurückgegeben.
ShowPlayerSelectUIBlocking
PlayerSelectUIResponse ShowPlayerSelectUIBlocking( Timeout timeout, uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch )
Version von ShowPlayerSelectUI wird blockiert.
Ermöglicht dem Aufrufer, ein Zeitlimit in ms anzugeben. Nach Ablauf der angegebenen Zeit gibt die Funktion ERROR_TIMEOUT
zurück.
ShowPlayerSelectUIBlocking
PlayerSelectUIResponse ShowPlayerSelectUIBlocking( uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch )
Überlastung von ShowPlayerSelectUIBlocking, das eine Standardzeitüberschreitung von 10 Jahren verwendet.
SynchronizeData
void SynchronizeData()
Erzwingt eine Synchronisierung der TBMP-Übereinstimmungsdaten mit dem Server.
Der Eingang neuer Daten löst ein OnTurnBasedMatchEventCallback
- oder OnMultiplayerInvitationReceivedCallback
-Objekt aus.
TakeMyTurn
void TakeMyTurn( const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant, TurnBasedMatchCallback callback )
Nimmt asynchron den örtlichen Teilnehmer an der Reihe.
Wenn der Teilnehmer am Zug ist, kann er einen neuen Wert für match_data
sowie einen Satz von ParticipantResults
angeben. Wenn der Zug vorbei ist, wird die aktualisierte Übereinstimmung über TurnBasedMatchCallback
zurückgegeben. Diese Funktion kann nur aufgerufen werden, wenn TurnBasedMatch::Status()
gleich MatchStatus::MY_TURN
ist.
Details | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Parameter |
|
TakeMyTurnBlocking
TurnBasedMatchResponse TakeMyTurnBlocking( Timeout timeout, const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant )
Version von TakeMyTurn wird blockiert.
Ermöglicht dem Aufrufer, ein Zeitlimit in ms anzugeben. Nach Ablauf der angegebenen Zeit gibt die Funktion ERROR_TIMEOUT
zurück.
TakeMyTurnBlocking
TurnBasedMatchResponse TakeMyTurnBlocking( const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant )
Überlastung von TakeMyTurnBlocking mit einem standardmäßigen Zeitlimit von 10 Jahren.