public void Finish(GooglePlayGames.BasicApi.Multiplayer.TurnBasedMatch match, byte[] data, MatchOutcome outcome, Action <bool> callback)
{
callback = Callbacks.AsOnGameThreadCallback <bool>(callback);
this.FindEqualVersionMatch(match, callback, (Action <NativeTurnBasedMatch>)(foundMatch =>
{
GooglePlayGames.Native.PInvoke.ParticipantResults results = foundMatch.Results();
using (List <string> .Enumerator enumerator = outcome.ParticipantIds.GetEnumerator())
{
while (enumerator.MoveNext())
{
string current = enumerator.Current;
Types.MatchResult matchResult1 = NativeTurnBasedMultiplayerClient.ResultToMatchResult(outcome.GetResultFor(current));
uint placementFor = outcome.GetPlacementFor(current);
if (results.HasResultsForParticipant(current))
{
Types.MatchResult matchResult2 = results.ResultsForParticipant(current);
uint num = results.PlacingForParticipant(current);
if (matchResult1 != matchResult2 || (int)placementFor != (int)num)
{
Logger.e(string.Format("Attempted to override existing results for participant {0}: Placing {1}, Result {2}", (object)current, (object)num, (object)matchResult2));
callback(false);
return;
}
}
else
{
GooglePlayGames.Native.PInvoke.ParticipantResults participantResults = results;
results = participantResults.WithResult(current, placementFor, matchResult1);
participantResults.Dispose();
}
}
}
this.mTurnBasedManager.FinishMatchDuringMyTurn(foundMatch, data, results, (Action <TurnBasedManager.TurnBasedMatchResponse>)(response => callback(response.RequestSucceeded())));
}));
}
public void Finish(GooglePlayGames.BasicApi.Multiplayer.TurnBasedMatch match, byte[] data, MatchOutcome outcome, Action <bool> callback)
{
callback = Callbacks.AsOnGameThreadCallback(callback);
FindEqualVersionMatch(match, callback, delegate(NativeTurnBasedMatch foundMatch)
{
GooglePlayGames.Native.PInvoke.ParticipantResults participantResults = foundMatch.Results();
foreach (string participantId in outcome.ParticipantIds)
{
Types.MatchResult matchResult = ResultToMatchResult(outcome.GetResultFor(participantId));
uint placementFor = outcome.GetPlacementFor(participantId);
if (participantResults.HasResultsForParticipant(participantId))
{
Types.MatchResult matchResult2 = participantResults.ResultsForParticipant(participantId);
uint num = participantResults.PlacingForParticipant(participantId);
if (matchResult != matchResult2 || placementFor != num)
{
Logger.e($"Attempted to override existing results for participant {participantId}: Placing {num}, Result {matchResult2}");
callback(false);
return;
}
}
else
{
GooglePlayGames.Native.PInvoke.ParticipantResults participantResults2 = participantResults;
participantResults = participantResults2.WithResult(participantId, placementFor, matchResult);
participantResults2.Dispose();
}
}
mTurnBasedManager.FinishMatchDuringMyTurn(foundMatch, data, participantResults, delegate(TurnBasedManager.TurnBasedMatchResponse response)
{
callback(response.RequestSucceeded());
});
});
}
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 ParticipantResults WithResult(string participantId, uint placing, Types.MatchResult result) => new ParticipantResults(ParticipantResults.ParticipantResults_WithResult(base.SelfPtr(), participantId, placing, result));
internal Types.MatchResult ResultsForParticipant(string participantId) => ParticipantResults.ParticipantResults_MatchResultForParticipant(base.SelfPtr(), participantId);
internal uint PlacingForParticipant(string participantId) => ParticipantResults.ParticipantResults_PlaceForParticipant(base.SelfPtr(), participantId);
internal bool HasResultsForParticipant(string participantId) => ParticipantResults.ParticipantResults_HasResultsForParticipant(base.SelfPtr(), participantId);
protected override void CallDispose(HandleRef selfPointer)
{
ParticipantResults.ParticipantResults_Dispose(selfPointer);
}
