public override void OnActivate(int pinID)
{
if (pinID != 0)
{
return;
}
PlayerData player = MonoSingleton <GameManager> .Instance.Player;
player.AutoSetLeaderUnit();
if (this.SetCurrent)
{
player.SetPartyCurrentIndex((int)GlobalVars.SelectedPartyIndex);
}
PartyData partyCurrent = MonoSingleton <GameManager> .Instance.Player.GetPartyCurrent();
for (int index1 = 0; index1 < player.Partys.Count; ++index1)
{
bool flag = false;
for (int index2 = 0; index2 < partyCurrent.MAX_UNIT; ++index2)
{
if (player.Partys[index1].GetUnitUniqueID(index2) != 0L)
{
flag = true;
break;
}
}
if (!flag)
{
this.ActivateOutputLinks(1800);
return;
}
}
if (Network.Mode == Network.EConnectMode.Offline)
{
this.Success();
}
else
{
bool needUpdateMultiRoom = false;
bool needUpdateMultiRoomMT = false;
MyPhoton instance = PunMonoSingleton <MyPhoton> .Instance;
GameUtility.EScene currentScene = GameUtility.GetCurrentScene();
if (UnityEngine.Object.op_Inequality((UnityEngine.Object)instance, (UnityEngine.Object)null))
{
if (currentScene == GameUtility.EScene.HOME_MULTI || instance.IsResume())
{
needUpdateMultiRoom = instance.IsOldestPlayer();
}
else if (currentScene == GameUtility.EScene.MULTI_TOWER || instance.IsResume())
{
needUpdateMultiRoomMT = instance.IsOldestPlayer();
}
}
((Behaviour)this).set_enabled(true);
this.ExecRequest((WebAPI) new ReqParty(new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback), needUpdateMultiRoom, true, needUpdateMultiRoomMT));
}
}
public override void OnActivate(int pinID)
{
switch (pinID)
{
case 100:
MyPhoton instance1 = PunMonoSingleton <MyPhoton> .Instance;
if (Object.op_Inequality((Object)instance1, (Object)null) && instance1.IsOldestPlayer())
{
MyPhoton.MyRoom currentRoom = instance1.GetCurrentRoom();
if (currentRoom != null)
{
JSON_MyPhotonRoomParam myPhotonRoomParam = JSON_MyPhotonRoomParam.Parse(currentRoom.json);
myPhotonRoomParam.iname = GlobalVars.SelectedQuestID;
instance1.SetRoomParam(myPhotonRoomParam.Serialize());
}
}
this.ActivateOutputLinks(200);
break;
case 101:
MyPhoton instance2 = PunMonoSingleton <MyPhoton> .Instance;
if (Object.op_Inequality((Object)instance2, (Object)null))
{
MyPhoton.MyRoom currentRoom = instance2.GetCurrentRoom();
if (currentRoom != null)
{
GlobalVars.SelectedQuestID = JSON_MyPhotonRoomParam.Parse(currentRoom.json).iname;
break;
}
break;
}
break;
}
this.ActivateOutputLinks(200);
}
private void SetVersusAudienceParam(string text)
{
MyPhoton instance = PunMonoSingleton <MyPhoton> .Instance;
if (!instance.IsMultiVersus)
{
return;
}
if (instance.IsOldestPlayer())
{
int startIndex = text.IndexOf("\"btlinfo\"");
if (startIndex != -1)
{
StringBuilder stringBuilder = new StringBuilder();
string str = text.Substring(startIndex);
string roomParam = instance.GetRoomParam("started");
if (!string.IsNullOrEmpty(roomParam))
{
stringBuilder.Append(roomParam);
--stringBuilder.Length;
stringBuilder.Append(",");
stringBuilder.Append(str);
--stringBuilder.Length;
instance.SetRoomParam("started", stringBuilder.ToString());
}
}
}
instance.BattleStartRoom();
}
public override void Begin(VersusDraftReady self)
{
MyPhoton instance = PunMonoSingleton <MyPhoton> .Instance;
List <JSON_MyPhotonPlayerParam> myPlayersStarted = instance.GetMyPlayersStarted();
List <MyPhoton.MyPlayer> roomPlayerList = instance.GetRoomPlayerList();
for (int index1 = 0; index1 < roomPlayerList.Count; ++index1)
{
JSON_MyPhotonPlayerParam param = JSON_MyPhotonPlayerParam.Parse(roomPlayerList[index1].json);
int index2 = myPlayersStarted.FindIndex((Predicate <JSON_MyPhotonPlayerParam>)(sp => sp.playerID == param.playerID));
if (index2 > -1)
{
myPlayersStarted[index2] = param;
}
}
if (roomPlayerList.Count < 2)
{
MyPhoton.MyPlayer player = instance.GetMyPlayer();
JSON_MyPhotonPlayerParam photonPlayerParam = myPlayersStarted.Find((Predicate <JSON_MyPhotonPlayerParam>)(sp => sp.playerID != player.playerID));
int num1 = 0;
int num2 = 0;
int num3 = 0;
List <JSON_MyPhotonPlayerParam.UnitDataElem> unitDataElemList = new List <JSON_MyPhotonPlayerParam.UnitDataElem>();
for (int index = 0; index < VersusDraftList.VersusDraftUnitDataListEnemy.Count && index < 3; ++index)
{
UnitData unitData = VersusDraftList.VersusDraftUnitDataListEnemy[index];
if (unitData != null)
{
unitDataElemList.Add(new JSON_MyPhotonPlayerParam.UnitDataElem()
{
slotID = num1,
place = index,
unit = unitData
});
num2 = num2 + (int)unitData.Status.param.atk + (int)unitData.Status.param.mag;
num3 = num3 + (int)((double)(int)unitData.Status.param.hp * (double)MonoSingleton <GameManager> .Instance.MasterParam.mStatusCoefficient.HP) + (int)((double)(int)unitData.Status.param.atk * (double)MonoSingleton <GameManager> .Instance.MasterParam.mStatusCoefficient.Attack) + (int)((double)(int)unitData.Status.param.def * (double)MonoSingleton <GameManager> .Instance.MasterParam.mStatusCoefficient.Defense) + (int)((double)(int)unitData.Status.param.mag * (double)MonoSingleton <GameManager> .Instance.MasterParam.mStatusCoefficient.MagAttack) + (int)((double)(int)unitData.Status.param.mnd * (double)MonoSingleton <GameManager> .Instance.MasterParam.mStatusCoefficient.MagDefense) + (int)((double)(int)unitData.Status.param.dex * (double)MonoSingleton <GameManager> .Instance.MasterParam.mStatusCoefficient.Dex) + (int)((double)(int)unitData.Status.param.spd * (double)MonoSingleton <GameManager> .Instance.MasterParam.mStatusCoefficient.Speed) + (int)((double)(int)unitData.Status.param.cri * (double)MonoSingleton <GameManager> .Instance.MasterParam.mStatusCoefficient.Critical) + (int)((double)(int)unitData.Status.param.luk * (double)MonoSingleton <GameManager> .Instance.MasterParam.mStatusCoefficient.Luck) + (int)((double)unitData.GetCombination() * (double)MonoSingleton <GameManager> .Instance.MasterParam.mStatusCoefficient.Combo) + (int)((double)(int)unitData.Status.param.mov * (double)MonoSingleton <GameManager> .Instance.MasterParam.mStatusCoefficient.Move) + (int)((double)(int)unitData.Status.param.jmp * (double)MonoSingleton <GameManager> .Instance.MasterParam.mStatusCoefficient.Jump);
++num1;
}
}
photonPlayerParam.units = unitDataElemList.ToArray();
photonPlayerParam.totalAtk = num2;
photonPlayerParam.totalStatus = Mathf.FloorToInt((float)(num3 / unitDataElemList.Count));
photonPlayerParam.draft_id = -1;
}
if (instance.IsOldestPlayer())
{
instance.UpdateRoomParam("started", (object)new FlowNode_StartMultiPlay.PlayerList()
{
players = myPlayersStarted.ToArray()
}.Serialize());
}
FlowNode_GameObject.ActivateOutputLinks((Component)self, 3);
}
public void OnVersusNoPlayer()
{
MyPhoton instance = PunMonoSingleton <MyPhoton> .Instance;
if (Object.op_Inequality((Object)instance, (Object)null) && instance.IsOldestPlayer())
{
instance.OpenRoom();
}
((Behaviour)this).set_enabled(false);
CriticalSection.Leave(CriticalSections.SceneChange);
Network.RemoveAPI();
this.ActivateOutputLinks(2);
}
public override void OnActivate(int pinID)
{
if (pinID != 101)
{
return;
}
MyPhoton instance = PunMonoSingleton <MyPhoton> .Instance;
if (!instance.IsOldestPlayer())
{
DebugUtility.Log("I'm not room owner");
this.ActivateOutputLinks(2);
}
else
{
MyPhoton.MyRoom currentRoom = instance.GetCurrentRoom();
if (currentRoom == null)
{
DebugUtility.Log("CurrentRoom is null");
this.ActivateOutputLinks(2);
}
else
{
JSON_MyPhotonRoomParam myPhotonRoomParam = JSON_MyPhotonRoomParam.Parse(currentRoom.json);
if (myPhotonRoomParam == null)
{
DebugUtility.Log("no roomParam");
this.ActivateOutputLinks(2);
}
else
{
myPhotonRoomParam.comment = GlobalVars.EditMultiPlayRoomComment;
if (!MyMsgInput.isLegal(myPhotonRoomParam.comment))
{
DebugUtility.Log("comment is not legal");
this.ActivateOutputLinks(2);
}
else
{
DebugUtility.Log("comment:" + myPhotonRoomParam.comment);
instance.SetRoomParam(myPhotonRoomParam.Serialize());
PlayerPrefs.SetString(PlayerData.ROOM_COMMENT_KEY, myPhotonRoomParam.comment);
this.ActivateOutputLinks(1);
}
}
}
}
}
private void FailureStartMulti()
{
MyPhoton instance = PunMonoSingleton <MyPhoton> .Instance;
if (Object.op_Inequality((Object)instance, (Object)null) && instance.IsOldestPlayer())
{
MyPhoton.MyRoom currentRoom = instance.GetCurrentRoom();
if (currentRoom != null)
{
JSON_MyPhotonRoomParam myPhotonRoomParam = !string.IsNullOrEmpty(currentRoom.json) ? JSON_MyPhotonRoomParam.Parse(currentRoom.json) : (JSON_MyPhotonRoomParam)null;
myPhotonRoomParam.started = 0;
instance.SetRoomParam(myPhotonRoomParam.Serialize());
}
instance.OpenRoom();
}
this.Failure();
}
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 (this.mConfirm)
{
using (List <MyPhoton.MyPlayer> .Enumerator enumerator = roomPlayerList.GetEnumerator())
{
while (enumerator.MoveNext())
{
if (JSON_MyPhotonPlayerParam.Parse(enumerator.Current.json).state != 3)
{
return;
}
}
}
this.mStartWait = 0.1f;
}
else
{
MyPhoton.MyPlayer myPlayer = instance.GetMyPlayer();
if (this.mRecvList.Count <= 0)
{
this.mSend.senderPlayerID = myPlayer.playerID;
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));
this.mSend.playerListJson = new FlowNode_StartMultiPlay.PlayerList()
{
players = photonPlayerParamList.ToArray()
}.Serialize();
string msg = this.mSend.Serialize();
DebugUtility.Log("[PUN] send started player list: " + msg);
instance.SendRoomMessage(true, msg, MyPhoton.SEND_TYPE.Normal);
this.mRecvList.Add(this.mSend);
}
List <MyPhoton.MyEvent> events = instance.GetEvents();
for (int index = events.Count - 1; index >= 0; --index)
{
FlowNode_StartMultiPlay.State_GameStart.RecvData jsonObject = JSONParser.parseJSONObject <FlowNode_StartMultiPlay.State_GameStart.RecvData>(events[index].json);
if (jsonObject == null || jsonObject.version < this.mSend.version)
{
DebugUtility.LogError("[PUN] started player list version error: " + events[index].json);
instance.Disconnect();
return;
}
if (jsonObject.version <= this.mSend.version)
{
jsonObject.senderPlayerID = events[index].playerID;
DebugUtility.Log("[PUN] recv started player list: " + events[index].json);
this.mRecvList.Add(jsonObject);
events.Remove(events[index]);
}
}
// ISSUE: object of a compiler-generated type is created
// ISSUE: variable of a compiler-generated type
FlowNode_StartMultiPlay.State_GameStart.\u003CUpdate\u003Ec__AnonStorey217 updateCAnonStorey217 = new FlowNode_StartMultiPlay.State_GameStart.\u003CUpdate\u003Ec__AnonStorey217();
using (List <MyPhoton.MyPlayer> .Enumerator enumerator = roomPlayerList.GetEnumerator())
{
while (enumerator.MoveNext())
{
// ISSUE: reference to a compiler-generated field
updateCAnonStorey217.p = enumerator.Current;
// ISSUE: reference to a compiler-generated method
if (this.mRecvList.FindIndex(new Predicate <FlowNode_StartMultiPlay.State_GameStart.RecvData>(updateCAnonStorey217.\u003C\u003Em__212)) < 0)
{
return;
}
}
}
bool flag = true;
using (List <FlowNode_StartMultiPlay.State_GameStart.RecvData> .Enumerator enumerator = this.mRecvList.GetEnumerator())
{
while (enumerator.MoveNext())
{
if (!enumerator.Current.playerListJson.Equals(this.mSend.playerListJson))
{
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.AddRoomParam("started", 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;
}
}
}
}
}
}
}
public override void Update(FlowNode_StartMultiPlay self)
{
DebugUtility.Log("StartMultiPlay State_Start Update");
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 if (this.mPlayerNum != currentRoom.playerCount)
{
self.FailureStartMulti();
}
else if (!instance.IsOldestPlayer() && !currentRoom.start)
{
self.Failure();
}
else
{
bool flag = true;
using (List <MyPhoton.MyPlayer> .Enumerator enumerator = instance.GetRoomPlayerList().GetEnumerator())
{
while (enumerator.MoveNext())
{
JSON_MyPhotonPlayerParam photonPlayerParam = JSON_MyPhotonPlayerParam.Parse(enumerator.Current.json);
if (photonPlayerParam.state != 2)
{
flag = false;
if (instance.IsOldestPlayer())
{
if (!instance.IsOldestPlayer(photonPlayerParam.playerID))
{
if (photonPlayerParam.state != 1)
{
self.FailureStartMulti();
return;
}
}
else
{
continue;
}
}
DebugUtility.Log("StartMultiPlay State_Start Update allStart is false");
break;
}
}
}
if (flag)
{
DebugUtility.Log("StartMultiPlay State_Start Update change state to game start");
self.GotoState <FlowNode_StartMultiPlay.State_GameStart>();
}
else if (currentRoom.start)
{
DebugUtility.Log("StartMultiPlay State_Start Update room is closed");
JSON_MyPhotonPlayerParam photonPlayerParam = JSON_MyPhotonPlayerParam.Parse(instance.GetMyPlayer().json);
if (photonPlayerParam.state == 2)
{
return;
}
photonPlayerParam.state = 2;
instance.SetMyPlayerParam(photonPlayerParam.Serialize());
DebugUtility.Log("StartMultiPlay State_Start Update update my state");
}
else
{
if (!instance.IsOldestPlayer())
{
return;
}
DebugUtility.Log("StartMultiPlay State_Start Update close room");
instance.CloseRoom();
}
}
}
}
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;
}
}
}
}
}
}
}
public override void OnActivate(int pinID)
{
GameManager instance = MonoSingleton <GameManager> .Instance;
MyPhoton pt = PunMonoSingleton <MyPhoton> .Instance;
instance.AudienceMode = false;
this.mReqID = pinID;
pt.IsMultiPlay = false;
pt.IsMultiVersus = false;
instance.IsVSCpuBattle = false;
pt.IsRankMatch = false;
if (pinID == 0 || pinID == 100 || (pinID == 200 || pinID == 250) || (pinID == 500 || pinID == 700 || pinID == 1000))
{
pt.IsMultiPlay = pinID == 100 || pinID == 200 || pinID == 250 || pinID == 500;
pt.IsMultiVersus = pinID == 200 || pinID == 250;
instance.IsVSCpuBattle = pinID == 700;
pt.IsRankMatch = pinID == 250;
pinID = 0;
}
if (pinID == 10)
{
this.mResume = true;
pinID = 0;
}
if (pinID == 0)
{
if (((Behaviour)this).get_enabled())
{
return;
}
((Behaviour)this).set_enabled(true);
CriticalSection.Enter(CriticalSections.SceneChange);
if (this.mResume)
{
long btlId = (long)GlobalVars.BtlID;
GlobalVars.BtlID.Set(0L);
this.ExecRequest((WebAPI) new ReqBtlComResume(btlId, new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback)));
}
else
{
this.mStartingQuest = instance.FindQuest(GlobalVars.SelectedQuestID);
PlayerPartyTypes partyIndex1 = this.QuestToPartyIndex(this.mStartingQuest.type);
if (!string.IsNullOrEmpty(this.QuestID))
{
GlobalVars.SelectedQuestID = this.QuestID;
GlobalVars.SelectedFriendID = string.Empty;
}
if (!this.PlayOffline && Network.Mode == Network.EConnectMode.Online)
{
if (this.mStartingQuest.type == QuestTypes.Arena)
{
this.ActivateOutputLinks(5);
this.StartCoroutine(this.StartScene((BattleCore.Json_Battle)null));
}
else if (this.mStartingQuest.type == QuestTypes.Ordeal)
{
this.ExecRequest((WebAPI) new ReqBtlOrdealReq(this.mStartingQuest.iname, GlobalVars.OrdealSupports, new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback)));
}
else
{
PartyData partyOfType = instance.Player.FindPartyOfType(partyIndex1);
int partyIndex2 = instance.Player.Partys.IndexOf(partyOfType);
bool multi = false;
bool isHost = false;
int seat = -1;
int plid = -1;
string uid = string.Empty;
List <string> stringList = new List <string>();
VersusStatusData versusStatusData = (VersusStatusData)null;
int num1 = 0;
if (UnityEngine.Object.op_Inequality((UnityEngine.Object)pt, (UnityEngine.Object)null))
{
multi = pt.IsMultiPlay;
isHost = pt.IsOldestPlayer();
seat = pt.MyPlayerIndex;
MyPhoton.MyPlayer myPlayer = pt.GetMyPlayer();
if (myPlayer != null)
{
plid = myPlayer.playerID;
}
if (pt.IsMultiVersus)
{
List <JSON_MyPhotonPlayerParam> myPlayersStarted = pt.GetMyPlayersStarted();
MyPhoton.MyRoom currentRoom = pt.GetCurrentRoom();
int num2 = currentRoom == null ? 1 : currentRoom.playerCount;
JSON_MyPhotonPlayerParam photonPlayerParam = myPlayersStarted.Find((Predicate <JSON_MyPhotonPlayerParam>)(p => p.playerIndex != pt.MyPlayerIndex));
if (photonPlayerParam != null)
{
uid = photonPlayerParam.UID;
}
if (!GlobalVars.IsVersusDraftMode)
{
if (string.IsNullOrEmpty(uid) || num2 == 1)
{
this.OnVersusNoPlayer();
return;
}
PlayerPartyTypes playerPartyTypes = PlayerPartyTypes.Versus;
if (pt.IsRankMatch)
{
playerPartyTypes = PlayerPartyTypes.RankMatch;
}
PartyData party = instance.Player.Partys[(int)playerPartyTypes];
if (party != null)
{
versusStatusData = new VersusStatusData();
for (int index = 0; index < party.MAX_UNIT; ++index)
{
long unitUniqueId = party.GetUnitUniqueID(index);
if (party.GetUnitUniqueID(index) != 0L)
{
UnitData unitDataByUniqueId = instance.Player.FindUnitDataByUniqueID(unitUniqueId);
if (unitDataByUniqueId != null)
{
versusStatusData.Add(unitDataByUniqueId.Status.param, unitDataByUniqueId.GetCombination());
++num1;
}
}
}
}
}
else
{
versusStatusData = new VersusStatusData();
for (int index = 0; index < VersusDraftList.VersusDraftPartyUnits.Count; ++index)
{
UnitData versusDraftPartyUnit = VersusDraftList.VersusDraftPartyUnits[index];
if (versusDraftPartyUnit != null)
{
versusStatusData.Add(versusDraftPartyUnit.Status.param, versusDraftPartyUnit.GetCombination());
++num1;
}
}
}
}
else
{
List <JSON_MyPhotonPlayerParam> myPlayersStarted = pt.GetMyPlayersStarted();
for (int index = 0; index < myPlayersStarted.Count; ++index)
{
if (myPlayersStarted[index].playerIndex != pt.MyPlayerIndex)
{
stringList.Add(myPlayersStarted[index].UID);
}
}
}
}
if (this.mReqID == 200)
{
if (GlobalVars.IsVersusDraftMode)
{
int enemy_draft_id = 0;
MyPhoton.MyPlayer player = PunMonoSingleton <MyPhoton> .Instance.GetMyPlayer();
JSON_MyPhotonPlayerParam photonPlayerParam = pt.GetMyPlayersStarted().Find((Predicate <JSON_MyPhotonPlayerParam>)(p => p.playerID != player.playerID));
if (photonPlayerParam != null)
{
enemy_draft_id = photonPlayerParam.draft_id;
}
this.ExecRequest((WebAPI) new ReqVersus(this.mStartingQuest.iname, plid, seat, uid, versusStatusData, num1, new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback), GlobalVars.SelectedMultiPlayVersusType, VersusDraftList.DraftID, enemy_draft_id));
}
else
{
this.ExecRequest((WebAPI) new ReqVersus(this.mStartingQuest.iname, plid, seat, uid, versusStatusData, num1, new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback), GlobalVars.SelectedMultiPlayVersusType, 0, 0));
}
}
else if (this.mReqID == 250)
{
this.ExecRequest((WebAPI) new ReqRankMatch(this.mStartingQuest.iname, plid, seat, uid, new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback)));
}
else if (this.mReqID == 500)
{
this.ExecRequest((WebAPI) new ReqBtlMultiTwReq(this.mStartingQuest.iname, partyIndex2, plid, seat, stringList.ToArray(), new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback)));
}
else if (this.mReqID == 700)
{
this.ExecRequest((WebAPI) new ReqVersusCpu(this.mStartingQuest.iname, GlobalVars.VersusCpu == null ? 1 : GlobalVars.VersusCpu.Get().Deck, new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback)));
}
else
{
this.ExecRequest((WebAPI) new ReqBtlComReq(this.mStartingQuest.iname, GlobalVars.SelectedFriendID, GlobalVars.SelectedSupport.Get(), new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback), multi, partyIndex2, isHost, plid, seat, GlobalVars.Location, GlobalVars.SelectedRankingQuestParam));
}
}
}
else
{
this.StartCoroutine(this.StartScene((BattleCore.Json_Battle)null));
}
}
}
else if (pinID == 20)
{
if (instance.AudienceRoom == null)
{
return;
}
this.StartCoroutine(this.StartAudience());
}
else
{
if (pinID != 30)
{
return;
}
if (Network.IsError)
{
this.ActivateOutputLinks(300);
Network.ResetError();
}
else if (!Network.IsStreamConnecting)
{
Network.ResetError();
this.ActivateOutputLinks(300);
}
else
{
VersusAudienceManager audienceManager = instance.AudienceManager;
audienceManager.AddStartQuest();
if (audienceManager.GetStartedParam() != null)
{
if (audienceManager.GetStartedParam().btlinfo != null)
{
BattleCore.Json_Battle json = new BattleCore.Json_Battle();
json.btlinfo = audienceManager.GetStartedParam().btlinfo;
CriticalSection.Enter(CriticalSections.SceneChange);
instance.AudienceMode = true;
this.StartCoroutine(this.StartScene(json));
}
else if (audienceManager.IsRetryError)
{
DebugUtility.LogError("Not Exist btlInfo");
Network.Abort();
this.ActivateOutputLinks(300);
}
else
{
this.ActivateOutputLinks(9);
}
}
else if (audienceManager.IsRetryError)
{
DebugUtility.LogError("Not Exist StartParam");
Network.Abort();
this.ActivateOutputLinks(300);
}
else
{
this.ActivateOutputLinks(9);
}
}
}
}
private void Update()
{
MyPhoton instance = PunMonoSingleton <MyPhoton> .Instance;
if (this.mIgnore)
{
return;
}
if (instance.CurrentState != MyPhoton.MyState.ROOM)
{
if (instance.CurrentState != MyPhoton.MyState.NOP)
{
instance.Disconnect();
}
this.ActivateOutputLinks(1);
}
else
{
List <MyPhoton.MyPlayer> roomPlayerList = instance.GetRoomPlayerList();
bool flag1 = GlobalVars.SelectedMultiPlayRoomType == JSON_MyPhotonRoomParam.EType.RAID;
bool flag2 = GlobalVars.SelectedMultiPlayRoomType == JSON_MyPhotonRoomParam.EType.VERSUS && GlobalVars.SelectedMultiPlayVersusType == VERSUS_TYPE.Friend;
bool flag3 = GlobalVars.SelectedMultiPlayRoomType == JSON_MyPhotonRoomParam.EType.TOWER;
if (roomPlayerList.Find((Predicate <MyPhoton.MyPlayer>)(p => p.playerID == 1)) == null && (flag1 || flag2 || flag3))
{
this.ActivateOutputLinks(7);
}
else
{
MyPhoton.MyRoom currentRoom = instance.GetCurrentRoom();
if (instance.IsUpdateRoomProperty)
{
if (currentRoom.start)
{
this.ActivateOutputLinks(5);
return;
}
instance.IsUpdateRoomProperty = false;
}
JSON_MyPhotonRoomParam myPhotonRoomParam = JSON_MyPhotonRoomParam.Parse(currentRoom.json);
string str1 = myPhotonRoomParam != null ? myPhotonRoomParam.comment : string.Empty;
if (!this.mRoomComment.Equals(str1))
{
DebugUtility.Log("change room comment");
this.ActivateOutputLinks(6);
}
this.mRoomComment = str1;
string str2 = myPhotonRoomParam != null ? myPhotonRoomParam.passCode : string.Empty;
if (!this.mRoomPass.Equals(str2))
{
DebugUtility.Log("change room pass");
this.ActivateOutputLinks(50);
}
this.mRoomPass = str2;
bool flag4 = false;
if (roomPlayerList == null)
{
instance.Disconnect();
}
else if (this.mPlayers == null)
{
flag4 = true;
}
else if (this.mPlayers.Count != roomPlayerList.Count)
{
flag4 = true;
}
else
{
for (int index = 0; index < this.mPlayers.Count; ++index)
{
if (this.mPlayers[index].playerID != roomPlayerList[index].playerID)
{
flag4 = true;
break;
}
if (!this.mPlayers[index].json.Equals(roomPlayerList[index].json))
{
flag4 = true;
break;
}
}
}
if (!string.IsNullOrEmpty(this.mQuestName) && !this.mQuestName.Equals(myPhotonRoomParam.iname))
{
DebugUtility.Log("change quest iname" + myPhotonRoomParam.iname);
this.ActivateOutputLinks(10);
}
this.mQuestName = myPhotonRoomParam.iname;
if (flag4)
{
this.mPlayers = new List <MyPhoton.MyPlayer>((IEnumerable <MyPhoton.MyPlayer>)roomPlayerList);
this.ActivateOutputLinks(2);
if (instance.IsOldestPlayer())
{
JSON_MyPhotonPlayerParam[] photonPlayerParamArray = new JSON_MyPhotonPlayerParam[roomPlayerList.Count];
for (int index = 0; index < photonPlayerParamArray.Length; ++index)
{
photonPlayerParamArray[index] = JSON_MyPhotonPlayerParam.Parse(roomPlayerList[index].json);
}
myPhotonRoomParam.players = photonPlayerParamArray;
instance.SetRoomParam(myPhotonRoomParam.Serialize());
}
bool flag5 = true;
using (List <MyPhoton.MyPlayer> .Enumerator enumerator = this.mPlayers.GetEnumerator())
{
while (enumerator.MoveNext())
{
JSON_MyPhotonPlayerParam photonPlayerParam = JSON_MyPhotonPlayerParam.Parse(enumerator.Current.json);
if (photonPlayerParam.state == 0 || photonPlayerParam.state == 4 || photonPlayerParam.state == 5)
{
flag5 = false;
break;
}
}
}
if (flag5)
{
this.ActivateOutputLinks(3);
}
else
{
this.ActivateOutputLinks(4);
}
}
else
{
int count = instance.GetRoomPlayerList().Count;
if (count == 1 && this.mMemberCnt != count)
{
this.ActivateOutputLinks(9);
}
this.mMemberCnt = instance.GetRoomPlayerList().Count;
if (this.mIgnoreFullMember || instance.GetCurrentRoom().maxPlayers - 1 != count)
{
return;
}
this.ActivateOutputLinks(8);
}
}
}
}
