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));
}
