internal void ConfirmPendingCompletion(NativeTurnBasedMatch match, Action <TurnBasedMatchResponse> callback) { TurnBasedMultiplayerManager.TurnBasedMultiplayerManager_ConfirmPendingCompletion( mGameServices.AsHandle(), match.AsPointer(), InternalTurnBasedMatchCallback, ToCallbackPointer(callback)); }
internal void LeaveMatchDuringTheirTurn(NativeTurnBasedMatch match, Action <MultiplayerStatus> callback) { TurnBasedMultiplayerManager.TurnBasedMultiplayerManager_LeaveMatchDuringTheirTurn( mGameServices.AsHandle(), match.AsPointer(), InternalMultiplayerStatusCallback, Callbacks.ToIntPtr(callback)); }
internal void Rematch(NativeTurnBasedMatch match, Action <TurnBasedMatchResponse> callback) { TurnBasedMultiplayerManager.TurnBasedMultiplayerManager_Rematch( mGameServices.AsHandle(), match.AsPointer(), InternalTurnBasedMatchCallback, ToCallbackPointer(callback)); }
internal void CancelMatch(NativeTurnBasedMatch match, Action <MultiplayerStatus> callback) { TurnBasedMultiplayerManager.TurnBasedMultiplayerManager_CancelMatch( mGameServices.AsHandle(), match.AsPointer(), InternalMultiplayerStatusCallback, Callbacks.ToIntPtr(callback)); }
internal void LeaveDuringMyTurn(NativeTurnBasedMatch match, MultiplayerParticipant nextParticipant, Action <MultiplayerStatus> callback) { C.TurnBasedMultiplayerManager_LeaveMatchDuringMyTurn( mGameServices.AsHandle(), match.AsPointer(), nextParticipant.AsPointer(), InternalMultiplayerStatusCallback, Callbacks.ToIntPtr(callback) ); }
internal void FinishMatchDuringMyTurn(NativeTurnBasedMatch match, byte[] data, ParticipantResults results, Action <TurnBasedMatchResponse> callback) { TurnBasedMultiplayerManager.TurnBasedMultiplayerManager_FinishMatchDuringMyTurn( mGameServices.AsHandle(), match.AsPointer(), data, new UIntPtr((uint)data.Length), results.AsPointer(), InternalTurnBasedMatchCallback, ToCallbackPointer(callback) ); }
internal void TakeTurn(NativeTurnBasedMatch match, byte[] data, MultiplayerParticipant nextParticipant, Action <TurnBasedMatchResponse> callback) { TurnBasedMultiplayerManager.TurnBasedMultiplayerManager_TakeMyTurn( mGameServices.AsHandle(), match.AsPointer(), data, new UIntPtr((uint)data.Length), // Just pass along the old results. Technically the API allows updates here, but // we never need them. match.Results().AsPointer(), nextParticipant.AsPointer(), InternalTurnBasedMatchCallback, ToCallbackPointer(callback)); }
private static void InternalOnTurnBasedMatchEventCallback(Types.MultiplayerEvent eventType, string matchId, IntPtr match, IntPtr userData) { Action <Types.MultiplayerEvent, string, NativeTurnBasedMatch> action = Callbacks.IntPtrToPermanentCallback <Action <Types.MultiplayerEvent, string, NativeTurnBasedMatch> >(userData); using (NativeTurnBasedMatch arg = NativeTurnBasedMatch.FromPointer(match)) { try { action?.Invoke(eventType, matchId, arg); } catch (Exception arg2) { Logger.e("Error encountered executing InternalOnTurnBasedMatchEventCallback. Smothering to avoid passing exception into Native: " + arg2); } } }
private static void InternalOnTurnBasedMatchEventCallback(Types.MultiplayerEvent eventType, string matchId, IntPtr match, IntPtr userData) { var callback = Callbacks.IntPtrToPermanentCallback <Action <Types.MultiplayerEvent, string, NativeTurnBasedMatch> >(userData); using (var nativeMatch = NativeTurnBasedMatch.FromPointer(match)) { try { if (callback != null) { callback(eventType, matchId, nativeMatch); } } catch (Exception e) { Logger.e("Error encountered executing InternalOnTurnBasedMatchEventCallback. " + "Smothering to avoid passing exception into Native: " + e); } } }
private static void InternalOnTurnBasedMatchEventCallback(Types.MultiplayerEvent eventType, string matchId, IntPtr match, IntPtr userData) { Action <Types.MultiplayerEvent, string, NativeTurnBasedMatch> permanentCallback = Callbacks.IntPtrToPermanentCallback <Action <Types.MultiplayerEvent, string, NativeTurnBasedMatch> >(userData); using (NativeTurnBasedMatch nativeTurnBasedMatch = NativeTurnBasedMatch.FromPointer(match)) { try { if (permanentCallback == null) { return; } permanentCallback(eventType, matchId, nativeTurnBasedMatch); } catch (Exception ex) { Logger.e("Error encountered executing InternalOnTurnBasedMatchEventCallback. Smothering to avoid passing exception into Native: " + (object)ex); } } }
private static void InternalOnTurnBasedMatchEventCallback(Types.MultiplayerEvent eventType, string matchId, IntPtr match, IntPtr userData) { Action <Types.MultiplayerEvent, string, NativeTurnBasedMatch> action = Callbacks.IntPtrToPermanentCallback <Action <Types.MultiplayerEvent, string, NativeTurnBasedMatch> >(userData); NativeTurnBasedMatch match2 = NativeTurnBasedMatch.FromPointer(match); try { if (action != null) { action(eventType, matchId, match2); } } catch (Exception exception) { Logger.e("Error encountered executing InternalOnTurnBasedMatchEventCallback. Smothering to avoid passing exception into Native: " + exception); } finally { if (match2 != null) { match2.Dispose(); } } }
internal void LeaveMatchDuringTheirTurn(NativeTurnBasedMatch match, Action<MultiplayerStatus> callback) { TurnBasedMultiplayerManager.TurnBasedMultiplayerManager_LeaveMatchDuringTheirTurn( mGameServices.AsHandle(), match.AsPointer(), InternalMultiplayerStatusCallback, Callbacks.ToIntPtr(callback)); }
internal void DismissMatch(NativeTurnBasedMatch match) { TurnBasedMultiplayerManager.TurnBasedMultiplayerManager_DismissMatch( mGameServices.AsHandle(), match.AsPointer()); }
internal void HandleMatchEvent(Types.MultiplayerEvent eventType, string matchId, NativeTurnBasedMatch match) { // Capture the current value of the delegate to protect against racing updates. var currentDelegate = mMatchDelegate; if (currentDelegate == null) { return; } // Ignore REMOVED events - this plugin has no use for them. if (eventType == Types.MultiplayerEvent.REMOVED) { Logger.d("Ignoring REMOVE event for match " + matchId); return; } bool shouldAutolaunch = eventType == Types.MultiplayerEvent.UPDATED_FROM_APP_LAUNCH; match.ReferToMe(); Callbacks.AsCoroutine(WaitForLogin(()=> {currentDelegate(match.AsTurnBasedMatch(mNativeClient.GetUserId()), shouldAutolaunch); match.ForgetMe();})); }
internal void CancelMatch(NativeTurnBasedMatch match, Action <CommonErrorStatus.MultiplayerStatus> callback) { TurnBasedMultiplayerManager.TurnBasedMultiplayerManager_CancelMatch(this.mGameServices.AsHandle(), match.AsPointer(), new TurnBasedMultiplayerManager.MultiplayerStatusCallback(TurnBasedManager.InternalMultiplayerStatusCallback), Callbacks.ToIntPtr((Delegate)callback)); }
internal void TakeTurn(NativeTurnBasedMatch match, byte[] data, MultiplayerParticipant nextParticipant, Action <TurnBasedManager.TurnBasedMatchResponse> callback) { TurnBasedMultiplayerManager.TurnBasedMultiplayerManager_TakeMyTurn(this.mGameServices.AsHandle(), match.AsPointer(), data, new UIntPtr((uint)data.Length), match.Results().AsPointer(), nextParticipant.AsPointer(), new TurnBasedMultiplayerManager.TurnBasedMatchCallback(TurnBasedManager.InternalTurnBasedMatchCallback), TurnBasedManager.ToCallbackPointer(callback)); }
internal GooglePlayGames.BasicApi.Multiplayer.TurnBasedMatch AsTurnBasedMatch(string selfPlayerId) { List <Participant> participants = new List <Participant>(); string selfParticipantId = (string)null; string pendingParticipantId = (string)null; using (MultiplayerParticipant multiplayerParticipant = this.PendingParticipant()) { if (multiplayerParticipant != null) { pendingParticipantId = multiplayerParticipant.Id(); } } foreach (MultiplayerParticipant participant in this.Participants()) { using (participant) { using (NativePlayer nativePlayer = participant.Player()) { if (nativePlayer != null) { if (nativePlayer.Id().Equals(selfPlayerId)) { selfParticipantId = participant.Id(); } } } participants.Add(participant.AsParticipant()); } } return(new GooglePlayGames.BasicApi.Multiplayer.TurnBasedMatch(this.Id(), this.Data(), this.MatchStatus() == Types.MatchStatus.COMPLETED && !this.HasRematchId(), selfParticipantId, participants, this.AvailableAutomatchSlots(), pendingParticipantId, NativeTurnBasedMatch.ToTurnStatus(this.MatchStatus()), NativeTurnBasedMatch.ToMatchStatus(pendingParticipantId, this.MatchStatus()), this.Variant(), this.Version())); }
internal void LeaveDuringMyTurn(NativeTurnBasedMatch match, MultiplayerParticipant nextParticipant, Action <CommonErrorStatus.MultiplayerStatus> callback) { TurnBasedMultiplayerManager.TurnBasedMultiplayerManager_LeaveMatchDuringMyTurn(this.mGameServices.AsHandle(), match.AsPointer(), nextParticipant.AsPointer(), new TurnBasedMultiplayerManager.MultiplayerStatusCallback(TurnBasedManager.InternalMultiplayerStatusCallback), Callbacks.ToIntPtr((Delegate)callback)); }
internal void TakeTurn(NativeTurnBasedMatch match, byte[] data, MultiplayerParticipant nextParticipant, Action<TurnBasedMatchResponse> callback) { TurnBasedMultiplayerManager.TurnBasedMultiplayerManager_TakeMyTurn( mGameServices.AsHandle(), match.AsPointer(), data, new UIntPtr((uint)data.Length), // Just pass along the old results. Technically the API allows updates here, but // we never need them. match.Results().AsPointer(), nextParticipant.AsPointer(), InternalTurnBasedMatchCallback, ToCallbackPointer(callback)); }
internal void LeaveDuringMyTurn(NativeTurnBasedMatch match, MultiplayerParticipant nextParticipant, Action<MultiplayerStatus> callback) { C.TurnBasedMultiplayerManager_LeaveMatchDuringMyTurn( mGameServices.AsHandle(), match.AsPointer(), nextParticipant.AsPointer(), InternalMultiplayerStatusCallback, Callbacks.ToIntPtr(callback) ); }
internal void CancelMatch(NativeTurnBasedMatch match, Action<MultiplayerStatus> callback) { TurnBasedMultiplayerManager.TurnBasedMultiplayerManager_CancelMatch( mGameServices.AsHandle(), match.AsPointer(), InternalMultiplayerStatusCallback, Callbacks.ToIntPtr(callback)); }
internal void FinishMatchDuringMyTurn(NativeTurnBasedMatch match, byte[] data, ParticipantResults results, Action<TurnBasedMatchResponse> callback) { TurnBasedMultiplayerManager.TurnBasedMultiplayerManager_FinishMatchDuringMyTurn( mGameServices.AsHandle(), match.AsPointer(), data, new UIntPtr((uint)data.Length), results.AsPointer(), InternalTurnBasedMatchCallback, ToCallbackPointer(callback) ); }
internal void ConfirmPendingCompletion(NativeTurnBasedMatch match, Action<TurnBasedMatchResponse> callback) { TurnBasedMultiplayerManager.TurnBasedMultiplayerManager_ConfirmPendingCompletion( mGameServices.AsHandle(), match.AsPointer(), InternalTurnBasedMatchCallback, ToCallbackPointer(callback)); }
internal void Rematch(NativeTurnBasedMatch match, Action<TurnBasedMatchResponse> callback) { TurnBasedMultiplayerManager.TurnBasedMultiplayerManager_Rematch( mGameServices.AsHandle(), match.AsPointer(), InternalTurnBasedMatchCallback, ToCallbackPointer(callback)); }
internal void LeaveMatchDuringTheirTurn(NativeTurnBasedMatch match, Action <GooglePlayGames.Native.Cwrapper.CommonErrorStatus.MultiplayerStatus> callback) { TurnBasedMultiplayerManager.TurnBasedMultiplayerManager_LeaveMatchDuringTheirTurn(this.mGameServices.AsHandle(), match.AsPointer(), new TurnBasedMultiplayerManager.MultiplayerStatusCallback(TurnBasedManager.InternalMultiplayerStatusCallback), Callbacks.ToIntPtr(callback)); }