public static bool IsEqual(Json_MyPhotonPlayerBinaryParam data0, Json_MyPhotonPlayerBinaryParam data1)
{
bool flag = true & data0.playerID == data1.playerID & data0.playerIndex == data1.playerIndex & data0.playerName == data1.playerName & data0.playerLevel == data1.playerLevel & data0.FUID == data1.FUID & data0.UID == data1.UID & data0.totalAtk == data1.totalAtk & data0.totalStatus == data1.totalStatus & data0.rankpoint == data1.rankpoint & data0.award == data1.award & data0.state == data1.state & data0.rankmatch_score == data1.rankmatch_score & data0.support_unit == data1.support_unit & data0.draft_id == data1.draft_id;
if (data0.units != null && data1.units != null && data0.units.Length == data1.units.Length)
{
for (int index = 0; index < data0.units.Length; ++index)
{
flag = flag & data0.units[index].slotID == data1.units[index].slotID & data0.units[index].place == data1.units[index].place & JsonUtility.ToJson((object)data0.units[index].unitJson).Equals(JsonUtility.ToJson((object)data1.units[index].unitJson));
}
}
return(flag);
}
public override void Update(FlowNode_StartMultiPlay self)
{
MyPhoton instance = PunMonoSingleton <MyPhoton> .Instance;
if (instance.CurrentState != MyPhoton.MyState.ROOM)
{
self.Failure();
}
else
{
MyPhoton.MyRoom currentRoom = instance.GetCurrentRoom();
if (currentRoom == null)
{
self.Failure();
}
else
{
JSON_MyPhotonRoomParam myPhotonRoomParam = !string.IsNullOrEmpty(currentRoom.json) ? JSON_MyPhotonRoomParam.Parse(currentRoom.json) : (JSON_MyPhotonRoomParam)null;
if (myPhotonRoomParam == null)
{
self.Failure();
}
else
{
if (myPhotonRoomParam.started == 0)
{
myPhotonRoomParam.started = 1;
instance.SetRoomParam(myPhotonRoomParam.Serialize());
}
if ((double)this.mStartWait > 0.0)
{
this.mStartWait -= Time.get_deltaTime();
if ((double)this.mStartWait > 0.0)
{
return;
}
GlobalVars.SelectedQuestID = myPhotonRoomParam.iname;
GlobalVars.SelectedFriendID = (string)null;
GlobalVars.SelectedFriend = (FriendData)null;
GlobalVars.SelectedSupport.Set((SupportData)null);
self.Success();
DebugUtility.Log("StartMultiPlay: " + myPhotonRoomParam.Serialize());
}
else if ((double)this.mWait > 0.0)
{
this.mWait -= Time.get_deltaTime();
}
else
{
List <MyPhoton.MyPlayer> roomPlayerList = instance.GetRoomPlayerList();
if ((myPhotonRoomParam.type == 1 || myPhotonRoomParam.type == 3) && roomPlayerList.Count == 1)
{
self.FailureStartMulti();
}
else if (this.mConfirm)
{
using (List <MyPhoton.MyPlayer> .Enumerator enumerator = roomPlayerList.GetEnumerator())
{
while (enumerator.MoveNext())
{
JSON_MyPhotonPlayerParam photonPlayerParam = JSON_MyPhotonPlayerParam.Parse(enumerator.Current.json);
if (photonPlayerParam.state != 3)
{
return;
}
if (photonPlayerParam.state < 2)
{
self.Failure();
return;
}
}
}
this.mStartWait = 0.1f;
}
else
{
MyPhoton.MyPlayer myPlayer = instance.GetMyPlayer();
if (this.mRecvList.Count <= 0)
{
this.mSend.senderPlayerID = myPlayer.photonPlayerID;
this.mSend.playerListJson = (string)null;
List <JSON_MyPhotonPlayerParam> photonPlayerParamList = new List <JSON_MyPhotonPlayerParam>();
for (int index = 0; index < roomPlayerList.Count; ++index)
{
JSON_MyPhotonPlayerParam photonPlayerParam = JSON_MyPhotonPlayerParam.Parse(roomPlayerList[index].json);
photonPlayerParamList.Add(photonPlayerParam);
}
photonPlayerParamList.Sort((Comparison <JSON_MyPhotonPlayerParam>)((a, b) => a.playerIndex - b.playerIndex));
FlowNode_StartMultiPlay.PlayerList playerList = new FlowNode_StartMultiPlay.PlayerList();
playerList.players = photonPlayerParamList.ToArray();
Json_MyPhotonPlayerBinaryParam[] playerBinaryParamArray = new Json_MyPhotonPlayerBinaryParam[playerList.players.Length];
for (int index = 0; index < playerList.players.Length; ++index)
{
playerList.players[index].CreateJsonUnitData();
playerBinaryParamArray[index] = new Json_MyPhotonPlayerBinaryParam();
playerBinaryParamArray[index].Set(playerList.players[index]);
}
this.mSend.playerList = playerBinaryParamArray;
byte[] msg = GameUtility.Object2Binary <FlowNode_StartMultiPlay.RecvData>(this.mSend);
instance.SendRoomMessageBinary(true, msg, MyPhoton.SEND_TYPE.Sync, false);
this.mRecvList.Add(this.mSend);
this.mSend.playerListJson = playerList.Serialize();
}
List <MyPhoton.MyEvent> events = instance.GetEvents();
for (int index = events.Count - 1; index >= 0; --index)
{
FlowNode_StartMultiPlay.RecvData buffer = (FlowNode_StartMultiPlay.RecvData)null;
if (!GameUtility.Binary2Object <FlowNode_StartMultiPlay.RecvData>(out buffer, events[index].binary))
{
DebugUtility.LogError("[PUN] started player list version error: " + events[index].json);
instance.Disconnect();
return;
}
if (buffer == null || buffer.version < this.mSend.version)
{
DebugUtility.LogError("[PUN] started player list version error: " + events[index].json);
instance.Disconnect();
return;
}
if (buffer.version <= this.mSend.version)
{
buffer.senderPlayerID = events[index].playerID;
DebugUtility.Log("[PUN] recv started player list: " + events[index].json);
this.mRecvList.Add(buffer);
events.Remove(events[index]);
}
}
using (List <MyPhoton.MyPlayer> .Enumerator enumerator = roomPlayerList.GetEnumerator())
{
while (enumerator.MoveNext())
{
MyPhoton.MyPlayer p = enumerator.Current;
if (this.mRecvList.FindIndex((Predicate <FlowNode_StartMultiPlay.RecvData>)(r => r.senderPlayerID == p.photonPlayerID)) < 0)
{
return;
}
}
}
bool flag = true;
using (List <FlowNode_StartMultiPlay.RecvData> .Enumerator enumerator = this.mRecvList.GetEnumerator())
{
while (enumerator.MoveNext())
{
FlowNode_StartMultiPlay.RecvData current = enumerator.Current;
if (current.playerList.Length == this.mSend.playerList.Length)
{
for (int index = 0; index < this.mSend.playerList.Length; ++index)
{
if (!Json_MyPhotonPlayerBinaryParam.IsEqual(current.playerList[index], this.mSend.playerList[index]))
{
flag = false;
}
}
if (!flag)
{
break;
}
}
else
{
flag = false;
break;
}
}
}
if (!flag)
{
DebugUtility.Log("[PUN] started player list is not equal. ver:" + (object)this.mSend.version);
this.mRecvList.Clear();
++this.mSend.version;
this.mWait = 1f;
}
else
{
DebugUtility.Log("[PUN]started player list decided. ver:" + (object)this.mSend.version);
List <JSON_MyPhotonPlayerParam> myPlayersStarted = instance.GetMyPlayersStarted();
myPlayersStarted.Clear();
foreach (JSON_MyPhotonPlayerParam player in JSONParser.parseJSONObject <FlowNode_StartMultiPlay.PlayerList>(this.mSend.playerListJson).players)
{
player.SetupUnits();
myPlayersStarted.Add(player);
}
if (instance.IsOldestPlayer())
{
instance.UpdateRoomParam("started", (object)this.mSend.playerListJson);
}
if (events.Count > 0)
{
DebugUtility.LogError("[PUN] event must be empty.");
}
events.Clear();
JSON_MyPhotonPlayerParam photonPlayerParam = JSON_MyPhotonPlayerParam.Parse(myPlayer.json);
photonPlayerParam.state = 3;
instance.SetMyPlayerParam(photonPlayerParam.Serialize());
this.mConfirm = true;
}
}
}
}
}
}
}