gpg::TurnBasedMultiplayerManager

#include <turn_based_multiplayer_manager.h>

מאחזר, משנה ויוצר אובייקטים מסוג TurnBasedMatch.

סיכום

סוגים ציבוריים
MatchInboxUICallback	typedef std::function< void(const MatchInboxUIResponse &)> מגדיר קריאה חוזרת (callback) שיכולה לקבל MatchInboxUIResponse מ-ShowMatchInboxUI.
MultiplayerStatusCallback	typedef std::function< void(MultiplayerStatus)> מגדיר קריאה חוזרת (callback) שאפשר להשתמש בה כדי לקבל סטטוס רב-משתתפים.
PlayerSelectUICallback	typedef std::function< void(const PlayerSelectUIResponse &)> מגדיר קריאה חוזרת (callback) שיכולה לקבל PlayerSelectUIResponse מ-ShowPlayerSelectUI.
TurnBasedMatchCallback	typedef std::function< void(const TurnBasedMatchResponse &)> מגדיר קריאה חוזרת (callback) שאפשר להשתמש בה כדי לקבל TurnBasedMatchResponse מאחת מהפעולות למשחק רב-משתתפים לפי תור.
TurnBasedMatchesCallback	typedef std::function< void(const TurnBasedMatchesResponse &)> מגדיר קריאה חוזרת (callback) שיכולה לקבל TurnBasedMatchesResponse מאחת מהפעולות למשחק רב-משתתפים לפי תור.

מאפיינים סטטיים ציבוריים
kAutomatchingParticipant	const MultiplayerParticipant משתתף שניתן להעביר ל-methods שנמצאות בשלב "הבא" משתתף".

פונקציות ציבוריות
AcceptInvitation(const MultiplayerInvitation & invitation, TurnBasedMatchCallback callback)	void הפונקציה מקבלת MultiplayerInvitation באופן אסינכרוני, ומחזירה את התוצאה דרך TurnBasedMatchCallback.
AcceptInvitationBlocking(Timeout timeout, const MultiplayerInvitation & invitation)	TurnBasedMatchResponse גרסת חסימה של AcceptInvitation.
AcceptInvitationBlocking(const MultiplayerInvitation & invitation)	TurnBasedMatchResponse עומס יתר של AcceptInvitationBlocking, שבו הזמן הקצוב לתפוגה שמוגדר כברירת מחדל הוא 10 שנים.
CancelMatch(const TurnBasedMatch & match, MultiplayerStatusCallback callback)	void היא מבטלת התאמה באופן אסינכרוני.
CancelMatchBlocking(Timeout timeout, const TurnBasedMatch & match)	MultiplayerStatus גרסת החסימה של CancelMatch.
CancelMatchBlocking(const TurnBasedMatch & match)	MultiplayerStatus עומס יתר של CancelMatch, שהזמן הקצוב שלו לתפוגה מוגדר ל-10 שנים כברירת מחדל.
ConfirmPendingCompletion(const TurnBasedMatch & match, TurnBasedMatchCallback callback)	void מאשרת את התוצאות של משחק שהסתיים וממתינה להשלמה מקומית.
ConfirmPendingCompletionBlocking(Timeout timeout, const TurnBasedMatch & match)	TurnBasedMatchResponse גרסת חסימה של ConfirmPendingCompletion
ConfirmPendingCompletionBlocking(const TurnBasedMatch & match)	TurnBasedMatchResponse עומס יתר של ConfirmPendingCompletionBlocking, עם הזמן הקצוב לתפוגה שמוגדר ל-10 שנים כברירת מחדל.
CreateTurnBasedMatch(const gpg::TurnBasedMatchConfig & config, TurnBasedMatchCallback callback)	void הפונקציה יוצרת באופן אסינכרוני TurnBasedMatch באמצעות ה-TurnBasedMatchConfig שסופק.
CreateTurnBasedMatchBlocking(Timeout timeout, const gpg::TurnBasedMatchConfig & config)	TurnBasedMatchResponse גרסת חסימה של CreateTurnBasedMatch.
CreateTurnBasedMatchBlocking(const gpg::TurnBasedMatchConfig & config)	TurnBasedMatchResponse עומס יתר של CreateTurnBasedMatchBlocking, שמוגדר כברירת מחדל לחסימה של 10 שנים.
DeclineInvitation(const MultiplayerInvitation & invitation)	void דוחה של MultiplayerInvitation ל-TurnBasedMatch.
DismissInvitation(const MultiplayerInvitation & invitation)	void MultiplayerInvitation נסגר/ת לTurnBasedMatch.
DismissMatch(const TurnBasedMatch & match)	void TurnBasedMatch נסגר.
FetchMatch(const std::string & match_id, TurnBasedMatchCallback callback)	void אחזור אסינכרוני של התאמה ספציפית לפי מזהה.
FetchMatchBlocking(Timeout timeout, const std::string & match_id)	TurnBasedMatchResponse חוסם את גרסת FetchMatch.
FetchMatchBlocking(const std::string & match_id)	TurnBasedMatchResponse עומס יתר של FetchMatchBlocking, שבו הזמן הקצוב לתפוגה שמוגדר כברירת מחדל הוא 10 שנים.
FetchMatches(TurnBasedMatchesCallback callback)	void מאחזר באופן אסינכרוני אובייקטים של TurnBasedMatch ו-Invitation של הנגן הנוכחי.
FetchMatchesBlocking(Timeout timeout)	TurnBasedMatchesResponse חסימת גרסה של FetchMatches.
FetchMatchesBlocking()	TurnBasedMatchesResponse עומס יתר של 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)	TurnBasedMatchResponse גרסת חסימה של FinishMatchDuringMyTurn.
FinishMatchDuringMyTurnBlocking(const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results)	TurnBasedMatchResponse עומס יתר של FinishMatchDuringMyTurnBlocking, שמוגדר כברירת מחדל ל-10 שנים.
LeaveMatchDuringMyTurn(const TurnBasedMatch & match, const MultiplayerParticipant & next_participant, MultiplayerStatusCallback callback)	void הוא משאיר משחק באופן אסינכרוני בזמן בתורו של המשתתף המקומי.
LeaveMatchDuringMyTurnBlocking(Timeout timeout, const TurnBasedMatch & match, const MultiplayerParticipant & next_participant)	MultiplayerStatus גרסת חסימה של LeaveMatchDuringMyTurn.
LeaveMatchDuringMyTurnBlocking(const TurnBasedMatch & match, const MultiplayerParticipant & next_participant)	MultiplayerStatus עומס יתר של LeaveMatchDuringMyTurnBlocking, שמוגדר כברירת מחדל ל-10 שנים.
LeaveMatchDuringTheirTurn(const TurnBasedMatch & match, MultiplayerStatusCallback callback)	void הוא משאיר משחק באופן אסינכרוני בתורו של משתתף אחר.
LeaveMatchDuringTheirTurnBlocking(Timeout timeout, const TurnBasedMatch & match)	MultiplayerStatus גרסת חסימה של LeaveMatchDuringTheirTurn.
LeaveMatchDuringTheirTurnBlocking(const TurnBasedMatch & match)	MultiplayerStatus עומס יתר של LeaveMatchDuringTheirTurnBlocking, שמוגדרת בהם ברירת המחדל של 10 שנים עם הזמן הקצוב לתפוגה שמוגדר כברירת מחדל.
Rematch(const TurnBasedMatch & match, TurnBasedMatchCallback callback)	void מחזירה התאמה שהמצב שלה הוא MatchStatus::COMPLETED.
RematchBlocking(Timeout timeout, const TurnBasedMatch & match)	TurnBasedMatchResponse חסימת גרסה של התאמה חוזרת.
RematchBlocking(const TurnBasedMatch & match)	TurnBasedMatchResponse עומס יתר של RematchBlocking, שבו הזמן הקצוב לתפוגה שמוגדר כברירת מחדל הוא 10 שנים.
ShowMatchInboxUI(MatchInboxUICallback callback)	void מציג באופן אסינכרוני את ממשק המשתמש של תיבת הדואר הנכנס התואם, וכך השחקן יכול לבחור התאמה או הזמנה.
ShowMatchInboxUIBlocking(Timeout timeout)	MatchInboxUIResponse גרסת חסימה של ShowMatchInboxUI.
ShowMatchInboxUIBlocking()	MatchInboxUIResponse עומס יתר של 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)	PlayerSelectUIResponse גרסת חסימה של ShowPlayerSelectUI.
ShowPlayerSelectUIBlocking(uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch)	PlayerSelectUIResponse עומס יתר של 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)	TurnBasedMatchResponse גרסת חסימה של TakeMyTurn.
TakeMyTurnBlocking(const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant)	TurnBasedMatchResponse עומס יתר של TakeMyTurnBlocking, עם הזמן הקצוב לתפוגה שמוגדר ל-10 שנים כברירת מחדל.

מבנים
gpg::TurnBasedMultiplayerManager::MatchInboxUIResponse	Data ו-ResponseStatus לפעולה ShowMatchInboxUI.
gpg::TurnBasedMultiplayerManager::PlayerSelectUIResponse	Data ו-ResponseStatus לפעולה ShowPlayerSelectUI.
gpg::TurnBasedMultiplayerManager::TurnBasedMatchResponse	Data ו-ResponseStatus עבור TurnBasedMatch ספציפי.
gpg::TurnBasedMultiplayerManager::TurnBasedMatchesResponse	Data ו-ResponseStatus עבור TurnBasedMatches והזמנות.

סוגים ציבוריים

MatchInboxUICallback

std::function< void(const MatchInboxUIResponse &)> MatchInboxUICallback

מגדיר קריאה חוזרת (callback) שיכולה לקבל MatchInboxUIResponse מ-ShowMatchInboxUI.

MultiplayerStatusCallback

std::function< void(MultiplayerStatus)> MultiplayerStatusCallback

מגדיר קריאה חוזרת (callback) שאפשר להשתמש בה כדי לקבל סטטוס רב-משתתפים.

משמש את הפונקציות AllowMatch ו-CancelMatch.

PlayerSelectUICallback

std::function< void(const PlayerSelectUIResponse &)> PlayerSelectUICallback

מגדיר קריאה חוזרת (callback) שיכולה לקבל PlayerSelectUIResponse מ-ShowPlayerSelectUI.

TurnBasedMatchCallback

std::function< void(const TurnBasedMatchResponse &)> TurnBasedMatchCallback

מגדיר קריאה חוזרת (callback) שאפשר להשתמש בה כדי לקבל TurnBasedMatchResponse מאחת מהפעולות למשחק רב-משתתפים לפי תור.

TurnBasedMatchesCallback

std::function< void(const TurnBasedMatchesResponse &)> TurnBasedMatchesCallback

מגדיר קריאה חוזרת (callback) שיכולה לקבל TurnBasedMatchesResponse מאחת מהפעולות למשחק רב-משתתפים לפי תור.

מאפיינים סטטיים ציבוריים

kAutomatchingParticipant

const MultiplayerParticipant kAutomatchingParticipant

משתתף שניתן להעביר ל-methods שנמצאות בשלב "הבא" משתתף".

הפעולה הזו תגרום לשיטה לבחור את המשתתף הבא באמצעות התאמה אוטומטית. אפשר להעביר את kAutomatchingParticipant לפונקציה רק אם הערך של 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 מציין אם הפעולה הצליחה. כדי שניתן יהיה להשתמש בפונקציה הזו, סטטוס ההתאמה חייב להיות משתתף [הזמנה], [THIR_TURN] או MY_TURN.

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.

פרטים
פרמטרים	match ההתאמה שיש לאשר את השלמתה. callback הקריאה החוזרת (callback) מקבלת TurnBasedMatchResponse.

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
)

הפונקציה יוצרת באופן אסינכרוני TurnBasedMatch באמצעות ה-TurnBasedMatchConfig שסופק.

אם היצירה בוצעה בהצלחה, הפונקציה הזו מחזירה את TurnBasedMatch דרך ה-TurnBasedMatchCallback שסופק. 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
)

MultiplayerInvitation נסגר/ת לTurnBasedMatch.

הפעולה הזו לא משנה את המצב הגלוי של 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.

פרטים
פרמטרים	match המשחק הסתיים. match_data אובייקט blob של נתונים שמייצג את המצב הסופי של ההתאמה. results כל התוצאות לגבי כל שחקן במשחק. לתשומת ליבכם: אסור שהתוצאות האלה סותרות את התוצאות שצוינו קודם באמצעות TakeTurn. ניסיון להגדיר תוצאות שונות לשחקן יוביל ל-ERROR_INVALID_RESULTS. callback הקריאה החוזרת שמקבלת את TurnBasedMatchResponse.

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.

פרטים
פרמטרים	match ההתאמה ליציאה. next_participant המשתתף הבא בתור. יכול להיות שייעשה שימוש ב-TurnBasedMultiplayerManager::kAutomatchingParticipant כדי לציין שצריך לבחור את המשתתף הבא באמצעות התאמה אוטומטית. callback הקריאה החוזרת שמקבלת את TurnBasedMatchResponse

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 יקבל את ההתאמה החדשה.

פרטים
פרמטרים	match משחק חוזר. callback הקריאה החוזרת שמקבלת TurnBasedMatchResponse

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.

פרטים

פרמטרים

match ההתאמה שבה מתרחש התור. match_data blob של נתונים לשליחה למשתתף הבא. results כל התוצאות הידועות של המשחק בשלב הנוכחי. שימו לב: ניתן לציין את התוצאה של שחקן מסוים רק פעם אחת. ניסיון להגדיר תוצאות שונות לשחקן יוביל ל-ERROR_INVALID_RESULTS. next_participant המשתתף הבא בתור. יכול להיות שייעשה שימוש ב-TurnBasedMultiplayerManager::kAutomatchingParticipant כדי לציין שצריך לבחור את המשתתף הבא באמצעות התאמה אוטומטית. callback הקריאה החוזרת שמקבלת את TurnBasedMatchResponse.

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 שנים כברירת מחדל.