gpg:: TurnBasedMultiplayerManager
#include <turn_based_multiplayer_manager.h>
Recupera, modifica e crea TurnBasedMatch
oggetti.
Riepilogo
Tipi pubblici |
|
---|---|
MatchInboxUICallback
|
typedefstd::function< void(const MatchInboxUIResponse &)>
Definisce un callback che può ricevere un MatchInboxUIResponse da ShowMatchInboxUI . |
MultiplayerStatusCallback
|
typedefstd::function< void(MultiplayerStatus)>
Definisce un callback che può essere utilizzato per ricevere un MultiplayerStatus. |
PlayerSelectUICallback
|
typedefstd::function< void(const PlayerSelectUIResponse &)>
Definisce un callback che può ricevere un PlayerSelectUIResponse da ShowPlayerSelectUI . |
TurnBasedMatchCallback
|
typedefstd::function< void(const TurnBasedMatchResponse &)>
Definisce un callback che può essere utilizzato per ricevere un TurnBasedMatchResponse da una delle operazioni multiplayer a turni. |
TurnBasedMatchesCallback
|
typedefstd::function< void(const TurnBasedMatchesResponse &)>
Definisce un callback che può ricevere un TurnBasedMatchesResponse da una delle operazioni multiplayer a turni. |
Attributi statici pubblici |
|
---|---|
kAutomatchingParticipant
|
const MultiplayerParticipant
Un partecipante che può essere trasmesso a metodi che accettano un "partecipante successivo".
|
Funzioni pubbliche |
|
---|---|
AcceptInvitation(const MultiplayerInvitation & invitation, TurnBasedMatchCallback callback)
|
void
Accetta in modo asincrono un valore
MultiplayerInvitation e restituisce il risultato tramite TurnBasedMatchCallback . |
AcceptInvitationBlocking(Timeout timeout, const MultiplayerInvitation & invitation)
|
Blocco della versione di AcceptInvitation.
|
AcceptInvitationBlocking(const MultiplayerInvitation & invitation)
|
Sovraccarico di AcceptInvitationBlocking, che utilizza un timeout predefinito di 10 anni.
|
CancelMatch(const TurnBasedMatch & match, MultiplayerStatusCallback callback)
|
void
Annulla una corrispondenza in modo asincrono.
|
CancelMatchBlocking(Timeout timeout, const TurnBasedMatch & match)
|
Blocco della versione di CancelMatch.
|
CancelMatchBlocking(const TurnBasedMatch & match)
|
Sovraccarico di CancelMatch che utilizza un timeout predefinito di 10 anni.
|
ConfirmPendingCompletion(const TurnBasedMatch & match, TurnBasedMatchCallback callback)
|
void
Conferma i risultati di una partita terminata in attesa del completamento locale.
|
ConfirmPendingCompletionBlocking(Timeout timeout, const TurnBasedMatch & match)
|
Versione di blocco di ConfirmPendingCompletion.
|
ConfirmPendingCompletionBlocking(const TurnBasedMatch & match)
|
Sovraccarico di ConfirmPendingCompletionBlocking, che utilizza un timeout predefinito di 10 anni.
|
CreateTurnBasedMatch(const gpg::TurnBasedMatchConfig & config, TurnBasedMatchCallback callback)
|
void
Crea in modo asincrono un
TurnBasedMatch utilizzando il metodo TurnBasedMatchConfig fornito. |
CreateTurnBasedMatchBlocking(Timeout timeout, const gpg::TurnBasedMatchConfig & config)
|
Blocco della versione di CreateTurnBasedMatch.
|
CreateTurnBasedMatchBlocking(const gpg::TurnBasedMatchConfig & config)
|
Sovraccarico di CreateTurnBasedMatchBlocking, che utilizza un timeout predefinito di 10 anni.
|
DeclineInvitation(const MultiplayerInvitation & invitation)
|
void
Rifiuta un
MultiplayerInvitation a un TurnBasedMatch . |
DismissInvitation(const MultiplayerInvitation & invitation)
|
void
Ignora
MultiplayerInvitation in TurnBasedMatch . |
DismissMatch(const TurnBasedMatch & match)
|
void
Ignora
TurnBasedMatch . |
FetchMatch(const std::string & match_id, TurnBasedMatchCallback callback)
|
void
Recupera in modo asincrono una corrispondenza specifica per ID.
|
FetchMatchBlocking(Timeout timeout, const std::string & match_id)
|
Blocco della versione di FetchMatch.
|
FetchMatchBlocking(const std::string & match_id)
|
Sovraccarico di FetchMatchBlocking, che utilizza un timeout predefinito di 10 anni.
|
FetchMatches(TurnBasedMatchesCallback callback)
|
void
Recupera in modo asincrono gli oggetti
TurnBasedMatch e Invitation per il player corrente. |
FetchMatchesBlocking(Timeout timeout)
|
Blocco della versione di FetchMatches.
|
FetchMatchesBlocking()
|
Sovraccarico di FetchMatchesBlocking, che utilizza un timeout predefinito di 10 anni.
|
FinishMatchDuringMyTurn(const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, TurnBasedMatchCallback callback)
|
void
Termina in modo asincrono la corrispondenza specificata.
|
FinishMatchDuringMyTurnBlocking(Timeout timeout, const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results)
|
Blocco della versione di FinishMatchDuringMyTurn.
|
FinishMatchDuringMyTurnBlocking(const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results)
|
Sovraccarico di FinishMatchDuringMyTurnBlocking, che utilizza un timeout predefinito di 10 anni.
|
LeaveMatchDuringMyTurn(const TurnBasedMatch & match, const MultiplayerParticipant & next_participant, MultiplayerStatusCallback callback)
|
void
Abbandono in modo asincrono una corrispondenza durante il turno del partecipante locale.
|
LeaveMatchDuringMyTurnBlocking(Timeout timeout, const TurnBasedMatch & match, const MultiplayerParticipant & next_participant)
|
Blocco della versione di LeaveMatchDuringMyTurn.
|
LeaveMatchDuringMyTurnBlocking(const TurnBasedMatch & match, const MultiplayerParticipant & next_participant)
|
Sovraccarico di LeaveMatchDuringMyTurnBlocking e usa un timeout predefinito di 10 anni.
|
LeaveMatchDuringTheirTurn(const TurnBasedMatch & match, MultiplayerStatusCallback callback)
|
void
Abbandono in modo asincrono una partita durante il turno di un altro partecipante.
|
LeaveMatchDuringTheirTurnBlocking(Timeout timeout, const TurnBasedMatch & match)
|
Blocco della versione di LeaveMatchDuringTheirTurn.
|
LeaveMatchDuringTheirTurnBlocking(const TurnBasedMatch & match)
|
Sovraccarico di LeaveMatchDuringTheirTurnBlocking, che utilizza un timeout predefinito di 10 anni.
|
Rematch(const TurnBasedMatch & match, TurnBasedMatchCallback callback)
|
void
Trova una corrispondenza il cui stato è MatchStatus::COMPLETED.
|
RematchBlocking(Timeout timeout, const TurnBasedMatch & match)
|
Blocco della versione di Rematch.
|
RematchBlocking(const TurnBasedMatch & match)
|
Sovraccarico di RematchBlocking, che utilizza un timeout predefinito di 10 anni.
|
ShowMatchInboxUI(MatchInboxUICallback callback)
|
void
Mostra in modo asincrono l'interfaccia utente della casella di posta delle corrispondenze, consentendo al giocatore di selezionare una partita o un invito.
|
ShowMatchInboxUIBlocking(Timeout timeout)
|
Blocco della versione di ShowMatchInboxUI.
|
ShowMatchInboxUIBlocking()
|
Sovraccarico di ShowMatchInboxUIBlocking, che utilizza un timeout predefinito di 10 anni.
|
ShowPlayerSelectUI(uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch, PlayerSelectUICallback callback)
|
void
Mostra in modo asincrono l'interfaccia utente di selezione del giocatore, consentendogli di selezionare altri giocatori con cui giocare una partita.
|
ShowPlayerSelectUIBlocking(Timeout timeout, uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch)
|
Blocco della versione di ShowPlayerSelectUI.
|
ShowPlayerSelectUIBlocking(uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch)
|
Sovraccarico di ShowPlayerSelectUIBlocking, che utilizza un timeout predefinito di 10 anni.
|
SynchronizeData()
|
void
Forza la sincronizzazione dei dati di corrispondenza di TBMP con il server.
|
TakeMyTurn(const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant, TurnBasedMatchCallback callback)
|
void
Cambia in modo asincrono il partecipante locale.
|
TakeMyTurnBlocking(Timeout timeout, const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant)
|
Blocco della versione di TakeMyTurn.
|
TakeMyTurnBlocking(const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant)
|
Sovraccarico di TakeMyTurnBlocking, che utilizza un timeout predefinito di 10 anni.
|
Strutture |
|
---|---|
gpg:: |
|
gpg:: |
|
gpg:: |
|
gpg:: |
|
Tipi pubblici
MatchInboxUICallback
std::function< void(const MatchInboxUIResponse &)> MatchInboxUICallback
Definisce un callback che può ricevere un MatchInboxUIResponse
da ShowMatchInboxUI
.
MultiplayerStatusCallback
std::function< void(MultiplayerStatus)> MultiplayerStatusCallback
Definisce un callback che può essere utilizzato per ricevere un MultiplayerStatus.
Utilizzato dalle funzioni LasciaMatch e CancelMatch.
PlayerSelectUICallback
std::function< void(const PlayerSelectUIResponse &)> PlayerSelectUICallback
Definisce un callback che può ricevere un PlayerSelectUIResponse
da ShowPlayerSelectUI
.
TurnBasedMatchCallback
std::function< void(const TurnBasedMatchResponse &)> TurnBasedMatchCallback
Definisce un callback che può essere utilizzato per ricevere un TurnBasedMatchResponse
da una delle operazioni multiplayer a turni.
TurnBasedMatchesCallback
std::function< void(const TurnBasedMatchesResponse &)> TurnBasedMatchesCallback
Definisce un callback che può ricevere un TurnBasedMatchesResponse
da una delle operazioni multiplayer a turni.
Attributi statici pubblici
kAutomatchingParticipant
const MultiplayerParticipant kAutomatchingParticipant
Un partecipante che può essere trasmesso a metodi che accettano un "partecipante successivo".
In questo modo viene usato il metodo di selezione del partecipante successivo tramite la corrispondenza automatica. È valido solo per passare kAutomatchingPartecipante a una funzione se TurnBasedMatch::AutomatchingSlotsAvailable è maggiore di 0 per la corrispondenza correlata.
Funzioni pubbliche
AcceptInvitation
void AcceptInvitation( const MultiplayerInvitation & invitation, TurnBasedMatchCallback callback )
Accetta in modo asincrono un valore MultiplayerInvitation
e restituisce il risultato tramite TurnBasedMatchCallback
.
Se l'operazione ha esito positivo, lo stato TurnBasedMatch
restituito tramite il callback è in stato TurnBasedMatchState::MY_TURN
.
AcceptInvitationBlocking
TurnBasedMatchResponse AcceptInvitationBlocking( Timeout timeout, const MultiplayerInvitation & invitation )
Blocco della versione di AcceptInvitation.
Consente al chiamante di specificare un timeout in ms. Una volta trascorso il tempo specificato, la funzione restituisce ERROR_TIMEOUT
.
AcceptInvitationBlocking
TurnBasedMatchResponse AcceptInvitationBlocking( const MultiplayerInvitation & invitation )
Sovraccarico di AcceptInvitationBlocking, che utilizza un timeout predefinito di 10 anni.
CancelMatch
void CancelMatch( const TurnBasedMatch & match, MultiplayerStatusCallback callback )
Annulla una corrispondenza in modo asincrono.
Lo stato restituito tramite MultiplayerStatusCallback
indica se l'operazione è riuscita. Lo stato della corrispondenza deve visualizzare nell'elemento.
CancelMatchBlocking
MultiplayerStatus CancelMatchBlocking( Timeout timeout, const TurnBasedMatch & match )
Blocco della versione di CancelMatch.
Consente al chiamante di specificare un timeout in ms. Una volta trascorso il tempo specificato, la funzione restituisce ERROR_TIMEOUT
.
CancelMatchBlocking
MultiplayerStatus CancelMatchBlocking( const TurnBasedMatch & match )
Sovraccarico di CancelMatch che utilizza un timeout predefinito di 10 anni.
ConfirmPendingCompletion
void ConfirmPendingCompletion( const TurnBasedMatch & match, TurnBasedMatchCallback callback )
Conferma i risultati di una partita terminata in attesa del completamento locale.
Questa funzione può essere chiamata solo quando TurnBasedMatch::Status()
restituisce MatchStatus::PENDING_COMPLETION
.
Dettagli | |||||
---|---|---|---|---|---|
Parametri |
|
ConfirmPendingCompletionBlocking
TurnBasedMatchResponse ConfirmPendingCompletionBlocking( Timeout timeout, const TurnBasedMatch & match )
Versione di blocco di ConfirmPendingCompletion.
Consente al chiamante di specificare un timeout in ms. Una volta trascorso il tempo specificato, la funzione restituisce ERROR_TIMEOUT
.
ConfirmPendingCompletionBlocking
TurnBasedMatchResponse ConfirmPendingCompletionBlocking( const TurnBasedMatch & match )
Sovraccarico di ConfirmPendingCompletionBlocking, che utilizza un timeout predefinito di 10 anni.
CreateTurnBasedMatch
void CreateTurnBasedMatch( const gpg::TurnBasedMatchConfig & config, TurnBasedMatchCallback callback )
Crea in modo asincrono un TurnBasedMatch
utilizzando il metodo TurnBasedMatchConfig
fornito.
Se la creazione ha esito positivo, questa funzione restituisce TurnBasedMatch
tramite il TurnBasedMatchCallback
fornito. Un elemento TurnBasedMatch
appena creato inizia sempre nello stato TurnBasedMatchState::MY_TURN
.
CreateTurnBasedMatchBlocking
TurnBasedMatchResponse CreateTurnBasedMatchBlocking( Timeout timeout, const gpg::TurnBasedMatchConfig & config )
Blocco della versione di CreateTurnBasedMatch.
Consente al chiamante di specificare un timeout in ms. Una volta trascorso il tempo specificato, la funzione restituisce ERROR_TIMEOUT
.
CreateTurnBasedMatchBlocking
TurnBasedMatchResponse CreateTurnBasedMatchBlocking( const gpg::TurnBasedMatchConfig & config )
Sovraccarico di CreateTurnBasedMatchBlocking, che utilizza un timeout predefinito di 10 anni.
DeclineInvitation
void DeclineInvitation( const MultiplayerInvitation & invitation )
Rifiuta un MultiplayerInvitation
a un TurnBasedMatch
.
In questo modo la partita viene annullata per gli altri partecipanti e la partita viene rimossa dal dispositivo del giocatore locale.
DismissInvitation
void DismissInvitation( const MultiplayerInvitation & invitation )
Ignora MultiplayerInvitation
in TurnBasedMatch
.
Questa operazione non modifica lo stato visibile di TurnBasedMatch
per gli altri partecipanti, ma rimuove TurnBasedMatch
dal dispositivo del player locale.
DismissMatch
void DismissMatch( const TurnBasedMatch & match )
Ignora TurnBasedMatch
.
Questa operazione non modifica lo stato visibile di TurnBasedMatch
per gli altri partecipanti, ma rimuove TurnBasedMatch
dal dispositivo del player locale.
FetchMatch
void FetchMatch( const std::string & match_id, TurnBasedMatchCallback callback )
Recupera in modo asincrono una corrispondenza specifica per ID.
Il risultato di questa operazione viene restituito tramite TurnBasedMatchCallback
.
FetchMatchBlocking
TurnBasedMatchResponse FetchMatchBlocking( Timeout timeout, const std::string & match_id )
Blocco della versione di FetchMatch.
Consente al chiamante di specificare un timeout in ms. Una volta trascorso il tempo specificato, la funzione restituisce ERROR_TIMEOUT
.
FetchMatchBlocking
TurnBasedMatchResponse FetchMatchBlocking( const std::string & match_id )
Sovraccarico di FetchMatchBlocking, che utilizza un timeout predefinito di 10 anni.
FetchMatches
void FetchMatches( TurnBasedMatchesCallback callback )
Recupera in modo asincrono gli oggetti TurnBasedMatch
e Invitation
per il player corrente.
Vengono restituite tutte le corrispondenze attive e fino a un massimo di 10 corrispondenze completate.
FetchMatchesBlocking
TurnBasedMatchesResponse FetchMatchesBlocking( Timeout timeout )
Blocco della versione di FetchMatches.
Consente al chiamante di specificare un timeout in ms. Una volta trascorso il tempo specificato, la funzione restituisce ERROR_TIMEOUT
.
FetchMatchesBlocking
TurnBasedMatchesResponse FetchMatchesBlocking()
Sovraccarico di FetchMatchesBlocking, che utilizza un timeout predefinito di 10 anni.
FinishMatchDuringMyTurn
void FinishMatchDuringMyTurn( const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, TurnBasedMatchCallback callback )
Termina in modo asincrono la corrispondenza specificata.
Può essere usato al posto di TakeMyTurn durante l'ultimo turno della partita. Consente al chiamante di specificare un valore finale per match_data
e un insieme di valori finali per ParticipantResults
. Al termine di questa operazione, la corrispondenza aggiornata viene restituita tramite il TurnBasedMatchCallback.
fornito. Questa funzione può essere chiamata solo quando TurnBasedMatch::Status()
restituisce MatchStatus::MY_TURN.
Dettagli | |||||||||
---|---|---|---|---|---|---|---|---|---|
Parametri |
|
FinishMatchDuringMyTurnBlocking
TurnBasedMatchResponse FinishMatchDuringMyTurnBlocking( Timeout timeout, const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results )
Blocco della versione di FinishMatchDuringMyTurn.
Consente al chiamante di specificare un timeout in ms. Una volta trascorso il tempo specificato, la funzione restituisce ERROR_TIMEOUT
.
FinishMatchDuringMyTurnBlocking
TurnBasedMatchResponse FinishMatchDuringMyTurnBlocking( const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results )
Sovraccarico di FinishMatchDuringMyTurnBlocking, che utilizza un timeout predefinito di 10 anni.
LeaveMatchDuringMyTurn
void LeaveMatchDuringMyTurn( const TurnBasedMatch & match, const MultiplayerParticipant & next_participant, MultiplayerStatusCallback callback )
Abbandono in modo asincrono una corrispondenza durante il turno del partecipante locale.
La risposta restituita tramite TurnBasedMatchCallback
contiene lo stato della corrispondenza dopo l'eliminazione del player locale. Se questa partenza lascia la partita con meno di due partecipanti, la partita viene annullata. match.Status()
deve restituire MatchStatus::MY_TURN
affinché questa funzione sia utilizzabile.
Dettagli | |||||||
---|---|---|---|---|---|---|---|
Parametri |
|
LeaveMatchDuringMyTurnBlocking
MultiplayerStatus LeaveMatchDuringMyTurnBlocking( Timeout timeout, const TurnBasedMatch & match, const MultiplayerParticipant & next_participant )
Blocco della versione di LeaveMatchDuringMyTurn.
Consente al chiamante di specificare un timeout in ms. Una volta trascorso il tempo specificato, la funzione restituisce ERROR_TIMEOUT
.
LeaveMatchDuringMyTurnBlocking
MultiplayerStatus LeaveMatchDuringMyTurnBlocking( const TurnBasedMatch & match, const MultiplayerParticipant & next_participant )
Sovraccarico di LeaveMatchDuringMyTurnBlocking e usa un timeout predefinito di 10 anni.
LeaveMatchDuringTheirTurn
void LeaveMatchDuringTheirTurn( const TurnBasedMatch & match, MultiplayerStatusCallback callback )
Abbandono in modo asincrono una partita durante il turno di un altro partecipante.
La risposta restituita tramite il MultiplayerStatusCallback
indica se il partecipante locale ha lasciato correttamente la corrispondenza. Se questa partenza lascia la partita con meno di due partecipanti, la partita viene annullata. match.Status()
deve restituire MatchStatus::THEIR_TURN
affinché questa funzione sia utilizzabile.
LeaveMatchDuringTheirTurnBlocking
MultiplayerStatus LeaveMatchDuringTheirTurnBlocking( Timeout timeout, const TurnBasedMatch & match )
Blocco della versione di LeaveMatchDuringTheirTurn.
Consente al chiamante di specificare un timeout in ms. Una volta trascorso il tempo specificato, la funzione restituisce ERROR_TIMEOUT
.
LeaveMatchDuringTheirTurnBlocking
MultiplayerStatus LeaveMatchDuringTheirTurnBlocking( const TurnBasedMatch & match )
Sovraccarico di LeaveMatchDuringTheirTurnBlocking, che utilizza un timeout predefinito di 10 anni.
Rivincita
void Rematch( const TurnBasedMatch & match, TurnBasedMatchCallback callback )
Trova una corrispondenza il cui stato è MatchStatus::COMPLETED.
Se la rivincita è possibile, TurnBasedMatchCallback
riceve la nuova partita.
Dettagli | |||||
---|---|---|---|---|---|
Parametri |
|
RematchBlocking
TurnBasedMatchResponse RematchBlocking( Timeout timeout, const TurnBasedMatch & match )
Blocco della versione di Rematch.
Consente al chiamante di specificare un timeout in ms. Una volta trascorso il tempo specificato, la funzione restituisce ERROR_TIMEOUT
.
RematchBlocking
TurnBasedMatchResponse RematchBlocking( const TurnBasedMatch & match )
Sovraccarico di RematchBlocking, che utilizza un timeout predefinito di 10 anni.
ShowMatchInboxUI
void ShowMatchInboxUI( MatchInboxUICallback callback )
Mostra in modo asincrono l'interfaccia utente della casella di posta delle corrispondenze, consentendo al giocatore di selezionare una partita o un invito.
Al termine, la corrispondenza o l'invito selezionato viene restituito tramite MatchInboxUICallback
.
ShowMatchInboxUIBlocking
MatchInboxUIResponse ShowMatchInboxUIBlocking( Timeout timeout )
Blocco della versione di ShowMatchInboxUI.
Consente al chiamante di specificare un timeout in ms. Una volta trascorso il tempo specificato, la funzione restituisce ERROR_TIMEOUT
.
ShowMatchInboxUIBlocking
MatchInboxUIResponse ShowMatchInboxUIBlocking()
Sovraccarico di ShowMatchInboxUIBlocking, che utilizza un timeout predefinito di 10 anni.
ShowPlayerSelectUI
void ShowPlayerSelectUI( uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch, PlayerSelectUICallback callback )
Mostra in modo asincrono l'interfaccia utente di selezione del giocatore, consentendogli di selezionare altri giocatori con cui giocare una partita.
Al termine, i giocatori selezionati verranno restituiti tramite il PlayerSelectUICallback
.
ShowPlayerSelectUIBlocking
PlayerSelectUIResponse ShowPlayerSelectUIBlocking( Timeout timeout, uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch )
Blocco della versione di ShowPlayerSelectUI.
Consente al chiamante di specificare un timeout in ms. Una volta trascorso il tempo specificato, la funzione restituisce ERROR_TIMEOUT
.
ShowPlayerSelectUIBlocking
PlayerSelectUIResponse ShowPlayerSelectUIBlocking( uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch )
Sovraccarico di ShowPlayerSelectUIBlocking, che utilizza un timeout predefinito di 10 anni.
SynchronizeData
void SynchronizeData()
Forza la sincronizzazione dei dati di corrispondenza di TBMP con il server.
La ricezione di nuovi dati attiva un OnTurnBasedMatchEventCallback
o un OnMultiplayerInvitationReceivedCallback
.
TakeMyTurn
void TakeMyTurn( const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant, TurnBasedMatchCallback callback )
Cambia in modo asincrono il partecipante locale.
Quando svolta, il partecipante può specificare un nuovo valore per match_data
e un insieme di ParticipantResults
. Al termine del turno, la corrispondenza aggiornata viene restituita tramite l'TurnBasedMatchCallback
. Questa funzione può essere chiamata solo quando TurnBasedMatch::Status()
è MatchStatus::MY_TURN
.
Dettagli | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Parametri |
|
TakeMyTurnBlocking
TurnBasedMatchResponse TakeMyTurnBlocking( Timeout timeout, const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant )
Blocco della versione di TakeMyTurn.
Consente al chiamante di specificare un timeout in ms. Una volta trascorso il tempo specificato, la funzione restituisce ERROR_TIMEOUT
.
TakeMyTurnBlocking
TurnBasedMatchResponse TakeMyTurnBlocking( const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant )
Sovraccarico di TakeMyTurnBlocking, che utilizza un timeout predefinito di 10 anni.