gpg:: TurnBasedMultiplayerManager
#include <turn_based_multiplayer_manager.h>
Recupera, modifica e crea gli oggetti TurnBasedMatch
.
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 uno Stato Multiplayer. |
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 passato a metodi che prendono un "
partecipante".
|
Funzioni pubbliche |
|
---|---|
AcceptInvitation(const MultiplayerInvitation & invitation, TurnBasedMatchCallback callback)
|
void
Accetta in modo asincrono un
MultiplayerInvitation e restituisce il risultato tramite un TurnBasedMatchCallback . |
AcceptInvitationBlocking(Timeout timeout, const MultiplayerInvitation & invitation)
|
Versione di blocco 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)
|
Versione di blocco 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 corrispondenza terminata ed 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 un
TurnBasedMatch in modo asincrono utilizzando il valore TurnBasedMatchConfig fornito. |
CreateTurnBasedMatchBlocking(Timeout timeout, const gpg::TurnBasedMatchConfig & config)
|
Versione di blocco 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 in un TurnBasedMatch . |
DismissInvitation(const MultiplayerInvitation & invitation)
|
void
Ignora un
MultiplayerInvitation per un TurnBasedMatch . |
DismissMatch(const TurnBasedMatch & match)
|
void
Ignora un
TurnBasedMatch . |
FetchMatch(const std::string & match_id, TurnBasedMatchCallback callback)
|
void
Recupera in modo asincrono una corrispondenza specifica in base all'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 la corrispondenza specificata in modo asincrono.
|
FinishMatchDuringMyTurnBlocking(Timeout timeout, const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results)
|
È in corso il 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
Abbandona una partita in modo asincrono durante il turno del partecipante locale.
|
LeaveMatchDuringMyTurnBlocking(Timeout timeout, const TurnBasedMatch & match, const MultiplayerParticipant & next_participant)
|
È in corso il blocco della versione di LeaveMatchDuringMyTurn.
|
LeaveMatchDuringMyTurnBlocking(const TurnBasedMatch & match, const MultiplayerParticipant & next_participant)
|
Sovraccarico di LeaveMatchDuringMyTurnBlocking e che utilizza un timeout predefinito di 10 anni.
|
LeaveMatchDuringTheirTurn(const TurnBasedMatch & match, MultiplayerStatusCallback callback)
|
void
Abbandona in modo asincrono una partita nel turno di un altro partecipante.
|
LeaveMatchDuringTheirTurnBlocking(Timeout timeout, const TurnBasedMatch & match)
|
È in corso il blocco della versione di LeaveMatchDuringTheirTurn.
|
LeaveMatchDuringTheirTurnBlocking(const TurnBasedMatch & match)
|
Sovraccarico di LeaveMatchDuringTheirTurnBlocking, che usa un timeout predefinito di 10 anni.
|
Rematch(const TurnBasedMatch & match, TurnBasedMatchCallback callback)
|
void
Rivinci una corrispondenza il cui stato è MatchStatus::COMPLETED.
|
RematchBlocking(Timeout timeout, const TurnBasedMatch & match)
|
Blocco della versione di Rivincita.
|
RematchBlocking(const TurnBasedMatch & match)
|
Sovraccarico di RematchBlocking, che utilizza un timeout predefinito di 10 anni.
|
ShowMatchInboxUI(MatchInboxUICallback callback)
|
void
Mostra in modo asincrono l'UI della Posta in arrivo delle corrispondenze, consentendo al giocatore di selezionare una partita o un invito.
|
ShowMatchInboxUIBlocking(Timeout timeout)
|
È stato bloccato il 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'UI di selezione del giocatore, che permette al giocatore di selezionare altri giocatori con cui giocare.
|
ShowPlayerSelectUIBlocking(Timeout timeout, uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch)
|
Versione di blocco 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
In modo asincrono prende il turno del partecipante locale.
|
TakeMyTurnBlocking(Timeout timeout, const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant)
|
È in corso il 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.
|
Structs |
|
---|---|
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 uno Stato Multiplayer.
Utilizzato dalle funzioni StayMatch 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 passato a metodi che prendono un " partecipante".
In questo modo viene attivato il metodo per selezionare il partecipante successivo tramite la corrispondenza automatica. È valido passare kAutomatchingparticipant a una funzione solo 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 MultiplayerInvitation
e restituisce il risultato tramite un TurnBasedMatchCallback
.
Se l'operazione ha esito positivo, TurnBasedMatch
restituito tramite il callback è nello stato TurnBasedMatchState::MY_TURN
.
AcceptInvitationBlocking
TurnBasedMatchResponse AcceptInvitationBlocking( Timeout timeout, const MultiplayerInvitation & invitation )
Versione di blocco 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. Affinché questa funzione sia utilizzabile, lo stato della corrispondenza deve essere INVITATO, THEIR_TURN o MY_TURN.
CancelMatchBlocking
MultiplayerStatus CancelMatchBlocking( Timeout timeout, const TurnBasedMatch & match )
Versione di blocco 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 corrispondenza terminata ed 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 un TurnBasedMatch
in modo asincrono utilizzando il valore TurnBasedMatchConfig
fornito.
Se la creazione ha esito positivo, questa funzione restituisce TurnBasedMatch
tramite il TurnBasedMatchCallback
fornito. Un TurnBasedMatch
appena creato viene sempre avviato nello stato TurnBasedMatchState::MY_TURN
.
CreateTurnBasedMatchBlocking
TurnBasedMatchResponse CreateTurnBasedMatchBlocking( Timeout timeout, const gpg::TurnBasedMatchConfig & config )
Versione di blocco 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
in un TurnBasedMatch
.
In questo modo la partita viene annullata per gli altri partecipanti e rimossa dal dispositivo del giocatore locale.
DismissInvitation
void DismissInvitation( const MultiplayerInvitation & invitation )
Ignora un MultiplayerInvitation
per un TurnBasedMatch
.
Questa operazione non modifica lo stato visibile di TurnBasedMatch
per gli altri partecipanti, ma rimuove TurnBasedMatch
dal dispositivo del giocatore locale.
DismissMatch
void DismissMatch( const TurnBasedMatch & match )
Ignora un TurnBasedMatch
.
Questa operazione non modifica lo stato visibile di TurnBasedMatch
per gli altri partecipanti, ma rimuove TurnBasedMatch
dal dispositivo del giocatore locale.
FetchMatch
void FetchMatch( const std::string & match_id, TurnBasedMatchCallback callback )
Recupera in modo asincrono una corrispondenza specifica in base all'ID.
Il risultato di questa operazione viene restituito tramite un 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 partite attive e fino a un massimo di 10 partite 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 la corrispondenza specificata in modo asincrono.
Questa opzione può essere utilizzata al posto di TakeMyTurn durante l'ultimo turno della partita. Consente al chiamante di specificare un valore finale per match_data
, nonché un insieme di valori finali per ParticipantResults
. Una volta completata l'operazione, la corrispondenza aggiornata viene restituita tramite il campo 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 )
È in corso il 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 )
Abbandona una partita in modo asincrono durante il turno del partecipante locale.
La risposta restituita tramite TurnBasedMatchCallback
contiene lo stato della partita dopo che il giocatore locale è uscito. 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 )
È in corso il 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 che utilizza un timeout predefinito di 10 anni.
LeaveMatchDuringTheirTurn
void LeaveMatchDuringTheirTurn( const TurnBasedMatch & match, MultiplayerStatusCallback callback )
Abbandona in modo asincrono una partita nel turno di un altro partecipante.
La risposta restituita tramite MultiplayerStatusCallback
indica se il partecipante locale ha abbandonato la partita correttamente. 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 )
È in corso il 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 usa un timeout predefinito di 10 anni.
Rivincita
void Rematch( const TurnBasedMatch & match, TurnBasedMatchCallback callback )
Ritrova 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 della rivincita.
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'UI della Posta in arrivo delle corrispondenze, consentendo al giocatore di selezionare una partita o un invito.
Al termine, la corrispondenza o l'invito selezionati vengono restituiti tramite MatchInboxUICallback
.
ShowMatchInboxUIBlocking
MatchInboxUIResponse ShowMatchInboxUIBlocking( Timeout timeout )
È stato bloccato il 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'UI di selezione del giocatore, che permette al giocatore di selezionare altri giocatori con cui giocare.
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 )
Versione di blocco 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 )
In modo asincrono prende il turno del partecipante locale.
Quando effettua un turno, il partecipante può specificare un nuovo valore per match_data
, oltre a un insieme di ParticipantResults
. Al termine del turno, la corrispondenza aggiornata viene restituita tramite 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 )
È in corso il 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.