gpg:: TurnBasedMultiplayerManager
#include <turn_based_multiplayer_manager.h>
यह TurnBasedMatch
ऑब्जेक्ट को फ़ेच करता है, उनमें बदलाव करता है, और उन्हें बनाता है.
खास जानकारी
सार्वजनिक टाइप |
|
---|---|
MatchInboxUICallback
|
typedefstd::function< void(const MatchInboxUIResponse &)>
यह ऐसे कॉलबैक को तय करता है जिसे ShowMatchInboxUI से MatchInboxUIResponse मिल सकता है. |
MultiplayerStatusCallback
|
typedefstd::function< void(MultiplayerStatus)>
एक कॉलबैक तय करता है, जिसका इस्तेमाल मल्टीप्लेयर स्टेटस पाने के लिए किया जा सकता है. |
PlayerSelectUICallback
|
typedefstd::function< void(const PlayerSelectUIResponse &)>
यह ऐसे कॉलबैक को तय करता है जिसे ShowPlayerSelectUI से PlayerSelectUIResponse मिल सकता है. |
TurnBasedMatchCallback
|
typedefstd::function< void(const TurnBasedMatchResponse &)>
एक ऐसा कॉलबैक तय करता है जिसका इस्तेमाल बारी-आधारित मल्टीप्लेयर ऑपरेशन में से किसी एक से TurnBasedMatchResponse पाने के लिए किया जा सकता है. |
TurnBasedMatchesCallback
|
typedefstd::function< void(const TurnBasedMatchesResponse &)>
एक ऐसा कॉलबैक तय करता है जिसे बारी-आधारित मल्टीप्लेयर ऑपरेशन में से किसी एक से TurnBasedMatchesResponse मिल सकता है. |
सार्वजनिक स्टैटिक एट्रिब्यूट |
|
---|---|
kAutomatchingParticipant
|
const MultiplayerParticipant
हिस्सा लेने वाला वह व्यक्ति जिसे "अगला हिस्सा लेने वाला" लेने वाले तरीकों में भेजा जा सकता है.
|
सार्वजनिक फ़ंक्शन |
|
---|---|
AcceptInvitation(const MultiplayerInvitation & invitation, TurnBasedMatchCallback callback)
|
void
एसिंक्रोनस रूप से
MultiplayerInvitation स्वीकार करता है और TurnBasedMatchCallback के ज़रिए नतीजा देता है. |
AcceptInvitationBlocking(Timeout timeout, const MultiplayerInvitation & invitation)
|
AcceptInvitation का ब्लॉक करने वाला वर्शन.
|
AcceptInvitationBlocking(const MultiplayerInvitation & invitation)
|
AcceptInvitationBlocking का ज़्यादा लोड होना, जो डिफ़ॉल्ट तौर पर 10 साल के टाइम आउट का इस्तेमाल करता है.
|
CancelMatch(const TurnBasedMatch & match, MultiplayerStatusCallback callback)
|
void
एसिंक्रोनस रूप से मैच को रद्द करता है.
|
CancelMatchBlocking(Timeout timeout, const TurnBasedMatch & match)
|
CancelMatch का ब्लॉक करने वाला वर्शन.
|
CancelMatchBlocking(const TurnBasedMatch & match)
|
CancelMatch का ओवरलोड, जो 10 साल के डिफ़ॉल्ट टाइम आउट का इस्तेमाल करता है.
|
ConfirmPendingCompletion(const TurnBasedMatch & match, TurnBasedMatchCallback callback)
|
void
ऐसे मैच के नतीजों की पुष्टि करता है जो खत्म हो चुके हैं और जो स्थानीय तौर पर पूरा होना बाकी है.
|
ConfirmPendingCompletionBlocking(Timeout timeout, const TurnBasedMatch & match)
|
ConfirmPendingCompletion का ब्लॉक करने वाला वर्शन.
|
ConfirmPendingCompletionBlocking(const TurnBasedMatch & match)
|
ConfirmPendingCompletionBlocking का ओवरलोड, जो 10 साल के डिफ़ॉल्ट टाइम आउट का इस्तेमाल करता है.
|
CreateTurnBasedMatch(const gpg::TurnBasedMatchConfig & config, TurnBasedMatchCallback callback)
|
void
दिए गए
TurnBasedMatchConfig का इस्तेमाल करके, एसिंक्रोनस TurnBasedMatch बनाता है. |
CreateTurnBasedMatchBlocking(Timeout timeout, const gpg::TurnBasedMatchConfig & config)
|
CreateTurnBasedMatch का ब्लॉक करने वाला वर्शन.
|
CreateTurnBasedMatchBlocking(const gpg::TurnBasedMatchConfig & config)
|
CreateTurnBasedMatchBlocking का ओवरलोड जो कि डिफ़ॉल्ट तौर पर 10 साल के टाइम आउट का इस्तेमाल करता है.
|
DeclineInvitation(const MultiplayerInvitation & invitation)
|
void
MultiplayerInvitation को TurnBasedMatch में अस्वीकार करता है. |
DismissInvitation(const MultiplayerInvitation & invitation)
|
void
TurnBasedMatch के लिए MultiplayerInvitation को खारिज करता है. |
DismissMatch(const TurnBasedMatch & match)
|
void
TurnBasedMatch को खारिज करता है. |
FetchMatch(const std::string & match_id, TurnBasedMatchCallback callback)
|
void
आईडी के हिसाब से, खास मैच को एसिंक्रोनस तरीके से फ़ेच करता है.
|
FetchMatchBlocking(Timeout timeout, const std::string & match_id)
|
FetchMatch को ब्लॉक करने वाला वर्शन.
|
FetchMatchBlocking(const std::string & match_id)
|
FetchMatchBlocking का ओवरलोड, जो 10 साल के डिफ़ॉल्ट टाइम आउट का इस्तेमाल करता है.
|
FetchMatches(TurnBasedMatchesCallback callback)
|
void
मौजूदा प्लेयर के लिए,
TurnBasedMatch और Invitation ऑब्जेक्ट, एसिंक्रोनस तरीके से फ़ेच होता है. |
FetchMatchesBlocking(Timeout timeout)
|
FetchMatches का ब्लॉक करने वाला वर्शन.
|
FetchMatchesBlocking()
|
FetchMatchesBlocking का ओवरलोड, जो 10 साल के डिफ़ॉल्ट टाइम आउट का इस्तेमाल करता है.
|
FinishMatchDuringMyTurn(const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, TurnBasedMatchCallback callback)
|
void
एसिंक्रोनस रूप से तय मिलान को खत्म करता है.
|
FinishMatchDuringMyTurnBlocking(Timeout timeout, const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results)
|
FinishMatchDuringMyTurn का ब्लॉक करने वाला वर्शन.
|
FinishMatchDuringMyTurnBlocking(const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results)
|
FinishMatchDuringMyTurnBlocking का ओवरलोड, जो 10 साल के डिफ़ॉल्ट टाइम आउट का इस्तेमाल करता है.
|
LeaveMatchDuringMyTurn(const TurnBasedMatch & match, const MultiplayerParticipant & next_participant, MultiplayerStatusCallback callback)
|
void
स्थानीय भागीदार की बारी के दौरान एसिंक्रोनस रूप से एक मिलान छोड़ता है.
|
LeaveMatchDuringMyTurnBlocking(Timeout timeout, const TurnBasedMatch & match, const MultiplayerParticipant & next_participant)
|
LeaveMatchDuringMyTurn का ब्लॉक करने वाला वर्शन.
|
LeaveMatchDuringMyTurnBlocking(const TurnBasedMatch & match, const MultiplayerParticipant & next_participant)
|
LeaveMatchDuringMyTurnBlocking का ओवरलोड होता है, जो 10 साल के डिफ़ॉल्ट टाइम आउट का इस्तेमाल करता है.
|
LeaveMatchDuringTheirTurn(const TurnBasedMatch & match, MultiplayerStatusCallback callback)
|
void
किसी अन्य भागीदार की बारी के दौरान एसिंक्रोनस रूप से मिलान छोड़ देता है.
|
LeaveMatchDuringTheirTurnBlocking(Timeout timeout, const TurnBasedMatch & match)
|
LeaveMatchDuringTheirTurn का ब्लॉक करने वाला वर्शन.
|
LeaveMatchDuringTheirTurnBlocking(const TurnBasedMatch & match)
|
LeaveMatchDuringTheirTurnBlocking का ओवरलोड, जो 10 साल के डिफ़ॉल्ट टाइम आउट का इस्तेमाल करता है.
|
Rematch(const TurnBasedMatch & match, TurnBasedMatchCallback callback)
|
void
ऐसे मैच से फिर से मैच करता है जिसका स्टेटस MatchStatus::COMPLETED है.
|
RematchBlocking(Timeout timeout, const TurnBasedMatch & match)
|
रीमैच के वर्शन को ब्लॉक किया जा रहा है.
|
RematchBlocking(const TurnBasedMatch & match)
|
RematchBlocking का ओवरलोड, जिसमें डिफ़ॉल्ट रूप से 10 साल का टाइम आउट इस्तेमाल किया जाता है.
|
ShowMatchInboxUI(MatchInboxUICallback callback)
|
void
एसिंक्रोनस रूप से मैच इनबॉक्स का यूज़र इंटरफ़ेस (यूआई) दिखता है, जिससे प्लेयर कोई मैच या न्योता चुन सकता है.
|
ShowMatchInboxUIBlocking(Timeout timeout)
|
ShowMatchInboxUI का ब्लॉक करने वाला वर्शन.
|
ShowMatchInboxUIBlocking()
|
ShowMatchInboxUIBlocking का ओवरलोड, जो 10 साल के डिफ़ॉल्ट टाइम आउट का इस्तेमाल करता है.
|
ShowPlayerSelectUI(uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch, PlayerSelectUICallback callback)
|
void
एसिंक्रोनस तरीके से, प्लेयर को चुना गया यूज़र इंटरफ़ेस (यूआई) दिखता है. इससे प्लेयर, दूसरे खिलाड़ियों को मैच खेलने के लिए चुन सकता है.
|
ShowPlayerSelectUIBlocking(Timeout timeout, uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch)
|
ShowPlayerSelectUI का ब्लॉक करने वाला वर्शन.
|
ShowPlayerSelectUIBlocking(uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch)
|
ShowPlayerSelectUIBlocking का ओवरलोड, जो 10 साल के डिफ़ॉल्ट टाइम आउट का इस्तेमाल करता है.
|
SynchronizeData()
|
void
इससे TBMP मैच डेटा को सर्वर के साथ सिंक किया जाता है.
|
TakeMyTurn(const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant, TurnBasedMatchCallback callback)
|
void
एसिंक्रोनस रूप से स्थानीय भागीदार की बारी होती है.
|
TakeMyTurnBlocking(Timeout timeout, const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant)
|
TakeMyTurn का ब्लॉक करने वाला वर्शन.
|
TakeMyTurnBlocking(const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant)
|
TakeMyTurnBlocking का ओवरलोड होना, जो डिफ़ॉल्ट रूप से 10 साल के टाइम आउट का इस्तेमाल करता है.
|
संरचना |
|
---|---|
gpg:: |
|
gpg:: |
|
gpg:: |
किसी खास |
gpg:: |
TurnBasedMatches और न्योते के लिए |
सार्वजनिक टाइप
MatchInboxUICallback
std::function< void(const MatchInboxUIResponse &)> MatchInboxUICallback
यह ऐसे कॉलबैक को तय करता है जिसे ShowMatchInboxUI
से MatchInboxUIResponse
मिल सकता है.
MultiplayerStatusCallback
std::function< void(MultiplayerStatus)> MultiplayerStatusCallback
एक कॉलबैक तय करता है, जिसका इस्तेमाल मल्टीप्लेयर स्टेटस पाने के लिए किया जा सकता है.
इसका इस्तेमाल, LifeMatch औरCancelMatch फ़ंक्शन की मदद से किया जाता है.
PlayerSelectUICallback
std::function< void(const PlayerSelectUIResponse &)> PlayerSelectUICallback
यह ऐसे कॉलबैक को तय करता है जिसे ShowPlayerSelectUI
से PlayerSelectUIResponse
मिल सकता है.
TurnBasedMatchCallback
std::function< void(const TurnBasedMatchResponse &)> TurnBasedMatchCallback
एक ऐसा कॉलबैक तय करता है जिसका इस्तेमाल बारी-आधारित मल्टीप्लेयर ऑपरेशन में से किसी एक से TurnBasedMatchResponse
पाने के लिए किया जा सकता है.
TurnBasedMatchesCallback
std::function< void(const TurnBasedMatchesResponse &)> TurnBasedMatchesCallback
एक ऐसा कॉलबैक तय करता है जिसे बारी-आधारित मल्टीप्लेयर ऑपरेशन में से किसी एक से TurnBasedMatchesResponse
मिल सकता है.
सार्वजनिक स्टैटिक एट्रिब्यूट
kAutomatchingParticipant
const MultiplayerParticipant kAutomatchingParticipant
हिस्सा लेने वाला वह व्यक्ति जिसे "अगला हिस्सा लेने वाला" लेने वाले तरीकों में भेजा जा सकता है.
इस वजह से, तरीके में ऑटो-मैचिंग की मदद से अगले व्यक्ति को चुना जाता है. किसी फ़ंक्शन में kAutomatchingMeet को पास करने का विकल्प सिर्फ़ तब मान्य होता है, जब मिलते-जुलते मैच के लिए TurnbasedMatch::AutomatchingSlotsAvailable की वैल्यू 0 से ज़्यादा हो.
सार्वजनिक फ़ंक्शन
AcceptInvitation
void AcceptInvitation( const MultiplayerInvitation & invitation, TurnBasedMatchCallback callback )
एसिंक्रोनस रूप से MultiplayerInvitation
स्वीकार करता है और TurnBasedMatchCallback
के ज़रिए नतीजा देता है.
अगर कार्रवाई पूरी होती है, तो कॉलबैक के ज़रिए लौटाया गया TurnBasedMatch
TurnBasedMatchState::MY_TURN
स्थिति में होता है.
AcceptInvitationBlocking
TurnBasedMatchResponse AcceptInvitationBlocking( Timeout timeout, const MultiplayerInvitation & invitation )
AcceptInvitation का ब्लॉक करने वाला वर्शन.
कॉलर को मिलीसेकंड में टाइम आउट तय करने देती है. तय समय बीत जाने के बाद, फ़ंक्शन ERROR_TIMEOUT
देता है.
AcceptInvitationBlocking
TurnBasedMatchResponse AcceptInvitationBlocking( const MultiplayerInvitation & invitation )
AcceptInvitationBlocking का ज़्यादा लोड होना, जो डिफ़ॉल्ट तौर पर 10 साल के टाइम आउट का इस्तेमाल करता है.
CancelMatch
void CancelMatch( const TurnBasedMatch & match, MultiplayerStatusCallback callback )
एसिंक्रोनस रूप से मैच को रद्द करता है.
MultiplayerStatusCallback
से मिली स्थिति से पता चलता है कि कार्रवाई पूरी हुई या नहीं. इस फ़ंक्शन का इस्तेमाल करने के लिए, मैच की स्थिति को Blogger, THEIR_ हाल या MY_चालू होना चाहिए.
CancelMatchBlocking
MultiplayerStatus CancelMatchBlocking( Timeout timeout, const TurnBasedMatch & match )
CancelMatch का ब्लॉक करने वाला वर्शन.
कॉलर को मिलीसेकंड में टाइम आउट तय करने देती है. तय समय बीत जाने के बाद, फ़ंक्शन ERROR_TIMEOUT
देता है.
CancelMatchBlocking
MultiplayerStatus CancelMatchBlocking( const TurnBasedMatch & match )
CancelMatch का ओवरलोड, जो 10 साल के डिफ़ॉल्ट टाइम आउट का इस्तेमाल करता है.
ConfirmPendingCompletion
void ConfirmPendingCompletion( const TurnBasedMatch & match, TurnBasedMatchCallback callback )
ऐसे मैच के नतीजों की पुष्टि करता है जो खत्म हो चुके हैं और जो स्थानीय तौर पर पूरा होना बाकी है.
इस फ़ंक्शन को सिर्फ़ तब कॉल किया जा सकता है, जब TurnBasedMatch::Status()
MatchStatus::PENDING_COMPLETION
को रिटर्न करे.
जानकारी | |||||
---|---|---|---|---|---|
पैरामीटर |
|
ConfirmPendingCompletionBlocking
TurnBasedMatchResponse ConfirmPendingCompletionBlocking( Timeout timeout, const TurnBasedMatch & match )
ConfirmPendingCompletion का ब्लॉक करने वाला वर्शन.
कॉलर को मिलीसेकंड में टाइम आउट तय करने देती है. तय समय बीत जाने के बाद, फ़ंक्शन ERROR_TIMEOUT
देता है.
ConfirmPendingCompletionBlocking
TurnBasedMatchResponse ConfirmPendingCompletionBlocking( const TurnBasedMatch & match )
ConfirmPendingCompletionBlocking का ओवरलोड, जो 10 साल के डिफ़ॉल्ट टाइम आउट का इस्तेमाल करता है.
CreateTurnBasedMatch
void CreateTurnBasedMatch( const gpg::TurnBasedMatchConfig & config, TurnBasedMatchCallback callback )
दिए गए TurnBasedMatchConfig
का इस्तेमाल करके, एसिंक्रोनस TurnBasedMatch
बनाता है.
अगर इवेंट बन जाता है, तो यह फ़ंक्शन दिए गए TurnBasedMatchCallback
के ज़रिए TurnBasedMatch
दिखाता है. नया TurnBasedMatch
हमेशा TurnBasedMatchState::MY_TURN
की स्थिति में शुरू होता है.
CreateTurnBasedMatchBlocking
TurnBasedMatchResponse CreateTurnBasedMatchBlocking( Timeout timeout, const gpg::TurnBasedMatchConfig & config )
CreateTurnBasedMatch का ब्लॉक करने वाला वर्शन.
कॉलर को मिलीसेकंड में टाइम आउट तय करने देती है. तय समय बीत जाने के बाद, फ़ंक्शन ERROR_TIMEOUT
देता है.
CreateTurnBasedMatchBlocking
TurnBasedMatchResponse CreateTurnBasedMatchBlocking( const gpg::TurnBasedMatchConfig & config )
CreateTurnBasedMatchBlocking का ओवरलोड जो कि डिफ़ॉल्ट तौर पर 10 साल के टाइम आउट का इस्तेमाल करता है.
DeclineInvitation
void DeclineInvitation( const MultiplayerInvitation & invitation )
MultiplayerInvitation
को TurnBasedMatch
में अस्वीकार करता है.
ऐसा करने से, दूसरे खिलाड़ियों के लिए मैच रद्द हो जाएगा और स्थानीय खिलाड़ी के डिवाइस से मैच हट जाएगा.
DismissInvitation
void DismissInvitation( const MultiplayerInvitation & invitation )
TurnBasedMatch
के लिए MultiplayerInvitation
को खारिज करता है.
इससे मीटिंग में शामिल दूसरे लोगों के लिए, TurnBasedMatch
के दिखने की स्थिति में कोई बदलाव नहीं होता. हालांकि, लोकल प्लेयर के डिवाइस से TurnBasedMatch
हट जाता है.
DismissMatch
void DismissMatch( const TurnBasedMatch & match )
TurnBasedMatch
को खारिज करता है.
इससे मीटिंग में शामिल दूसरे लोगों के लिए, TurnBasedMatch
के दिखने की स्थिति में कोई बदलाव नहीं होता. हालांकि, लोकल प्लेयर के डिवाइस से TurnBasedMatch
हट जाता है.
FetchMatch
void FetchMatch( const std::string & match_id, TurnBasedMatchCallback callback )
आईडी के हिसाब से, खास मैच को एसिंक्रोनस तरीके से फ़ेच करता है.
इस कार्रवाई का नतीजा TurnBasedMatchCallback
के ज़रिए मिलता है.
FetchMatchBlocking
TurnBasedMatchResponse FetchMatchBlocking( Timeout timeout, const std::string & match_id )
FetchMatch को ब्लॉक करने वाला वर्शन.
कॉलर को मिलीसेकंड में टाइम आउट तय करने देती है. तय समय बीत जाने के बाद, फ़ंक्शन ERROR_TIMEOUT
देता है.
FetchMatchBlocking
TurnBasedMatchResponse FetchMatchBlocking( const std::string & match_id )
FetchMatchBlocking का ओवरलोड, जो 10 साल के डिफ़ॉल्ट टाइम आउट का इस्तेमाल करता है.
FetchMatches
void FetchMatches( TurnBasedMatchesCallback callback )
मौजूदा प्लेयर के लिए, TurnBasedMatch
और Invitation
ऑब्जेक्ट, एसिंक्रोनस तरीके से फ़ेच होता है.
सभी चालू मैच और पूरे हो चुके 10 मैच लौटाए जाते हैं.
FetchMatchesBlocking
TurnBasedMatchesResponse FetchMatchesBlocking( Timeout timeout )
FetchMatches का ब्लॉक करने वाला वर्शन.
कॉलर को मिलीसेकंड में टाइम आउट तय करने देती है. तय समय बीत जाने के बाद, फ़ंक्शन ERROR_TIMEOUT
देता है.
FetchMatchesBlocking
TurnBasedMatchesResponse FetchMatchesBlocking()
FetchMatchesBlocking का ओवरलोड, जो 10 साल के डिफ़ॉल्ट टाइम आउट का इस्तेमाल करता है.
FinishMatchDuringMyTurn
void FinishMatchDuringMyTurn( const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, TurnBasedMatchCallback callback )
एसिंक्रोनस रूप से तय मिलान को खत्म करता है.
मैच के आखिरी मोड़ के दौरान, इसका इस्तेमाल TakeMyTurn की जगह किया जा सकता है. इससे कॉल करने वाले को match_data
के लिए आखिरी वैल्यू और ParticipantResults
के लिए आखिरी वैल्यू का सेट तय करने की अनुमति मिलती है. यह कार्रवाई पूरी होने के बाद, अपडेट किया गया मैच, दिए गए TurnBasedMatchCallback.
के ज़रिए दिखाया जाता है. इस फ़ंक्शन को सिर्फ़ तब कॉल किया जा सकता है, जब TurnBasedMatch::Status()
MatchStatus::MY_TURN.
को रिटर्न करे
जानकारी | |||||||||
---|---|---|---|---|---|---|---|---|---|
पैरामीटर |
|
FinishMatchDuringMyTurnBlocking
TurnBasedMatchResponse FinishMatchDuringMyTurnBlocking( Timeout timeout, const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results )
FinishMatchDuringMyTurn का ब्लॉक करने वाला वर्शन.
कॉलर को मिलीसेकंड में टाइम आउट तय करने देती है. तय समय बीत जाने के बाद, फ़ंक्शन ERROR_TIMEOUT
देता है.
FinishMatchDuringMyTurnBlocking
TurnBasedMatchResponse FinishMatchDuringMyTurnBlocking( const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results )
FinishMatchDuringMyTurnBlocking का ओवरलोड, जो 10 साल के डिफ़ॉल्ट टाइम आउट का इस्तेमाल करता है.
LeaveMatchDuringMyTurn
void LeaveMatchDuringMyTurn( const TurnBasedMatch & match, const MultiplayerParticipant & next_participant, MultiplayerStatusCallback callback )
स्थानीय भागीदार की बारी के दौरान एसिंक्रोनस रूप से एक मिलान छोड़ता है.
TurnBasedMatchCallback
से मिले रिस्पॉन्स में, मैच की स्थिति की जानकारी होती है. यह जानकारी, स्थानीय खिलाड़ी के जाने के बाद दिखती है. अगर यह रवानगी, मैच में दो से कम लोगों के साथ मैच छोड़ती है, तो मैच रद्द हो जाता है. इस फ़ंक्शन को इस्तेमाल करने के लिए, match.Status()
को MatchStatus::MY_TURN
दिखाना होगा.
जानकारी | |||||||
---|---|---|---|---|---|---|---|
पैरामीटर |
|
LeaveMatchDuringMyTurnBlocking
MultiplayerStatus LeaveMatchDuringMyTurnBlocking( Timeout timeout, const TurnBasedMatch & match, const MultiplayerParticipant & next_participant )
LeaveMatchDuringMyTurn का ब्लॉक करने वाला वर्शन.
कॉलर को मिलीसेकंड में टाइम आउट तय करने देती है. तय समय बीत जाने के बाद, फ़ंक्शन ERROR_TIMEOUT
देता है.
LeaveMatchDuringMyTurnBlocking
MultiplayerStatus LeaveMatchDuringMyTurnBlocking( const TurnBasedMatch & match, const MultiplayerParticipant & next_participant )
LeaveMatchDuringMyTurnBlocking का ओवरलोड होता है, जो 10 साल के डिफ़ॉल्ट टाइम आउट का इस्तेमाल करता है.
LeaveMatchDuringTheirTurn
void LeaveMatchDuringTheirTurn( const TurnBasedMatch & match, MultiplayerStatusCallback callback )
किसी अन्य भागीदार की बारी के दौरान एसिंक्रोनस रूप से मिलान छोड़ देता है.
MultiplayerStatusCallback
से मिले रिस्पॉन्स में यह जानकारी होती है कि स्थानीय व्यक्ति ने मैच छोड़ा या नहीं. अगर यह रवानगी, मैच में दो से कम लोगों के साथ मैच छोड़ती है, तो मैच रद्द हो जाता है. इस फ़ंक्शन को इस्तेमाल करने के लिए, match.Status()
को MatchStatus::THEIR_TURN
दिखाना होगा.
LeaveMatchDuringTheirTurnBlocking
MultiplayerStatus LeaveMatchDuringTheirTurnBlocking( Timeout timeout, const TurnBasedMatch & match )
LeaveMatchDuringTheirTurn का ब्लॉक करने वाला वर्शन.
कॉलर को मिलीसेकंड में टाइम आउट तय करने देती है. तय समय बीत जाने के बाद, फ़ंक्शन ERROR_TIMEOUT
देता है.
LeaveMatchDuringTheirTurnBlocking
MultiplayerStatus LeaveMatchDuringTheirTurnBlocking( const TurnBasedMatch & match )
LeaveMatchDuringTheirTurnBlocking का ओवरलोड, जो 10 साल के डिफ़ॉल्ट टाइम आउट का इस्तेमाल करता है.
फिर से मुकाबला करें
void Rematch( const TurnBasedMatch & match, TurnBasedMatchCallback callback )
ऐसे मैच से फिर से मैच करता है जिसका स्टेटस MatchStatus::COMPLETED है.
अगर दोबारा मैच किया जा सकता है, तो TurnBasedMatchCallback
को नया मैच मिलेगा.
जानकारी | |||||
---|---|---|---|---|---|
पैरामीटर |
|
RematchBlocking
TurnBasedMatchResponse RematchBlocking( Timeout timeout, const TurnBasedMatch & match )
रीमैच के वर्शन को ब्लॉक किया जा रहा है.
कॉलर को मिलीसेकंड में टाइम आउट तय करने देती है. तय समय बीत जाने के बाद, फ़ंक्शन ERROR_TIMEOUT
देता है.
RematchBlocking
TurnBasedMatchResponse RematchBlocking( const TurnBasedMatch & match )
RematchBlocking का ओवरलोड, जिसमें डिफ़ॉल्ट रूप से 10 साल का टाइम आउट इस्तेमाल किया जाता है.
ShowMatchInboxUI
void ShowMatchInboxUI( MatchInboxUICallback callback )
एसिंक्रोनस रूप से मैच इनबॉक्स का यूज़र इंटरफ़ेस (यूआई) दिखता है, जिससे प्लेयर कोई मैच या न्योता चुन सकता है.
पूरा होने पर, चुना गया मैच या न्योते को MatchInboxUICallback
के ज़रिए वापस भेजा जाता है.
ShowMatchInboxUIBlocking
MatchInboxUIResponse ShowMatchInboxUIBlocking( Timeout timeout )
ShowMatchInboxUI का ब्लॉक करने वाला वर्शन.
कॉलर को मिलीसेकंड में टाइम आउट तय करने देती है. तय समय बीत जाने के बाद, फ़ंक्शन ERROR_TIMEOUT
देता है.
ShowMatchInboxUIBlocking
MatchInboxUIResponse ShowMatchInboxUIBlocking()
ShowMatchInboxUIBlocking का ओवरलोड, जो 10 साल के डिफ़ॉल्ट टाइम आउट का इस्तेमाल करता है.
ShowPlayerSelectUI
void ShowPlayerSelectUI( uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch, PlayerSelectUICallback callback )
एसिंक्रोनस तरीके से, प्लेयर को चुना गया यूज़र इंटरफ़ेस (यूआई) दिखता है. इससे प्लेयर, दूसरे खिलाड़ियों को मैच खेलने के लिए चुन सकता है.
पूरा होने पर, चुने गए खिलाड़ियों को PlayerSelectUICallback
के ज़रिए वापस भेजा जाएगा.
ShowPlayerSelectUIBlocking
PlayerSelectUIResponse ShowPlayerSelectUIBlocking( Timeout timeout, uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch )
ShowPlayerSelectUI का ब्लॉक करने वाला वर्शन.
कॉलर को मिलीसेकंड में टाइम आउट तय करने देती है. तय समय बीत जाने के बाद, फ़ंक्शन ERROR_TIMEOUT
देता है.
ShowPlayerSelectUIBlocking
PlayerSelectUIResponse ShowPlayerSelectUIBlocking( uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch )
ShowPlayerSelectUIBlocking का ओवरलोड, जो 10 साल के डिफ़ॉल्ट टाइम आउट का इस्तेमाल करता है.
SynchronizeData
void SynchronizeData()
इससे TBMP मैच डेटा को सर्वर के साथ सिंक किया जाता है.
नए डेटा के मिलने पर, OnTurnBasedMatchEventCallback
या OnMultiplayerInvitationReceivedCallback
ट्रिगर होता है.
TakeMyTurn
void TakeMyTurn( const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant, TurnBasedMatchCallback callback )
एसिंक्रोनस रूप से स्थानीय भागीदार की बारी होती है.
मोड़ लेते समय, हिस्सा लेने वाला व्यक्ति match_data
के लिए एक नई वैल्यू तय कर सकता है. साथ ही, ParticipantResults
का एक सेट भी तय कर सकता है. जब टर्न खत्म होता है, तो अपडेट किया गया मैच TurnBasedMatchCallback
के ज़रिए वापस भेजा जाता है. यह फ़ंक्शन सिर्फ़ तब कॉल किया जा सकता है, जब TurnBasedMatch::Status()
MatchStatus::MY_TURN
हो.
जानकारी | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
पैरामीटर |
|
TakeMyTurnBlocking
TurnBasedMatchResponse TakeMyTurnBlocking( Timeout timeout, const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant )
TakeMyTurn का ब्लॉक करने वाला वर्शन.
कॉलर को मिलीसेकंड में टाइम आउट तय करने देती है. तय समय बीत जाने के बाद, फ़ंक्शन ERROR_TIMEOUT
देता है.
TakeMyTurnBlocking
TurnBasedMatchResponse TakeMyTurnBlocking( const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant )
TakeMyTurnBlocking का ओवरलोड होना, जो डिफ़ॉल्ट रूप से 10 साल के टाइम आउट का इस्तेमाल करता है.