gpg:: TurnBasedMultiplayerManager
#include <turn_based_multiplayer_manager.h>
Ruft TurnBasedMatch
-Objekte ab, ändert und erstellt sie.
Zusammenfassung
Öffentliche Typen |
|
---|---|
MatchInboxUICallback
|
typedefstd::function< void(const MatchInboxUIResponse &)>
Definiert einen Callback, der einen MatchInboxUIResponse von ShowMatchInboxUI empfangen kann. |
MultiplayerStatusCallback
|
typedefstd::function< void(MultiplayerStatus)>
Definiert einen Callback, der für den Empfang eines MultiplayerStatus verwendet werden kann. |
PlayerSelectUICallback
|
typedefstd::function< void(const PlayerSelectUIResponse &)>
Definiert einen Callback, der einen PlayerSelectUIResponse von ShowPlayerSelectUI empfangen kann. |
TurnBasedMatchCallback
|
typedefstd::function< void(const TurnBasedMatchResponse &)>
Definiert einen Callback, mit dem ein TurnBasedMatchResponse von einem der rundenbasierten Multiplayer-Vorgänge empfangen werden kann. |
TurnBasedMatchesCallback
|
typedefstd::function< void(const TurnBasedMatchesResponse &)>
Definiert einen Callback, der ein TurnBasedMatchesResponse von einem der rundenbasierten Multiplayer-Vorgänge empfangen kann. |
Öffentliche statische Attribute |
|
---|---|
kAutomatchingParticipant
|
const MultiplayerParticipant
Ein Teilnehmer, der an Methoden übergeben werden kann, die einen "nächsten Teilnehmer" übernehmen.
|
Öffentliche Funktionen |
|
---|---|
AcceptInvitation(const MultiplayerInvitation & invitation, TurnBasedMatchCallback callback)
|
void
Akzeptiert asynchron einen
MultiplayerInvitation und gibt das Ergebnis über einen TurnBasedMatchCallback zurück. |
AcceptInvitationBlocking(Timeout timeout, const MultiplayerInvitation & invitation)
|
Blockierende Version von AcceptInvitation
|
AcceptInvitationBlocking(const MultiplayerInvitation & invitation)
|
Eine Überlastung von AcceptInvitationBlocking, das ein Standardzeitlimit von 10 Jahren verwendet.
|
CancelMatch(const TurnBasedMatch & match, MultiplayerStatusCallback callback)
|
void
Bricht eine Zuordnung asynchron ab.
|
CancelMatchBlocking(Timeout timeout, const TurnBasedMatch & match)
|
Blockierende Version von CancelMatch.
|
CancelMatchBlocking(const TurnBasedMatch & match)
|
Überlastung von CancelMatch, die ein Standardzeitlimit von 10 Jahren verwendet.
|
ConfirmPendingCompletion(const TurnBasedMatch & match, TurnBasedMatchCallback callback)
|
void
Bestätigt die Ergebnisse einer beendeten Zuordnung, deren lokaler Abschluss noch aussteht.
|
ConfirmPendingCompletionBlocking(Timeout timeout, const TurnBasedMatch & match)
|
Version von ConfirmPendingCompletion wird blockiert.
|
ConfirmPendingCompletionBlocking(const TurnBasedMatch & match)
|
Überlastung von ConfirmPendingCompletionBlocking, wofür ein Standardzeitlimit von 10 Jahren verwendet wird.
|
CreateTurnBasedMatch(const gpg::TurnBasedMatchConfig & config, TurnBasedMatchCallback callback)
|
void
Erstellt asynchron ein
TurnBasedMatch mithilfe des angegebenen TurnBasedMatchConfig . |
CreateTurnBasedMatchBlocking(Timeout timeout, const gpg::TurnBasedMatchConfig & config)
|
Blockierende Version von CreateTurnBasedMatch.
|
CreateTurnBasedMatchBlocking(const gpg::TurnBasedMatchConfig & config)
|
Überlastung von CreateTurnBasedMatchBlocking, das ein Standardzeitlimit von 10 Jahren verwendet.
|
DeclineInvitation(const MultiplayerInvitation & invitation)
|
void
Lehnt einen
MultiplayerInvitation zu einem TurnBasedMatch ab. |
DismissInvitation(const MultiplayerInvitation & invitation)
|
void
Schließt einen
MultiplayerInvitation zu einem TurnBasedMatch . |
DismissMatch(const TurnBasedMatch & match)
|
void
Schließt
TurnBasedMatch . |
FetchMatch(const std::string & match_id, TurnBasedMatchCallback callback)
|
void
Ruft eine bestimmte Übereinstimmung asynchron anhand der ID ab
|
FetchMatchBlocking(Timeout timeout, const std::string & match_id)
|
Blockierende Version von FetchMatch
|
FetchMatchBlocking(const std::string & match_id)
|
Überlastung von FetchMatchBlocking, das ein Standardzeitlimit von 10 Jahren verwendet.
|
FetchMatches(TurnBasedMatchesCallback callback)
|
void
Ruft die Objekte
TurnBasedMatch und Invitation asynchron für den aktuellen Spieler ab. |
FetchMatchesBlocking(Timeout timeout)
|
Blockierende Version von FetchMatches.
|
FetchMatchesBlocking()
|
Überlastung von FetchMatchesBlocking, das ein Standardzeitlimit von 10 Jahren verwendet.
|
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)
|
Blockierende Version von FinishMatchDuringMyTurn.
|
FinishMatchDuringMyTurnBlocking(const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results)
|
Überlastung von FinishMatchDuringMyTurnBlocking, das ein Standardzeitlimit von 10 Jahren verwendet.
|
LeaveMatchDuringMyTurn(const TurnBasedMatch & match, const MultiplayerParticipant & next_participant, MultiplayerStatusCallback callback)
|
void
Beendet ein Spiel asynchron, während der lokale Teilnehmer an der Reihe ist.
|
LeaveMatchDuringMyTurnBlocking(Timeout timeout, const TurnBasedMatch & match, const MultiplayerParticipant & next_participant)
|
Blockierende Version von LeaveMatchDuringMyTurn.
|
LeaveMatchDuringMyTurnBlocking(const TurnBasedMatch & match, const MultiplayerParticipant & next_participant)
|
Überlastung von LeaveMatchDuringMyTurnBlocking, das ein Standardzeitlimit von 10 Jahren verwendet.
|
LeaveMatchDuringTheirTurn(const TurnBasedMatch & match, MultiplayerStatusCallback callback)
|
void
Beendet ein Spiel asynchron, während ein anderer Teilnehmer an der Reihe ist.
|
LeaveMatchDuringTheirTurnBlocking(Timeout timeout, const TurnBasedMatch & match)
|
Blockierende Version von LeaveMatchDuringTheirTurn.
|
LeaveMatchDuringTheirTurnBlocking(const TurnBasedMatch & match)
|
Überlastung von LeaveMatchDuringTheirTurnBlocking, das ein Standardzeitlimit von 10 Jahren verwendet.
|
Rematch(const TurnBasedMatch & match, TurnBasedMatchCallback callback)
|
void
Gibt eine Übereinstimmung mit dem Status MatchStatus::COMPLETED wieder.
|
RematchBlocking(Timeout timeout, const TurnBasedMatch & match)
|
Blockierende Version von Rematch
|
RematchBlocking(const TurnBasedMatch & match)
|
Überlastung von RematchBlocking, das ein Standardzeitlimit von 10 Jahren verwendet.
|
ShowMatchInboxUI(MatchInboxUICallback callback)
|
void
Zeigt asynchron die Benutzeroberfläche des Spiel-Posteingangs an, über die der Spieler ein Spiel oder eine Einladung auswählen kann
|
ShowMatchInboxUIBlocking(Timeout timeout)
|
Blockierende Version von ShowMatchInboxUI
|
ShowMatchInboxUIBlocking()
|
Überlastung von ShowMatchInboxUIBlocking, das ein Standardzeitlimit von 10 Jahren verwendet.
|
ShowPlayerSelectUI(uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch, PlayerSelectUICallback callback)
|
void
Zeigt die Benutzeroberfläche zur Spielerauswahl asynchron 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)
|
Blockierende Version von ShowPlayerSelectUI
|
ShowPlayerSelectUIBlocking(uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch)
|
Überlastung von ShowPlayerSelectUIBlocking, das ein Standardzeitlimit 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 an der Reihe der lokalen Teilnehmer.
|
TakeMyTurnBlocking(Timeout timeout, const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant)
|
Blockierende Version von TakeMyTurn.
|
TakeMyTurnBlocking(const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant)
|
Überlastung von TakeMyTurnBlocking, das ein Standardzeitlimit von 10 Jahren verwendet.
|
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, der für den Empfang eines MultiplayerStatus verwendet 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, mit dem ein TurnBasedMatchResponse
von einem der rundenbasierten Multiplayer-Vorgänge empfangen werden kann.
TurnBasedMatchesCallback
std::function< void(const TurnBasedMatchesResponse &)> TurnBasedMatchesCallback
Definiert einen Callback, der ein TurnBasedMatchesResponse
von einem der rundenbasierten Multiplayer-Vorgänge empfangen kann.
Öffentliche statische Attribute
kAutomatchingParticipant
const MultiplayerParticipant kAutomatchingParticipant
Ein Teilnehmer, der an Methoden übergeben werden kann, die einen "nächsten Teilnehmer" übernehmen.
Dadurch wird mit der Methode der nächste Teilnehmer per automatischer Zuordnung ausgewählt. kAutomatchingSubscriber kann nur dann an eine Funktion übergeben werden, wenn TurnBasedMatch::AutomatchingSlotsAvailable für die zugehörige Übereinstimmung größer als 0 ist.
Öffentliche Funktionen
AcceptInvitation
void AcceptInvitation( const MultiplayerInvitation & invitation, TurnBasedMatchCallback callback )
Akzeptiert asynchron einen MultiplayerInvitation
und gibt das Ergebnis über einen TurnBasedMatchCallback
zurück.
Wenn der Vorgang erfolgreich ist, hat das über den Callback zurückgegebene TurnBasedMatch
den Status TurnBasedMatchState::MY_TURN
.
AcceptInvitationBlocking
TurnBasedMatchResponse AcceptInvitationBlocking( Timeout timeout, const MultiplayerInvitation & invitation )
Blockierende Version von AcceptInvitation
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 )
Eine Überlastung von AcceptInvitationBlocking, das ein Standardzeitlimit von 10 Jahren verwendet.
CancelMatch
void CancelMatch( const TurnBasedMatch & match, MultiplayerStatusCallback callback )
Bricht eine Zuordnung asynchron ab.
Der über MultiplayerStatusCallback
zurückgegebene Status gibt an, ob der Vorgang erfolgreich war. Damit diese Funktion genutzt werden kann, muss der Abgleichsstatus INVITATIOND, THEIR_TURN oder MY_TURN sein.
CancelMatchBlocking
MultiplayerStatus CancelMatchBlocking( Timeout timeout, const TurnBasedMatch & match )
Blockierende Version von CancelMatch.
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, die ein Standardzeitlimit von 10 Jahren verwendet.
ConfirmPendingCompletion
void ConfirmPendingCompletion( const TurnBasedMatch & match, TurnBasedMatchCallback callback )
Bestätigt die Ergebnisse einer beendeten Zuordnung, deren lokaler Abschluss noch aussteht.
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, wofür ein Standardzeitlimit von 10 Jahren verwendet wird.
CreateTurnBasedMatch
void CreateTurnBasedMatch( const gpg::TurnBasedMatchConfig & config, TurnBasedMatchCallback callback )
Erstellt asynchron ein TurnBasedMatch
mithilfe des angegebenen TurnBasedMatchConfig
.
Wenn die Erstellung erfolgreich war, gibt diese Funktion TurnBasedMatch
über die angegebene TurnBasedMatchCallback
zurück. Eine neu erstellte TurnBasedMatch
beginnt immer im Status TurnBasedMatchState::MY_TURN
.
CreateTurnBasedMatchBlocking
TurnBasedMatchResponse CreateTurnBasedMatchBlocking( Timeout timeout, const gpg::TurnBasedMatchConfig & config )
Blockierende Version von CreateTurnBasedMatch.
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, das ein Standardzeitlimit von 10 Jahren verwendet.
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 )
Schließt einen MultiplayerInvitation
zu einem TurnBasedMatch
.
Dadurch wird der sichtbare Status von TurnBasedMatch
für die anderen Teilnehmer nicht geändert, sondern das TurnBasedMatch
vom Gerät des lokalen Players entfernt.
DismissMatch
void DismissMatch( const TurnBasedMatch & match )
Schließt TurnBasedMatch
.
Dadurch wird der sichtbare Status von TurnBasedMatch
für die anderen Teilnehmer nicht geändert, sondern das TurnBasedMatch
vom Gerät des lokalen Players entfernt.
FetchMatch
void FetchMatch( const std::string & match_id, TurnBasedMatchCallback callback )
Ruft eine bestimmte Übereinstimmung asynchron anhand der 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, das ein Standardzeitlimit von 10 Jahren verwendet.
FetchMatches
void FetchMatches( TurnBasedMatchesCallback callback )
Ruft die Objekte TurnBasedMatch
und Invitation
asynchron für den aktuellen Spieler ab.
Alle aktiven Übereinstimmungen und bis zu zehn abgeschlossene Übereinstimmungen werden 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, das ein Standardzeitlimit von 10 Jahren verwendet.
FinishMatchDuringMyTurn
void FinishMatchDuringMyTurn( const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, TurnBasedMatchCallback callback )
Beendet die angegebene Übereinstimmung asynchron.
Diese kann statt TakeMyTurn beim letzten Zug des Spiels verwendet werden. Ermöglicht dem Aufrufer, einen endgültigen Wert für match_data
sowie einen Satz endgültiger Werte für ParticipantResults
anzugeben. Nach Abschluss dieses Vorgangs wird die aktualisierte Übereinstimmung über den bereitgestellten 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 )
Blockierende Version von FinishMatchDuringMyTurn.
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, das ein Standardzeitlimit von 10 Jahren verwendet.
LeaveMatchDuringMyTurn
void LeaveMatchDuringMyTurn( const TurnBasedMatch & match, const MultiplayerParticipant & next_participant, MultiplayerStatusCallback callback )
Beendet ein Spiel asynchron, 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 diese Abreise das Spiel mit weniger als zwei Teilnehmern verlässt, wird das Spiel abgesagt. 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 )
Blockierende Version von LeaveMatchDuringMyTurn.
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, das ein Standardzeitlimit von 10 Jahren verwendet.
LeaveMatchDuringTheirTurn
void LeaveMatchDuringTheirTurn( const TurnBasedMatch & match, MultiplayerStatusCallback callback )
Beendet ein Spiel asynchron, während ein anderer Teilnehmer an der Reihe ist.
Die über MultiplayerStatusCallback
zurückgegebene Antwort gibt an, ob der lokale Teilnehmer das Spiel erfolgreich verlassen hat. Wenn diese Abreise das Spiel mit weniger als zwei Teilnehmern verlässt, wird das Spiel abgesagt. match.Status()
muss MatchStatus::THEIR_TURN
zurückgeben, damit diese Funktion verwendet werden kann.
LeaveMatchDuringTheirTurnBlocking
MultiplayerStatus LeaveMatchDuringTheirTurnBlocking( Timeout timeout, const TurnBasedMatch & match )
Blockierende Version von LeaveMatchDuringTheirTurn.
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, das ein Standardzeitlimit von 10 Jahren verwendet.
Revanche
void Rematch( const TurnBasedMatch & match, TurnBasedMatchCallback callback )
Gibt eine Übereinstimmung mit dem Status MatchStatus::COMPLETED wieder.
Wenn eine Revanche möglich ist, erhält TurnBasedMatchCallback
die neue Übereinstimmung.
Details | |||||
---|---|---|---|---|---|
Parameter |
|
RematchBlocking
TurnBasedMatchResponse RematchBlocking( Timeout timeout, const TurnBasedMatch & match )
Blockierende Version von Rematch
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, das ein Standardzeitlimit von 10 Jahren verwendet.
ShowMatchInboxUI
void ShowMatchInboxUI( MatchInboxUICallback callback )
Zeigt asynchron die Benutzeroberfläche des Spiel-Posteingangs an, über die der Spieler ein Spiel oder eine Einladung auswählen kann
Nach Abschluss wird das ausgewählte Spiel oder die ausgewählte Einladung über MatchInboxUICallback
zurückgegeben.
ShowMatchInboxUIBlocking
MatchInboxUIResponse ShowMatchInboxUIBlocking( Timeout timeout )
Blockierende Version von ShowMatchInboxUI
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 ein Standardzeitlimit von 10 Jahren verwendet.
ShowPlayerSelectUI
void ShowPlayerSelectUI( uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch, PlayerSelectUICallback callback )
Zeigt die Benutzeroberfläche zur Spielerauswahl asynchron 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 )
Blockierende Version von ShowPlayerSelectUI
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 ein Standardzeitlimit von 10 Jahren verwendet.
SynchronizeData
void SynchronizeData()
Erzwingt eine Synchronisierung der TBMP-Übereinstimmungsdaten mit dem Server.
Der Erhalt neuer Daten löst einen OnTurnBasedMatchEventCallback
oder OnMultiplayerInvitationReceivedCallback
aus.
TakeMyTurn
void TakeMyTurn( const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant, TurnBasedMatchCallback callback )
Nimmt asynchron an der Reihe der lokalen Teilnehmer.
Wenn er an der Reihe ist, kann der Teilnehmer einen neuen Wert für match_data
sowie einen Satz von ParticipantResults
angeben. Wenn der Zug vorbei ist, wird die aktualisierte Übereinstimmung über die TurnBasedMatchCallback
zurückgegeben. Diese Funktion kann nur aufgerufen werden, wenn TurnBasedMatch::Status()
den Wert MatchStatus::MY_TURN
hat.
Details | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Parameter |
|
TakeMyTurnBlocking
TurnBasedMatchResponse TakeMyTurnBlocking( Timeout timeout, const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant )
Blockierende Version von TakeMyTurn.
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, das ein Standardzeitlimit von 10 Jahren verwendet.