gpg:: TurnBasedMultiplayerManager
#include <turn_based_multiplayer_manager.h>
Récupère, modifie et crée les objets TurnBasedMatch
.
Résumé
Types publics |
|
---|---|
MatchInboxUICallback
|
typedefstd::function< void(const MatchInboxUIResponse &)>
Définit un rappel pouvant recevoir un MatchInboxUIResponse de ShowMatchInboxUI . |
MultiplayerStatusCallback
|
typedefstd::function< void(MultiplayerStatus)>
Définit un rappel qui peut être utilisé pour recevoir un MultiplayerStatus. |
PlayerSelectUICallback
|
typedefstd::function< void(const PlayerSelectUIResponse &)>
Définit un rappel pouvant recevoir un PlayerSelectUIResponse de ShowPlayerSelectUI . |
TurnBasedMatchCallback
|
typedefstd::function< void(const TurnBasedMatchResponse &)>
Définit un rappel qui peut être utilisé pour recevoir un TurnBasedMatchResponse de l'une des opérations multijoueurs au tour par tour. |
TurnBasedMatchesCallback
|
typedefstd::function< void(const TurnBasedMatchesResponse &)>
Définit un rappel pouvant recevoir un TurnBasedMatchesResponse de l'une des opérations multijoueurs au tour par tour. |
Attributs statiques publics |
|
---|---|
kAutomatchingParticipant
|
const MultiplayerParticipant
Participant pouvant être transmis à des méthodes qui prennent une "prochaine"
participant.
|
Fonctions publiques |
|
---|---|
AcceptInvitation(const MultiplayerInvitation & invitation, TurnBasedMatchCallback callback)
|
void
Accepte de manière asynchrone un
MultiplayerInvitation et renvoie le résultat via une TurnBasedMatchCallback . |
AcceptInvitationBlocking(Timeout timeout, const MultiplayerInvitation & invitation)
|
Blocage de la version d'AcceptInvitation.
|
AcceptInvitationBlocking(const MultiplayerInvitation & invitation)
|
Surcharge de AcceptInvitationBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
|
CancelMatch(const TurnBasedMatch & match, MultiplayerStatusCallback callback)
|
void
Annule une correspondance de manière asynchrone.
|
CancelMatchBlocking(Timeout timeout, const TurnBasedMatch & match)
|
Blocage de la version de CancelMatch.
|
CancelMatchBlocking(const TurnBasedMatch & match)
|
Surcharge de CancelMatch, qui utilise un délai avant expiration par défaut de 10 ans.
|
ConfirmPendingCompletion(const TurnBasedMatch & match, TurnBasedMatchCallback callback)
|
void
Confirme les résultats d'une correspondance terminée et en attente de finalisation locale.
|
ConfirmPendingCompletionBlocking(Timeout timeout, const TurnBasedMatch & match)
|
Blocage de la version de ConfirmPendingCompletion.
|
ConfirmPendingCompletionBlocking(const TurnBasedMatch & match)
|
Surcharge de ConfirmPendingCompletionBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
|
CreateTurnBasedMatch(const gpg::TurnBasedMatchConfig & config, TurnBasedMatchCallback callback)
|
void
Crée un
TurnBasedMatch de manière asynchrone à l'aide du TurnBasedMatchConfig fourni. |
CreateTurnBasedMatchBlocking(Timeout timeout, const gpg::TurnBasedMatchConfig & config)
|
Blocage de la version de CreateTurnBasedMatch.
|
CreateTurnBasedMatchBlocking(const gpg::TurnBasedMatchConfig & config)
|
Surcharge de CreateTurnBasedMatchBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
|
DeclineInvitation(const MultiplayerInvitation & invitation)
|
void
Refuse un
MultiplayerInvitation en TurnBasedMatch . |
DismissInvitation(const MultiplayerInvitation & invitation)
|
void
Ignore une
MultiplayerInvitation en TurnBasedMatch . |
DismissMatch(const TurnBasedMatch & match)
|
void
Ignore un élément
TurnBasedMatch . |
FetchMatch(const std::string & match_id, TurnBasedMatchCallback callback)
|
void
Récupère de manière asynchrone une correspondance spécifique par ID.
|
FetchMatchBlocking(Timeout timeout, const std::string & match_id)
|
Blocage de la version de FetchMatch.
|
FetchMatchBlocking(const std::string & match_id)
|
Surcharge de FetchMatchBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
|
FetchMatches(TurnBasedMatchesCallback callback)
|
void
Récupère de manière asynchrone les objets
TurnBasedMatch et Invitation pour le joueur actif. |
FetchMatchesBlocking(Timeout timeout)
|
Version bloquante de FetchMatches.
|
FetchMatchesBlocking()
|
Surcharge de FetchMatchesBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
|
FinishMatchDuringMyTurn(const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, TurnBasedMatchCallback callback)
|
void
Met fin à la correspondance spécifiée de manière asynchrone.
|
FinishMatchDuringMyTurnBlocking(Timeout timeout, const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results)
|
Blocage de la version de FinishMatchDuringMyTurn
|
FinishMatchDuringMyTurnBlocking(const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results)
|
Surcharge de FinishMatchDuringMyTurnBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
|
LeaveMatchDuringMyTurn(const TurnBasedMatch & match, const MultiplayerParticipant & next_participant, MultiplayerStatusCallback callback)
|
void
Quitte de manière asynchrone une partie pendant le tour du participant local.
|
LeaveMatchDuringMyTurnBlocking(Timeout timeout, const TurnBasedMatch & match, const MultiplayerParticipant & next_participant)
|
Blocage de la version de LeaveMatchDuringMyTurn
|
LeaveMatchDuringMyTurnBlocking(const TurnBasedMatch & match, const MultiplayerParticipant & next_participant)
|
Surcharge de LeaveMatchDuringMyTurnBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
|
LeaveMatchDuringTheirTurn(const TurnBasedMatch & match, MultiplayerStatusCallback callback)
|
void
Quitte de manière asynchrone une partie au tour d'un autre participant.
|
LeaveMatchDuringTheirTurnBlocking(Timeout timeout, const TurnBasedMatch & match)
|
Blocage de la version de LeaveMatchDuringTheirTurn
|
LeaveMatchDuringTheirTurnBlocking(const TurnBasedMatch & match)
|
Surcharge de LeaveMatchDuringTheirTurnBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
|
Rematch(const TurnBasedMatch & match, TurnBasedMatchCallback callback)
|
void
Remplace une correspondance dont l'état est MatchStatus::COMPLETED.
|
RematchBlocking(Timeout timeout, const TurnBasedMatch & match)
|
Blocage de la version de Rematch
|
RematchBlocking(const TurnBasedMatch & match)
|
Surcharge de RematchBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
|
ShowMatchInboxUI(MatchInboxUICallback callback)
|
void
Affiche de manière asynchrone l'interface utilisateur de la boîte de réception des matchs, ce qui permet au joueur de sélectionner une partie ou une invitation.
|
ShowMatchInboxUIBlocking(Timeout timeout)
|
Blocage de la version de ShowMatchInboxUI
|
ShowMatchInboxUIBlocking()
|
Surcharge de ShowMatchInboxUIBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
|
ShowPlayerSelectUI(uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch, PlayerSelectUICallback callback)
|
void
Affiche de manière asynchrone l'interface utilisateur de sélection du joueur, ce qui permet au joueur de sélectionner d'autres joueurs avec lesquels jouer une partie.
|
ShowPlayerSelectUIBlocking(Timeout timeout, uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch)
|
Blocage de la version de ShowPlayerSelectUI.
|
ShowPlayerSelectUIBlocking(uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch)
|
Surcharge de ShowPlayerSelectUIBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
|
SynchronizeData()
|
void
Force la synchronisation des données de correspondance TOMP avec le serveur.
|
TakeMyTurn(const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant, TurnBasedMatchCallback callback)
|
void
Elle prend le tour du participant local de manière asynchrone.
|
TakeMyTurnBlocking(Timeout timeout, const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant)
|
Blocage de la version de TakeMyTurn
|
TakeMyTurnBlocking(const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant)
|
Surcharge de TakeMyTurnBlocking, qui utilise un délai avant expiration par défaut de 10 ans
|
Structs |
|
---|---|
gpg:: |
|
gpg:: |
|
gpg:: |
|
gpg:: |
|
Types publics
MatchInboxUICallback
std::function< void(const MatchInboxUIResponse &)> MatchInboxUICallback
Définit un rappel pouvant recevoir un MatchInboxUIResponse
de ShowMatchInboxUI
.
MultiplayerStatusCallback
std::function< void(MultiplayerStatus)> MultiplayerStatusCallback
Définit un rappel qui peut être utilisé pour recevoir un MultiplayerStatus.
Utilisé par les fonctions Part de la correspondance et Annulation de la correspondance.
PlayerSelectUICallback
std::function< void(const PlayerSelectUIResponse &)> PlayerSelectUICallback
Définit un rappel pouvant recevoir un PlayerSelectUIResponse
de ShowPlayerSelectUI
.
TurnBasedMatchCallback
std::function< void(const TurnBasedMatchResponse &)> TurnBasedMatchCallback
Définit un rappel qui peut être utilisé pour recevoir un TurnBasedMatchResponse
de l'une des opérations multijoueurs au tour par tour.
TurnBasedMatchesCallback
std::function< void(const TurnBasedMatchesResponse &)> TurnBasedMatchesCallback
Définit un rappel pouvant recevoir un TurnBasedMatchesResponse
de l'une des opérations multijoueurs au tour par tour.
Attributs statiques publics
kAutomatchingParticipant
const MultiplayerParticipant kAutomatchingParticipant
Participant pouvant être transmis à des méthodes qui prennent une "prochaine" participant.
La méthode sélectionne alors le participant suivant via la mise en correspondance automatique. La transmission de kAutomatchingParticipant à une fonction n'est valide que si la valeur TurnBasedMatch::AutomatchingSlotsAvailable est supérieure à 0 pour la correspondance associée.
Fonctions publiques
AcceptInvitation
void AcceptInvitation( const MultiplayerInvitation & invitation, TurnBasedMatchCallback callback )
Accepte de manière asynchrone un MultiplayerInvitation
et renvoie le résultat via une TurnBasedMatchCallback
.
Si l'opération aboutit, le TurnBasedMatch
renvoyé par le rappel est à l'état TurnBasedMatchState::MY_TURN
.
AcceptInvitationBlocking
TurnBasedMatchResponse AcceptInvitationBlocking( Timeout timeout, const MultiplayerInvitation & invitation )
Blocage de la version d'AcceptInvitation.
Permet à l'appelant de spécifier un délai avant expiration en millisecondes. Une fois le délai spécifié écoulé, la fonction renvoie ERROR_TIMEOUT
.
AcceptInvitationBlocking
TurnBasedMatchResponse AcceptInvitationBlocking( const MultiplayerInvitation & invitation )
Surcharge de AcceptInvitationBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
CancelMatch
void CancelMatch( const TurnBasedMatch & match, MultiplayerStatusCallback callback )
Annule une correspondance de manière asynchrone.
L'état renvoyé par MultiplayerStatusCallback
indique si l'opération a réussi. L'état de la mise en correspondance doit être InviteD, THEIR_TURN ou MY_TURN pour que cette fonction soit utilisable.
CancelMatchBlocking
MultiplayerStatus CancelMatchBlocking( Timeout timeout, const TurnBasedMatch & match )
Blocage de la version de CancelMatch.
Permet à l'appelant de spécifier un délai avant expiration en millisecondes. Une fois le délai spécifié écoulé, la fonction renvoie ERROR_TIMEOUT
.
CancelMatchBlocking
MultiplayerStatus CancelMatchBlocking( const TurnBasedMatch & match )
Surcharge de CancelMatch, qui utilise un délai avant expiration par défaut de 10 ans.
ConfirmPendingCompletion
void ConfirmPendingCompletion( const TurnBasedMatch & match, TurnBasedMatchCallback callback )
Confirme les résultats d'une correspondance terminée et en attente de finalisation locale.
Cette fonction ne peut être appelée que lorsque TurnBasedMatch::Status()
renvoie MatchStatus::PENDING_COMPLETION
.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
ConfirmPendingCompletionBlocking
TurnBasedMatchResponse ConfirmPendingCompletionBlocking( Timeout timeout, const TurnBasedMatch & match )
Blocage de la version de ConfirmPendingCompletion.
Permet à l'appelant de spécifier un délai avant expiration en millisecondes. Une fois le délai spécifié écoulé, la fonction renvoie ERROR_TIMEOUT
.
ConfirmPendingCompletionBlocking
TurnBasedMatchResponse ConfirmPendingCompletionBlocking( const TurnBasedMatch & match )
Surcharge de ConfirmPendingCompletionBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
CreateTurnBasedMatch
void CreateTurnBasedMatch( const gpg::TurnBasedMatchConfig & config, TurnBasedMatchCallback callback )
Crée un TurnBasedMatch
de manière asynchrone à l'aide du TurnBasedMatchConfig
fourni.
Si la création aboutit, cette fonction renvoie TurnBasedMatch
via la TurnBasedMatchCallback
fournie. Une nouvelle TurnBasedMatch
commence toujours à l'état TurnBasedMatchState::MY_TURN
.
CreateTurnBasedMatchBlocking
TurnBasedMatchResponse CreateTurnBasedMatchBlocking( Timeout timeout, const gpg::TurnBasedMatchConfig & config )
Blocage de la version de CreateTurnBasedMatch.
Permet à l'appelant de spécifier un délai avant expiration en millisecondes. Une fois le délai spécifié écoulé, la fonction renvoie ERROR_TIMEOUT
.
CreateTurnBasedMatchBlocking
TurnBasedMatchResponse CreateTurnBasedMatchBlocking( const gpg::TurnBasedMatchConfig & config )
Surcharge de CreateTurnBasedMatchBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
DeclineInvitation
void DeclineInvitation( const MultiplayerInvitation & invitation )
Refuse un MultiplayerInvitation
en TurnBasedMatch
.
Cela annule la partie des autres participants et la supprime de l'appareil du joueur local.
DismissInvitation
void DismissInvitation( const MultiplayerInvitation & invitation )
Ignore une MultiplayerInvitation
en TurnBasedMatch
.
Cela ne modifie pas l'état visible de TurnBasedMatch
pour les autres participants, mais supprime TurnBasedMatch
de l'appareil du joueur local.
DismissMatch
void DismissMatch( const TurnBasedMatch & match )
Ignore un élément TurnBasedMatch
.
Cela ne modifie pas l'état visible de TurnBasedMatch
pour les autres participants, mais supprime TurnBasedMatch
de l'appareil du joueur local.
FetchMatch
void FetchMatch( const std::string & match_id, TurnBasedMatchCallback callback )
Récupère de manière asynchrone une correspondance spécifique par ID.
Le résultat de cette opération est renvoyé via un TurnBasedMatchCallback
.
FetchMatchBlocking
TurnBasedMatchResponse FetchMatchBlocking( Timeout timeout, const std::string & match_id )
Blocage de la version de FetchMatch.
Permet à l'appelant de spécifier un délai avant expiration en millisecondes. Une fois le délai spécifié écoulé, la fonction renvoie ERROR_TIMEOUT
.
FetchMatchBlocking
TurnBasedMatchResponse FetchMatchBlocking( const std::string & match_id )
Surcharge de FetchMatchBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
FetchMatches
void FetchMatches( TurnBasedMatchesCallback callback )
Récupère de manière asynchrone les objets TurnBasedMatch
et Invitation
pour le joueur actif.
Toutes les correspondances actives et jusqu'à 10 correspondances terminées sont renvoyées.
FetchMatchesBlocking
TurnBasedMatchesResponse FetchMatchesBlocking( Timeout timeout )
Version bloquante de FetchMatches.
Permet à l'appelant de spécifier un délai avant expiration en millisecondes. Une fois le délai spécifié écoulé, la fonction renvoie ERROR_TIMEOUT
.
FetchMatchesBlocking
TurnBasedMatchesResponse FetchMatchesBlocking()
Surcharge de FetchMatchesBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
FinishMatchDuringMyTurn
void FinishMatchDuringMyTurn( const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, TurnBasedMatchCallback callback )
Met fin à la correspondance spécifiée de manière asynchrone.
Peut être utilisé à la place de TakeMyTurn pendant le dernier tour de la partie. Permet à l'appelant de spécifier une valeur finale pour match_data
, ainsi qu'un ensemble de valeurs finales pour ParticipantResults
. Une fois cette opération terminée, la correspondance mise à jour est renvoyée via la TurnBasedMatchCallback.
fournie. Cette fonction ne peut être appelée que lorsque TurnBasedMatch::Status()
renvoie MatchStatus::MY_TURN.
.
Détails | |||||||||
---|---|---|---|---|---|---|---|---|---|
Paramètres |
|
FinishMatchDuringMyTurnBlocking
TurnBasedMatchResponse FinishMatchDuringMyTurnBlocking( Timeout timeout, const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results )
Blocage de la version de FinishMatchDuringMyTurn
Permet à l'appelant de spécifier un délai avant expiration en millisecondes. Une fois le délai spécifié écoulé, la fonction renvoie ERROR_TIMEOUT
.
FinishMatchDuringMyTurnBlocking
TurnBasedMatchResponse FinishMatchDuringMyTurnBlocking( const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results )
Surcharge de FinishMatchDuringMyTurnBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
LeaveMatchDuringMyTurn
void LeaveMatchDuringMyTurn( const TurnBasedMatch & match, const MultiplayerParticipant & next_participant, MultiplayerStatusCallback callback )
Quitte de manière asynchrone une partie pendant le tour du participant local.
La réponse renvoyée via TurnBasedMatchCallback
contient l'état de la partie une fois que le joueur local a quitté le jeu. Si le match quitte le match avec moins de deux participants, le match est annulé. match.Status()
doit renvoyer MatchStatus::MY_TURN
pour que cette fonction soit utilisable.
Détails | |||||||
---|---|---|---|---|---|---|---|
Paramètres |
|
LeaveMatchDuringMyTurnBlocking
MultiplayerStatus LeaveMatchDuringMyTurnBlocking( Timeout timeout, const TurnBasedMatch & match, const MultiplayerParticipant & next_participant )
Blocage de la version de LeaveMatchDuringMyTurn.
Permet à l'appelant de spécifier un délai avant expiration en millisecondes. Une fois le délai spécifié écoulé, la fonction renvoie ERROR_TIMEOUT
.
LeaveMatchDuringMyTurnBlocking
MultiplayerStatus LeaveMatchDuringMyTurnBlocking( const TurnBasedMatch & match, const MultiplayerParticipant & next_participant )
Surcharge de LeaveMatchDuringMyTurnBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
LeaveMatchDuringTheirTurn
void LeaveMatchDuringTheirTurn( const TurnBasedMatch & match, MultiplayerStatusCallback callback )
Quitte de manière asynchrone une partie au tour d'un autre participant.
La réponse renvoyée via MultiplayerStatusCallback
indique si le participant local a bien quitté la correspondance. Si le match quitte le match avec moins de deux participants, le match est annulé. match.Status()
doit renvoyer MatchStatus::THEIR_TURN
pour que cette fonction soit utilisable.
LeaveMatchDuringTheirTurnBlocking
MultiplayerStatus LeaveMatchDuringTheirTurnBlocking( Timeout timeout, const TurnBasedMatch & match )
Blocage de la version de LeaveMatchDuringTheirTurn
Permet à l'appelant de spécifier un délai avant expiration en millisecondes. Une fois le délai spécifié écoulé, la fonction renvoie ERROR_TIMEOUT
.
LeaveMatchDuringTheirTurnBlocking
MultiplayerStatus LeaveMatchDuringTheirTurnBlocking( const TurnBasedMatch & match )
Surcharge de LeaveMatchDuringTheirTurnBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
Revanche
void Rematch( const TurnBasedMatch & match, TurnBasedMatchCallback callback )
Remplace une correspondance dont l'état est MatchStatus::COMPLETED.
Si la revanche est possible, TurnBasedMatchCallback
reçoit la nouvelle correspondance.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
RematchBlocking
TurnBasedMatchResponse RematchBlocking( Timeout timeout, const TurnBasedMatch & match )
Blocage de la version de Rematch
Permet à l'appelant de spécifier un délai avant expiration en millisecondes. Une fois le délai spécifié écoulé, la fonction renvoie ERROR_TIMEOUT
.
RematchBlocking
TurnBasedMatchResponse RematchBlocking( const TurnBasedMatch & match )
Surcharge de RematchBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
ShowMatchInboxUI
void ShowMatchInboxUI( MatchInboxUICallback callback )
Affiche de manière asynchrone l'interface utilisateur de la boîte de réception des matchs, ce qui permet au joueur de sélectionner une partie ou une invitation.
Une fois l'opération terminée, la correspondance ou l'invitation sélectionnée est renvoyée via MatchInboxUICallback
.
ShowMatchInboxUIBlocking
MatchInboxUIResponse ShowMatchInboxUIBlocking( Timeout timeout )
Blocage de la version de ShowMatchInboxUI
Permet à l'appelant de spécifier un délai avant expiration en millisecondes. Une fois le délai spécifié écoulé, la fonction renvoie ERROR_TIMEOUT
.
ShowMatchInboxUIBlocking
MatchInboxUIResponse ShowMatchInboxUIBlocking()
Surcharge de ShowMatchInboxUIBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
ShowPlayerSelectUI
void ShowPlayerSelectUI( uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch, PlayerSelectUICallback callback )
Affiche de manière asynchrone l'interface utilisateur de sélection du joueur, ce qui permet au joueur de sélectionner d'autres joueurs avec lesquels jouer une partie.
Une fois l'opération terminée, les joueurs sélectionnés seront renvoyés via le PlayerSelectUICallback
.
ShowPlayerSelectUIBlocking
PlayerSelectUIResponse ShowPlayerSelectUIBlocking( Timeout timeout, uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch )
Blocage de la version de ShowPlayerSelectUI.
Permet à l'appelant de spécifier un délai avant expiration en millisecondes. Une fois le délai spécifié écoulé, la fonction renvoie ERROR_TIMEOUT
.
ShowPlayerSelectUIBlocking
PlayerSelectUIResponse ShowPlayerSelectUIBlocking( uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch )
Surcharge de ShowPlayerSelectUIBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
SynchronizeData
void SynchronizeData()
Force la synchronisation des données de correspondance TOMP avec le serveur.
La réception de nouvelles données déclenche une OnTurnBasedMatchEventCallback
ou une OnMultiplayerInvitationReceivedCallback
.
TakeMyTurn
void TakeMyTurn( const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant, TurnBasedMatchCallback callback )
Elle prend le tour du participant local de manière asynchrone.
Lorsqu'il joue à son tour, le participant peut spécifier une nouvelle valeur pour l'attribut match_data
, ainsi qu'un ensemble de valeurs ParticipantResults
. Lorsque la partie est terminée, la correspondance mise à jour est renvoyée via TurnBasedMatchCallback
. Cette fonction ne peut être appelée que lorsque TurnBasedMatch::Status()
est défini sur MatchStatus::MY_TURN
.
Détails | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Paramètres |
|
TakeMyTurnBlocking
TurnBasedMatchResponse TakeMyTurnBlocking( Timeout timeout, const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant )
Blocage de la version de TakeMyTurn
Permet à l'appelant de spécifier un délai avant expiration en millisecondes. Une fois le délai spécifié écoulé, la fonction renvoie ERROR_TIMEOUT
.
TakeMyTurnBlocking
TurnBasedMatchResponse TakeMyTurnBlocking( const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant )
Surcharge de TakeMyTurnBlocking, qui utilise un délai avant expiration par défaut de 10 ans