Esempio n. 1
0
        public List <MyPhoton.MyPlayer> GetRoomPlayerList()
        {
            List <MyPhoton.MyPlayer> myPlayerList = new List <MyPhoton.MyPlayer>();

            foreach (PhotonPlayer player in PhotonNetwork.playerList)
            {
                MyPhoton.MyPlayer myPlayer = new MyPhoton.MyPlayer();
                myPlayer.playerID = player.ID;
                Hashtable customProperties = player.CustomProperties;
                if (customProperties != null && ((Dictionary <object, object>)customProperties).Count > 0)
                {
                    myPlayer.json = (string)customProperties.get_Item((object)"json");
                    if (((Dictionary <object, object>)customProperties).ContainsKey((object)"resumeID"))
                    {
                        myPlayer.resumeID = (int)customProperties.get_Item((object)"resumeID");
                    }
                    if (((Dictionary <object, object>)customProperties).ContainsKey((object)"BattleStart"))
                    {
                        myPlayer.start = (bool)customProperties.get_Item((object)"BattleStart");
                    }
                }
                myPlayerList.Add(myPlayer);
            }
            return(myPlayerList);
        }
 public override void OnActivate(int pinID)
 {
     if (pinID == 100)
     {
         // ISSUE: object of a compiler-generated type is created
         // ISSUE: variable of a compiler-generated type
         FlowNode_VersusAward.\u003COnActivate\u003Ec__AnonStorey218 activateCAnonStorey218 = new FlowNode_VersusAward.\u003COnActivate\u003Ec__AnonStorey218();
         // ISSUE: reference to a compiler-generated field
         activateCAnonStorey218.pt = PunMonoSingleton <MyPhoton> .Instance;
         JSON_MyPhotonPlayerParam data = (JSON_MyPhotonPlayerParam)null;
         // ISSUE: reference to a compiler-generated field
         List <MyPhoton.MyPlayer> roomPlayerList = activateCAnonStorey218.pt.GetRoomPlayerList();
         if (roomPlayerList != null)
         {
             if (this.MyPlayer)
             {
                 data = JSON_MyPhotonPlayerParam.Create(0, 0);
             }
             else
             {
                 // ISSUE: reference to a compiler-generated method
                 MyPhoton.MyPlayer myPlayer = roomPlayerList.Find(new Predicate <MyPhoton.MyPlayer>(activateCAnonStorey218.\u003C\u003Em__215));
                 if (myPlayer != null)
                 {
                     data = JSON_MyPhotonPlayerParam.Parse(myPlayer.json);
                 }
             }
         }
         if (data != null)
         {
             DataSource.Bind <JSON_MyPhotonPlayerParam>(this.BindObj, data);
         }
     }
     this.ActivateOutputLinks(200);
 }
Esempio n. 3
0
        public bool IsOldestPlayer(int playerID)
        {
            if (this.mState != MyPhoton.MyState.ROOM)
            {
                return(false);
            }
            bool flag = false;

            using (List <MyPhoton.MyPlayer> .Enumerator enumerator = this.GetRoomPlayerList().GetEnumerator())
            {
                while (enumerator.MoveNext())
                {
                    MyPhoton.MyPlayer current = enumerator.Current;
                    if (current.playerID < playerID)
                    {
                        return(false);
                    }
                    if (current.playerID == playerID)
                    {
                        flag = true;
                    }
                }
            }
            return(flag);
        }
Esempio n. 4
0
        public override void OnActivate(int pinID)
        {
            if (!GameUtility.Config_UseAssetBundles.Value)
            {
                this.ActivateOutputLinks(100);
            }
            else
            {
                switch (pinID)
                {
                case 0:
                    // ISSUE: object of a compiler-generated type is created
                    // ISSUE: variable of a compiler-generated type
                    FlowNode_VersusUnitDownload.\u003COnActivate\u003Ec__AnonStorey2D7 activateCAnonStorey2D7 = new FlowNode_VersusUnitDownload.\u003COnActivate\u003Ec__AnonStorey2D7();
                    // ISSUE: reference to a compiler-generated field
                    activateCAnonStorey2D7.pt = PunMonoSingleton <MyPhoton> .Instance;
                    // ISSUE: reference to a compiler-generated field
                    if (UnityEngine.Object.op_Inequality((UnityEngine.Object)activateCAnonStorey2D7.pt, (UnityEngine.Object)null))
                    {
                        // ISSUE: reference to a compiler-generated field
                        List <MyPhoton.MyPlayer> roomPlayerList = activateCAnonStorey2D7.pt.GetRoomPlayerList();
                        if (roomPlayerList != null && roomPlayerList.Count > 1)
                        {
                            // ISSUE: reference to a compiler-generated method
                            MyPhoton.MyPlayer myPlayer = roomPlayerList.Find(new Predicate <MyPhoton.MyPlayer>(activateCAnonStorey2D7.\u003C\u003Em__2CC));
                            if (myPlayer != null)
                            {
                                this.AddAssets(JSON_MyPhotonPlayerParam.Parse(myPlayer.json));
                                break;
                            }
                            break;
                        }
                        break;
                    }
                    break;

                case 1:
                    GameManager instance = MonoSingleton <GameManager> .Instance;
                    if (instance.AudienceRoom != null)
                    {
                        JSON_MyPhotonRoomParam myPhotonRoomParam = JSON_MyPhotonRoomParam.Parse(instance.AudienceRoom.json);
                        if (myPhotonRoomParam != null)
                        {
                            for (int index = 0; index < myPhotonRoomParam.players.Length; ++index)
                            {
                                if (myPhotonRoomParam.players[index] != null)
                                {
                                    myPhotonRoomParam.players[index].SetupUnits();
                                    this.AddAssets(myPhotonRoomParam.players[index]);
                                }
                            }
                            break;
                        }
                        break;
                    }
                    break;
                }
                this.StartCoroutine(this.AsyncDownload());
            }
        }
        private void SendPlacementInfo()
        {
            MyPhoton pt = PunMonoSingleton <MyPhoton> .Instance;

            MyPhoton.MyPlayer myPlayer = pt.GetMyPlayer();
            if (myPlayer == null)
            {
                return;
            }
            JSON_MyPhotonPlayerParam param = JSON_MyPhotonPlayerParam.Parse(myPlayer.json);

            if (param.units != null)
            {
                for (int i = 0; i < param.units.Length; ++i)
                {
                    TacticsUnitController tacticsUnitController = this.m_Units.Find((Predicate <TacticsUnitController>)(data =>
                    {
                        if (data.Unit.OwnerPlayerIndex == pt.MyPlayerIndex)
                        {
                            return(data.UnitData.UnitParam.iname == param.units[i].unit.UnitParam.iname);
                        }
                        return(false);
                    }));
                    if (UnityEngine.Object.op_Inequality((UnityEngine.Object)tacticsUnitController, (UnityEngine.Object)null))
                    {
                        param.units[i].place = this.GetPlacementID(tacticsUnitController.Unit.x, tacticsUnitController.Unit.y);
                        PlayerPrefsUtility.SetInt(PlayerPrefsUtility.MULTITW_ID_KEY + (object)i, param.units[i].place, false);
                    }
                }
            }
            PlayerPrefsUtility.Save();
            pt.SetMyPlayerParam(param.Serialize());
        }
Esempio n. 6
0
            public override void Begin(VersusDraftReady self)
            {
                MyPhoton instance1 = PunMonoSingleton <MyPhoton> .Instance;

                MyPhoton.MyPlayer myPlayer = instance1.GetMyPlayer();
                int         num1           = myPlayer != null ? myPlayer.playerID : 0;
                int         myPlayerIndex  = instance1.MyPlayerIndex;
                GameManager instance2      = MonoSingleton <GameManager> .Instance;
                JSON_MyPhotonPlayerParam photonPlayerParam = new JSON_MyPhotonPlayerParam();
                PlayerData player = instance2.Player;

                photonPlayerParam.playerID    = num1;
                photonPlayerParam.playerIndex = myPlayerIndex;
                photonPlayerParam.playerName  = player.Name;
                photonPlayerParam.playerLevel = player.Lv;
                photonPlayerParam.FUID        = player.FUID;
                photonPlayerParam.UID         = MonoSingleton <GameManager> .Instance.DeviceId;
                photonPlayerParam.award       = player.SelectedAward;
                int num2 = 0;
                int num3 = 0;
                int num4 = 0;
                List <JSON_MyPhotonPlayerParam.UnitDataElem> unitDataElemList = new List <JSON_MyPhotonPlayerParam.UnitDataElem>();

                for (int index = 0; index < VersusDraftList.VersusDraftPartyUnits.Count; ++index)
                {
                    UnitData versusDraftPartyUnit = VersusDraftList.VersusDraftPartyUnits[index];
                    if (versusDraftPartyUnit != null)
                    {
                        unitDataElemList.Add(new JSON_MyPhotonPlayerParam.UnitDataElem()
                        {
                            slotID = num2,
                            place  = VersusDraftList.VersusDraftPartyPlaces.Count <= index ? index : VersusDraftList.VersusDraftPartyPlaces[index],
                            unit   = versusDraftPartyUnit
                        });
                        num3 = num3 + (int)versusDraftPartyUnit.Status.param.atk + (int)versusDraftPartyUnit.Status.param.mag;
                        num4 = num4 + (int)((double)(int)versusDraftPartyUnit.Status.param.hp * (double)MonoSingleton <GameManager> .Instance.MasterParam.mStatusCoefficient.HP) + (int)((double)(int)versusDraftPartyUnit.Status.param.atk * (double)MonoSingleton <GameManager> .Instance.MasterParam.mStatusCoefficient.Attack) + (int)((double)(int)versusDraftPartyUnit.Status.param.def * (double)MonoSingleton <GameManager> .Instance.MasterParam.mStatusCoefficient.Defense) + (int)((double)(int)versusDraftPartyUnit.Status.param.mag * (double)MonoSingleton <GameManager> .Instance.MasterParam.mStatusCoefficient.MagAttack) + (int)((double)(int)versusDraftPartyUnit.Status.param.mnd * (double)MonoSingleton <GameManager> .Instance.MasterParam.mStatusCoefficient.MagDefense) + (int)((double)(int)versusDraftPartyUnit.Status.param.dex * (double)MonoSingleton <GameManager> .Instance.MasterParam.mStatusCoefficient.Dex) + (int)((double)(int)versusDraftPartyUnit.Status.param.spd * (double)MonoSingleton <GameManager> .Instance.MasterParam.mStatusCoefficient.Speed) + (int)((double)(int)versusDraftPartyUnit.Status.param.cri * (double)MonoSingleton <GameManager> .Instance.MasterParam.mStatusCoefficient.Critical) + (int)((double)(int)versusDraftPartyUnit.Status.param.luk * (double)MonoSingleton <GameManager> .Instance.MasterParam.mStatusCoefficient.Luck) + (int)((double)versusDraftPartyUnit.GetCombination() * (double)MonoSingleton <GameManager> .Instance.MasterParam.mStatusCoefficient.Combo) + (int)((double)(int)versusDraftPartyUnit.Status.param.mov * (double)MonoSingleton <GameManager> .Instance.MasterParam.mStatusCoefficient.Move) + (int)((double)(int)versusDraftPartyUnit.Status.param.jmp * (double)MonoSingleton <GameManager> .Instance.MasterParam.mStatusCoefficient.Jump);
                        ++num2;
                    }
                }
                photonPlayerParam.units       = unitDataElemList.ToArray();
                photonPlayerParam.totalAtk    = num3;
                photonPlayerParam.totalStatus = Mathf.FloorToInt((float)(num4 / unitDataElemList.Count));
                photonPlayerParam.rankpoint   = player.VERSUS_POINT;
                photonPlayerParam.draft_id    = VersusDraftList.DraftID;
                instance1.SetMyPlayerParam(photonPlayerParam.Serialize());
                byte[] msg = GameUtility.Object2Binary <VersusDraftReady.VersusReadyMessageData>(new VersusDraftReady.VersusReadyMessageData()
                {
                    h    = 1,
                    pidx = myPlayerIndex,
                    pid  = num1
                });
                instance1.SendRoomMessageBinary(true, msg, MyPhoton.SEND_TYPE.Normal, false);
                FlowNode_GameObject.ActivateOutputLinks((Component)self, 2);
            }
Esempio n. 7
0
        public override void OnActivate(int pinID)
        {
            if (!GameUtility.Config_UseAssetBundles.Value)
            {
                this.ActivateOutputLinks(100);
            }
            else
            {
                switch (pinID)
                {
                case 0:
                    MyPhoton pt = PunMonoSingleton <MyPhoton> .Instance;
                    if (UnityEngine.Object.op_Inequality((UnityEngine.Object)pt, (UnityEngine.Object)null))
                    {
                        List <MyPhoton.MyPlayer> roomPlayerList = pt.GetRoomPlayerList();
                        if (roomPlayerList != null && roomPlayerList.Count > 1)
                        {
                            MyPhoton.MyPlayer myPlayer = roomPlayerList.Find((Predicate <MyPhoton.MyPlayer>)(p => p.playerID != pt.GetMyPlayer().playerID));
                            if (myPlayer != null)
                            {
                                this.AddAssets(JSON_MyPhotonPlayerParam.Parse(myPlayer.json));
                                break;
                            }
                            break;
                        }
                        break;
                    }
                    break;

                case 1:
                    GameManager instance = MonoSingleton <GameManager> .Instance;
                    if (instance.AudienceRoom != null)
                    {
                        JSON_MyPhotonRoomParam myPhotonRoomParam = JSON_MyPhotonRoomParam.Parse(instance.AudienceRoom.json);
                        if (myPhotonRoomParam != null)
                        {
                            for (int index = 0; index < myPhotonRoomParam.players.Length; ++index)
                            {
                                if (myPhotonRoomParam.players[index] != null)
                                {
                                    myPhotonRoomParam.players[index].SetupUnits();
                                    this.AddAssets(myPhotonRoomParam.players[index]);
                                }
                            }
                            break;
                        }
                        break;
                    }
                    break;
                }
                this.StartCoroutine(this.AsyncDownload());
            }
        }
Esempio n. 8
0
            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);
            }
Esempio n. 9
0
 public override void OnActivate(int pinID)
 {
     if (pinID == 100)
     {
         GameManager instance          = MonoSingleton <GameManager> .Instance;
         JSON_MyPhotonPlayerParam data = (JSON_MyPhotonPlayerParam)null;
         if (instance.AudienceMode)
         {
             MyPhoton.MyRoom audienceRoom = instance.AudienceRoom;
             if (audienceRoom != null)
             {
                 JSON_MyPhotonRoomParam myPhotonRoomParam = JSON_MyPhotonRoomParam.Parse(audienceRoom.json);
                 if (myPhotonRoomParam != null && myPhotonRoomParam.players != null && myPhotonRoomParam.players.Length >= this.ROOM_MAX_PLAYERCNT)
                 {
                     data = myPhotonRoomParam.players[!this.MyPlayer ? 1 : 0];
                 }
             }
         }
         else
         {
             // ISSUE: object of a compiler-generated type is created
             // ISSUE: variable of a compiler-generated type
             FlowNode_VersusAward.\u003COnActivate\u003Ec__AnonStorey2D6 activateCAnonStorey2D6 = new FlowNode_VersusAward.\u003COnActivate\u003Ec__AnonStorey2D6();
             // ISSUE: reference to a compiler-generated field
             activateCAnonStorey2D6.pt = PunMonoSingleton <MyPhoton> .Instance;
             // ISSUE: reference to a compiler-generated field
             List <MyPhoton.MyPlayer> roomPlayerList = activateCAnonStorey2D6.pt.GetRoomPlayerList();
             if (roomPlayerList != null)
             {
                 if (this.MyPlayer)
                 {
                     data = JSON_MyPhotonPlayerParam.Create(0, 0);
                 }
                 else
                 {
                     // ISSUE: reference to a compiler-generated method
                     MyPhoton.MyPlayer myPlayer = roomPlayerList.Find(new Predicate <MyPhoton.MyPlayer>(activateCAnonStorey2D6.\u003C\u003Em__2CB));
                     if (myPlayer != null)
                     {
                         data = JSON_MyPhotonPlayerParam.Parse(myPlayer.json);
                     }
                 }
             }
         }
         if (data != null)
         {
             DataSource.Bind <JSON_MyPhotonPlayerParam>(this.BindObj, data);
         }
     }
     this.ActivateOutputLinks(200);
 }
Esempio n. 10
0
 private void SendPlacementInfo()
 {
     // ISSUE: object of a compiler-generated type is created
     // ISSUE: variable of a compiler-generated type
     MultiPlayVersusReady.\u003CSendPlacementInfo\u003Ec__AnonStorey34F infoCAnonStorey34F = new MultiPlayVersusReady.\u003CSendPlacementInfo\u003Ec__AnonStorey34F();
     // ISSUE: reference to a compiler-generated field
     infoCAnonStorey34F.pt = PunMonoSingleton <MyPhoton> .Instance;
     // ISSUE: reference to a compiler-generated field
     MyPhoton.MyPlayer myPlayer = infoCAnonStorey34F.pt.GetMyPlayer();
     if (myPlayer == null)
     {
         return;
     }
     // ISSUE: reference to a compiler-generated field
     infoCAnonStorey34F.param = JSON_MyPhotonPlayerParam.Parse(myPlayer.json);
     // ISSUE: reference to a compiler-generated field
     if (infoCAnonStorey34F.param.units != null)
     {
         // ISSUE: object of a compiler-generated type is created
         // ISSUE: variable of a compiler-generated type
         MultiPlayVersusReady.\u003CSendPlacementInfo\u003Ec__AnonStorey350 infoCAnonStorey350 = new MultiPlayVersusReady.\u003CSendPlacementInfo\u003Ec__AnonStorey350();
         // ISSUE: reference to a compiler-generated field
         infoCAnonStorey350.\u003C\u003Ef__ref\u0024847 = infoCAnonStorey34F;
         // ISSUE: reference to a compiler-generated field
         // ISSUE: reference to a compiler-generated field
         // ISSUE: reference to a compiler-generated field
         // ISSUE: reference to a compiler-generated field
         for (infoCAnonStorey350.i = 0; infoCAnonStorey350.i < infoCAnonStorey34F.param.units.Length; ++infoCAnonStorey350.i)
         {
             // ISSUE: reference to a compiler-generated method
             TacticsUnitController tacticsUnitController = this.m_Units.Find(new Predicate <TacticsUnitController>(infoCAnonStorey350.\u003C\u003Em__3B0));
             if (UnityEngine.Object.op_Inequality((UnityEngine.Object)tacticsUnitController, (UnityEngine.Object)null))
             {
                 // ISSUE: reference to a compiler-generated field
                 // ISSUE: reference to a compiler-generated field
                 infoCAnonStorey34F.param.units[infoCAnonStorey350.i].place = this.GetPlacementID(tacticsUnitController.Unit.x, tacticsUnitController.Unit.y);
                 // ISSUE: reference to a compiler-generated field
                 // ISSUE: reference to a compiler-generated field
                 // ISSUE: reference to a compiler-generated field
                 PlayerPrefsUtility.SetInt(PlayerPrefsUtility.MULTITW_ID_KEY + (object)infoCAnonStorey350.i, infoCAnonStorey34F.param.units[infoCAnonStorey350.i].place, false);
             }
         }
     }
     PlayerPrefsUtility.Save();
     // ISSUE: reference to a compiler-generated field
     // ISSUE: reference to a compiler-generated field
     infoCAnonStorey34F.pt.SetMyPlayerParam(infoCAnonStorey34F.param.Serialize());
 }
Esempio n. 11
0
        public MyPhoton.MyPlayer GetMyPlayer()
        {
            Hashtable customProperties = PhotonNetwork.player.CustomProperties;

            MyPhoton.MyPlayer myPlayer = new MyPhoton.MyPlayer();
            myPlayer.photonPlayerID = PhotonNetwork.player.ID;
            if (customProperties != null && ((Dictionary <object, object>)customProperties).Count > 0)
            {
                myPlayer.json = (string)customProperties.get_Item((object)"json");
                if (((Dictionary <object, object>)customProperties).ContainsKey((object)"resumeID"))
                {
                    myPlayer.resumeID = (int)customProperties.get_Item((object)"resumeID");
                }
            }
            return(myPlayer);
        }
Esempio n. 12
0
 public override void OnActivate(int pinID)
 {
     if (pinID == 100)
     {
         GameManager instance          = MonoSingleton <GameManager> .Instance;
         JSON_MyPhotonPlayerParam data = (JSON_MyPhotonPlayerParam)null;
         if (instance.AudienceMode)
         {
             MyPhoton.MyRoom audienceRoom = instance.AudienceRoom;
             if (audienceRoom != null)
             {
                 JSON_MyPhotonRoomParam myPhotonRoomParam = JSON_MyPhotonRoomParam.Parse(audienceRoom.json);
                 if (myPhotonRoomParam != null && myPhotonRoomParam.players != null && myPhotonRoomParam.players.Length >= this.ROOM_MAX_PLAYERCNT)
                 {
                     data = myPhotonRoomParam.players[!this.MyPlayer ? 1 : 0];
                 }
             }
         }
         else
         {
             MyPhoton pt = PunMonoSingleton <MyPhoton> .Instance;
             List <MyPhoton.MyPlayer> roomPlayerList = pt.GetRoomPlayerList();
             if (roomPlayerList != null)
             {
                 if (this.MyPlayer)
                 {
                     data = JSON_MyPhotonPlayerParam.Create(0, 0);
                 }
                 else
                 {
                     MyPhoton.MyPlayer myPlayer = roomPlayerList.Find((Predicate <MyPhoton.MyPlayer>)(p => p.playerID != pt.GetMyPlayer().playerID));
                     if (myPlayer != null)
                     {
                         data = JSON_MyPhotonPlayerParam.Parse(myPlayer.json);
                     }
                 }
             }
         }
         if (data != null)
         {
             DataSource.Bind <JSON_MyPhotonPlayerParam>(this.BindObj, data);
         }
     }
     this.ActivateOutputLinks(200);
 }
Esempio n. 13
0
 public void Refresh(List <MyPhoton.MyPlayer> _new_players)
 {
     for (int i = 0; i < _new_players.Count; ++i)
     {
         if (_new_players[i].photonPlayerID > -1)
         {
             this.tmp_entry_member = this.room_members.Find((Predicate <ChatUtility.RoomMember>)(a => a.PlayerId == _new_players[i].playerID));
             if (this.tmp_entry_member == null)
             {
                 JSON_MyPhotonPlayerParam photonPlayerParam = JSON_MyPhotonPlayerParam.Parse(_new_players[i].json);
                 ChatUtility.RoomMember   roomMember        = new ChatUtility.RoomMember();
                 roomMember.SetParam(_new_players[i].photonPlayerID, _new_players[i].playerID, photonPlayerParam.UID, photonPlayerParam.playerName);
                 if (!this.entry_members.Contains(roomMember))
                 {
                     this.entry_members.Add(roomMember);
                 }
             }
         }
     }
     for (int i = 0; i < this.room_members.Count; ++i)
     {
         if (this.room_members[i].PhotonPlayerId > -1)
         {
             this.tmp_leave_member = _new_players.Find((Predicate <MyPhoton.MyPlayer>)(a => a.playerID == this.room_members[i].PlayerId));
             if (this.tmp_leave_member == null && !this.leave_members.Contains(this.room_members[i]))
             {
                 this.leave_members.Add(this.room_members[i]);
             }
         }
     }
     for (int index = 0; index < this.entry_members.Count; ++index)
     {
         if (!this.room_members.Contains(this.entry_members[index]))
         {
             this.room_members.Add(this.entry_members[index]);
         }
     }
     for (int index = 0; index < this.leave_members.Count; ++index)
     {
         if (this.room_members.Contains(this.leave_members[index]))
         {
             this.room_members.Remove(this.leave_members[index]);
         }
     }
 }
Esempio n. 14
0
        public int GetOldestPlayer()
        {
            if (this.mState != MyPhoton.MyState.ROOM)
            {
                return(0);
            }
            int num = 0;

            using (List <MyPhoton.MyPlayer> .Enumerator enumerator = this.GetRoomPlayerList().GetEnumerator())
            {
                while (enumerator.MoveNext())
                {
                    MyPhoton.MyPlayer current = enumerator.Current;
                    if ((current.playerID < num || num == 0) && current.start)
                    {
                        num = current.playerID;
                    }
                }
            }
            return(num);
        }
Esempio n. 15
0
 public override void OnActivate(int pinID)
 {
     if (pinID != 0)
     {
         return;
     }
     // ISSUE: object of a compiler-generated type is created
     // ISSUE: variable of a compiler-generated type
     FlowNode_VersusUnitDownload.\u003COnActivate\u003Ec__AnonStorey219 activateCAnonStorey219 = new FlowNode_VersusUnitDownload.\u003COnActivate\u003Ec__AnonStorey219();
     if (!GameUtility.Config_UseAssetBundles.Value)
     {
         this.ActivateOutputLinks(100);
     }
     else
     {
         // ISSUE: reference to a compiler-generated field
         activateCAnonStorey219.pt = PunMonoSingleton <MyPhoton> .Instance;
         JSON_MyPhotonPlayerParam photonPlayerParam = (JSON_MyPhotonPlayerParam)null;
         // ISSUE: reference to a compiler-generated field
         if (Object.op_Inequality((Object)activateCAnonStorey219.pt, (Object)null))
         {
             // ISSUE: reference to a compiler-generated field
             List <MyPhoton.MyPlayer> roomPlayerList = activateCAnonStorey219.pt.GetRoomPlayerList();
             if (roomPlayerList != null && roomPlayerList.Count > 1)
             {
                 // ISSUE: reference to a compiler-generated method
                 MyPhoton.MyPlayer myPlayer = roomPlayerList.Find(new Predicate <MyPhoton.MyPlayer>(activateCAnonStorey219.\u003C\u003Em__216));
                 if (myPlayer != null)
                 {
                     photonPlayerParam = JSON_MyPhotonPlayerParam.Parse(myPlayer.json);
                 }
             }
         }
         if (photonPlayerParam != null)
         {
             AssetManager.PrepareAssets(AssetPath.UnitSkinImage(photonPlayerParam.units[0].unit.UnitParam, photonPlayerParam.units[0].unit.GetSelectedSkin(-1), photonPlayerParam.units[0].unit.CurrentJobId));
         }
         this.StartCoroutine(this.AsyncDownload());
     }
 }
Esempio n. 16
0
        private void SendRoomMessage(VersusDraftList.VersusDraftMessageData mess, bool immediate = false)
        {
            if (mess == null)
            {
                return;
            }
            MyPhoton instance = PunMonoSingleton <MyPhoton> .Instance;

            MyPhoton.MyPlayer myPlayer = instance.GetMyPlayer();
            int myPlayerIndex          = instance.MyPlayerIndex;
            int num = myPlayer != null ? myPlayer.playerID : 0;

            mess.pidx = myPlayerIndex;
            mess.pid  = num;
            byte[] msg = GameUtility.Object2Binary <VersusDraftList.VersusDraftMessageData>(mess);
            instance.SendRoomMessageBinary(true, msg, MyPhoton.SEND_TYPE.Normal, false);
            if (!immediate)
            {
                return;
            }
            instance.SendFlush();
        }
Esempio n. 17
0
        public bool IsHost()
        {
            if (this.mState != MyPhoton.MyState.ROOM)
            {
                return(false);
            }
            MyPhoton.MyPlayer        myPlayer       = this.GetMyPlayer();
            List <MyPhoton.MyPlayer> roomPlayerList = this.GetRoomPlayerList();
            int photonPlayerId = myPlayer.photonPlayerID;

            using (List <MyPhoton.MyPlayer> .Enumerator enumerator = roomPlayerList.GetEnumerator())
            {
                while (enumerator.MoveNext())
                {
                    if (enumerator.Current.photonPlayerID < photonPlayerId)
                    {
                        return(false);
                    }
                }
            }
            return(true);
        }
Esempio n. 18
0
 public void Refresh(List <MyPhoton.MyPlayer> _new_players)
 {
     // ISSUE: object of a compiler-generated type is created
     // ISSUE: variable of a compiler-generated type
     ChatUtility.RoomMemberManager.\u003CRefresh\u003Ec__AnonStorey317 refreshCAnonStorey317 = new ChatUtility.RoomMemberManager.\u003CRefresh\u003Ec__AnonStorey317();
     // ISSUE: reference to a compiler-generated field
     refreshCAnonStorey317._new_players = _new_players;
     // ISSUE: reference to a compiler-generated field
     refreshCAnonStorey317.\u003C\u003Ef__this = this;
     // ISSUE: object of a compiler-generated type is created
     // ISSUE: variable of a compiler-generated type
     ChatUtility.RoomMemberManager.\u003CRefresh\u003Ec__AnonStorey318 refreshCAnonStorey318 = new ChatUtility.RoomMemberManager.\u003CRefresh\u003Ec__AnonStorey318();
     // ISSUE: reference to a compiler-generated field
     refreshCAnonStorey318.\u003C\u003Ef__ref\u0024791 = refreshCAnonStorey317;
     // ISSUE: reference to a compiler-generated field
     // ISSUE: reference to a compiler-generated field
     // ISSUE: reference to a compiler-generated field
     // ISSUE: reference to a compiler-generated field
     for (refreshCAnonStorey318.i = 0; refreshCAnonStorey318.i < refreshCAnonStorey317._new_players.Count; ++refreshCAnonStorey318.i)
     {
         // ISSUE: reference to a compiler-generated field
         // ISSUE: reference to a compiler-generated field
         if (refreshCAnonStorey317._new_players[refreshCAnonStorey318.i].photonPlayerID > -1)
         {
             // ISSUE: reference to a compiler-generated method
             this.tmp_entry_member = this.room_members.Find(new Predicate <ChatUtility.RoomMember>(refreshCAnonStorey318.\u003C\u003Em__332));
             if (this.tmp_entry_member == null)
             {
                 // ISSUE: reference to a compiler-generated field
                 // ISSUE: reference to a compiler-generated field
                 JSON_MyPhotonPlayerParam photonPlayerParam = JSON_MyPhotonPlayerParam.Parse(refreshCAnonStorey317._new_players[refreshCAnonStorey318.i].json);
                 ChatUtility.RoomMember   roomMember        = new ChatUtility.RoomMember();
                 // ISSUE: reference to a compiler-generated field
                 // ISSUE: reference to a compiler-generated field
                 // ISSUE: reference to a compiler-generated field
                 // ISSUE: reference to a compiler-generated field
                 roomMember.SetParam(refreshCAnonStorey317._new_players[refreshCAnonStorey318.i].photonPlayerID, refreshCAnonStorey317._new_players[refreshCAnonStorey318.i].playerID, photonPlayerParam.UID, photonPlayerParam.playerName);
                 if (!this.entry_members.Contains(roomMember))
                 {
                     this.entry_members.Add(roomMember);
                 }
             }
         }
     }
     // ISSUE: object of a compiler-generated type is created
     // ISSUE: variable of a compiler-generated type
     ChatUtility.RoomMemberManager.\u003CRefresh\u003Ec__AnonStorey319 refreshCAnonStorey319 = new ChatUtility.RoomMemberManager.\u003CRefresh\u003Ec__AnonStorey319();
     // ISSUE: reference to a compiler-generated field
     refreshCAnonStorey319.\u003C\u003Ef__this = this;
     // ISSUE: reference to a compiler-generated field
     // ISSUE: reference to a compiler-generated field
     // ISSUE: reference to a compiler-generated field
     for (refreshCAnonStorey319.i = 0; refreshCAnonStorey319.i < this.room_members.Count; ++refreshCAnonStorey319.i)
     {
         // ISSUE: reference to a compiler-generated field
         if (this.room_members[refreshCAnonStorey319.i].PhotonPlayerId > -1)
         {
             // ISSUE: reference to a compiler-generated field
             // ISSUE: reference to a compiler-generated method
             this.tmp_leave_member = refreshCAnonStorey317._new_players.Find(new Predicate <MyPhoton.MyPlayer>(refreshCAnonStorey319.\u003C\u003Em__333));
             // ISSUE: reference to a compiler-generated field
             if (this.tmp_leave_member == null && !this.leave_members.Contains(this.room_members[refreshCAnonStorey319.i]))
             {
                 // ISSUE: reference to a compiler-generated field
                 this.leave_members.Add(this.room_members[refreshCAnonStorey319.i]);
             }
         }
     }
     for (int index = 0; index < this.entry_members.Count; ++index)
     {
         if (!this.room_members.Contains(this.entry_members[index]))
         {
             this.room_members.Add(this.entry_members[index]);
         }
     }
     for (int index = 0; index < this.leave_members.Count; ++index)
     {
         if (this.room_members.Contains(this.leave_members[index]))
         {
             this.room_members.Remove(this.leave_members[index]);
         }
     }
 }
            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;
                                    }
                                }
                            }
                        }
                    }
                }
            }
Esempio n. 20
0
        private void RefreshItems()
        {
            Transform transform = ((Component)this).get_transform();

            if (UnityEngine.Object.op_Equality((UnityEngine.Object) this.ItemTemplate, (UnityEngine.Object)null))
            {
                return;
            }
            MyPhoton instance = PunMonoSingleton <MyPhoton> .Instance;

            MyPhoton.MyRoom          currentRoom        = instance.GetCurrentRoom();
            JSON_MyPhotonRoomParam   data1              = JSON_MyPhotonRoomParam.Parse(currentRoom.json);
            JSON_MyPhotonPlayerParam photonPlayerParam1 = data1 != null?data1.GetOwner() : (JSON_MyPhotonPlayerParam)null;

            int num1 = photonPlayerParam1 != null ? photonPlayerParam1.playerIndex : 0;
            List <MyPhoton.MyPlayer> roomPlayerList1 = instance.GetRoomPlayerList();

            for (int count = this.UIItemList.Count; count < currentRoom.maxPlayers; ++count)
            {
                this.UIItemList.Add((GameObject)UnityEngine.Object.Instantiate <GameObject>((M0)this.ItemTemplate));
                if (GlobalVars.SelectedMultiPlayRoomType == JSON_MyPhotonRoomParam.EType.TOWER)
                {
                    this.PlayerInfo.SetActive(false);
                    this.PlayerInfoList.Add((GameObject)UnityEngine.Object.Instantiate <GameObject>((M0)this.PlayerInfo));
                }
            }
            int maxPlayers = currentRoom.maxPlayers;

            if (GlobalVars.SelectedMultiPlayRoomType == JSON_MyPhotonRoomParam.EType.VERSUS)
            {
                --maxPlayers;
            }
            for (int index1 = 0; index1 < maxPlayers; ++index1)
            {
                JSON_MyPhotonPlayerParam data2 = (JSON_MyPhotonPlayerParam)null;
                int num2 = index1 + 1;
                if (num1 > 0)
                {
                    if (index1 == 0)
                    {
                        num2 = num1;
                    }
                    else if (index1 < num1)
                    {
                        num2 = index1;
                    }
                }
                using (List <MyPhoton.MyPlayer> .Enumerator enumerator = roomPlayerList1.GetEnumerator())
                {
                    while (enumerator.MoveNext())
                    {
                        MyPhoton.MyPlayer current = enumerator.Current;
                        if (current.json != null)
                        {
                            JSON_MyPhotonPlayerParam photonPlayerParam2 = JSON_MyPhotonPlayerParam.Parse(current.json);
                            if (photonPlayerParam2 != null && photonPlayerParam2.playerIndex == num2)
                            {
                                data2 = photonPlayerParam2;
                                break;
                            }
                        }
                    }
                }
                if (data2 == null)
                {
                    data2             = new JSON_MyPhotonPlayerParam();
                    data2.playerIndex = num2;
                }
                GameObject uiItem = this.UIItemList[index1];
                ((UnityEngine.Object)uiItem).set_hideFlags((HideFlags)52);
                DataSource.Bind <JSON_MyPhotonPlayerParam>(uiItem, data2);
                DataSource.Bind <JSON_MyPhotonRoomParam>(uiItem, data1);
                if (GlobalVars.SelectedMultiPlayRoomType == JSON_MyPhotonRoomParam.EType.TOWER)
                {
                    DataSource.Bind <JSON_MyPhotonPlayerParam>(this.PlayerInfoList[index1], data2);
                    DataSource.Bind <JSON_MyPhotonRoomParam>(this.PlayerInfoList[index1], data1);
                    this.PlayerInfoList[index1].get_transform().SetParent(this.PlayerInfo.get_transform().get_parent(), false);
                    this.PlayerInfoList[index1].get_gameObject().SetActive(true);
                }
                GameObjectID[] componentsInChildren = (GameObjectID[])uiItem.GetComponentsInChildren <GameObjectID>(true);
                if (data2 != null && data2.units != null && componentsInChildren != null)
                {
                    for (int index2 = 0; index2 < componentsInChildren.Length; ++index2)
                    {
                        GameObjectID gameObjectId = componentsInChildren[index2];
                        if (gameObjectId.ID != null)
                        {
                            DataSource.Bind <UnitData>(((Component)gameObjectId).get_gameObject(), (UnitData)null);
                        }
                    }
                    for (int index2 = 0; index2 < data2.units.Length; ++index2)
                    {
                        int      slotId = data2.units[index2].slotID;
                        bool     flag1  = data2.units[index2].sub == 1;
                        UnitData data3  = data2.units[index2].unit;
                        if (data3 != null)
                        {
                            if (GlobalVars.SelectedMultiPlayRoomType == JSON_MyPhotonRoomParam.EType.TOWER)
                            {
                                for (int index3 = 0; index3 < componentsInChildren.Length; ++index3)
                                {
                                    GameObjectID gameObjectId = componentsInChildren[index3];
                                    if (gameObjectId.ID != null && (gameObjectId.ID.Equals("unit" + (object)slotId) || flag1) && (!flag1 || index3 == componentsInChildren.Length - 1))
                                    {
                                        data3.TempFlags |= UnitData.TemporaryFlags.AllowJobChange;
                                        DataSource.Bind <UnitData>(((Component)gameObjectId).get_gameObject(), data3);
                                        UnitIcon component = (UnitIcon)((Component)gameObjectId).get_gameObject().GetComponent <UnitIcon>();
                                        if (UnityEngine.Object.op_Inequality((UnityEngine.Object)component, (UnityEngine.Object)null) && data2.playerIndex > 0)
                                        {
                                            DataSource.Bind <PlayerPartyTypes>(((Component)gameObjectId).get_gameObject(), PlayerPartyTypes.MultiTower);
                                            bool flag2 = data2.playerIndex == PunMonoSingleton <MyPhoton> .Instance.MyPlayerIndex;
                                            component.AllowJobChange = flag2;
                                            if (flag2)
                                            {
                                                UnitData unitDataByUnitId = MonoSingleton <GameManager> .Instance.Player.FindUnitDataByUnitID(data3.UnitParam.iname);

                                                if (unitDataByUnitId != null)
                                                {
                                                    unitDataByUnitId.TempFlags |= UnitData.TemporaryFlags.AllowJobChange;
                                                    DataSource.Bind <UnitData>(((Component)gameObjectId).get_gameObject(), unitDataByUnitId);
                                                    data3 = unitDataByUnitId;
                                                }
                                            }
                                        }
                                        if (index3 == 0 && this.PlayerInfoList.Count > index1)
                                        {
                                            DataSource.Bind <UnitData>(this.PlayerInfoList[index1], data3);
                                            break;
                                        }
                                        break;
                                    }
                                }
                            }
                            else
                            {
                                for (int index3 = 0; index3 < componentsInChildren.Length; ++index3)
                                {
                                    GameObjectID gameObjectId = componentsInChildren[index3];
                                    if (gameObjectId.ID != null && gameObjectId.ID.Equals("unit" + (object)slotId))
                                    {
                                        DataSource.Bind <UnitData>(((Component)gameObjectId).get_gameObject(), data3);
                                        break;
                                    }
                                }
                            }
                        }
                    }
                }
                ListItemEvents component1 = (ListItemEvents)uiItem.GetComponent <ListItemEvents>();
                if (UnityEngine.Object.op_Inequality((UnityEngine.Object)component1, (UnityEngine.Object)null))
                {
                    component1.OnSelect      = new ListItemEvents.ListItemEvent(this.OnSelectItem);
                    component1.OnOpenDetail  = new ListItemEvents.ListItemEvent(this.OnOpenItemDetail);
                    component1.OnCloseDetail = new ListItemEvents.ListItemEvent(this.OnCloseItemDetail);
                }
                uiItem.get_transform().SetParent(transform, false);
                uiItem.get_gameObject().SetActive(true);
            }
            QuestParam quest = MonoSingleton <GameManager> .Instance.FindQuest(data1.iname);

            DataSource.Bind <QuestParam>(this.Root, quest);
            bool flag = false;

            if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.SkillObj, (UnityEngine.Object)null) && quest != null)
            {
                if (quest.IsMultiLeaderSkill)
                {
                    List <MyPhoton.MyPlayer> roomPlayerList2 = instance.GetRoomPlayerList();
                    if (roomPlayerList2 != null)
                    {
                        MyPhoton.MyPlayer myPlayer = roomPlayerList2.Find((Predicate <MyPhoton.MyPlayer>)(member => member.playerID == 1));
                        if (myPlayer != null)
                        {
                            JSON_MyPhotonPlayerParam photonPlayerParam2 = JSON_MyPhotonPlayerParam.Parse(myPlayer.json);
                            if (photonPlayerParam2 != null && photonPlayerParam2.units != null && photonPlayerParam2.units.Length > 0)
                            {
                                UnitData data2 = new UnitData();
                                if (data2 != null)
                                {
                                    data2.Deserialize(photonPlayerParam2.units[0].unitJson);
                                    DataSource.Bind <UnitData>(this.SkillObj, data2);
                                    flag = data2.LeaderSkill != null;
                                }
                            }
                        }
                    }
                }
                SRPG_Button component = (SRPG_Button)this.SkillObj.GetComponent <SRPG_Button>();
                if (UnityEngine.Object.op_Inequality((UnityEngine.Object)component, (UnityEngine.Object)null))
                {
                    ((Selectable)component).set_interactable(quest.IsMultiLeaderSkill && flag);
                }
            }
            GameParameter.UpdateAll(this.Root);
            FlowNode_GameObject.ActivateOutputLinks((Component)this, 1);
        }
Esempio n. 21
0
        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);
                    }
                }
            }
        }
Esempio n. 22
0
        public override void OnActivate(int pinID)
        {
            switch (pinID)
            {
            case 0:
            case 4:
            case 22:
                this.ResetPlacementParam();
                string empty1 = string.Empty;
                string str1   = !PlayerPrefsUtility.HasKey(PlayerPrefsUtility.ROOM_COMMENT_KEY) ? LocalizedText.Get("sys.DEFAULT_ROOM_COMMENT") : PlayerPrefsUtility.GetString(PlayerPrefsUtility.ROOM_COMMENT_KEY, string.Empty);
                if (string.IsNullOrEmpty(str1))
                {
                    str1 = LocalizedText.Get("sys.DEFAULT_ROOM_COMMENT");
                }
                if (!MyMsgInput.isLegal(str1))
                {
                    DebugUtility.Log("comment is not legal");
                    this.ActivateOutputLinks(4801);
                    break;
                }
                GlobalVars.ResumeMultiplayPlayerID      = 0;
                GlobalVars.ResumeMultiplaySeatID        = 0;
                GlobalVars.SelectedMultiPlayRoomComment = str1;
                DebugUtility.Log("MakeRoom Comment:" + GlobalVars.SelectedMultiPlayRoomComment);
                bool flag = false;
                if (pinID == 4)
                {
                    GlobalVars.SelectedQuestID           = FlowNode_OnUrlSchemeLaunch.LINEParam_decided.iname;
                    GlobalVars.SelectedMultiPlayRoomType = FlowNode_OnUrlSchemeLaunch.LINEParam_decided.type;
                    GlobalVars.EditMultiPlayRoomPassCode = "0";
                    flag = true;
                    DebugUtility.Log("MakeRoom for LINE Quest:" + GlobalVars.SelectedQuestID + " Type:" + (object)GlobalVars.SelectedMultiPlayRoomType + " PassCodeHash:" + GlobalVars.SelectedMultiPlayRoomPassCodeHash);
                }
                GlobalVars.EditMultiPlayRoomPassCode = "0";
                string s = FlowNode_Variable.Get("MultiPlayPasscode");
                if (!string.IsNullOrEmpty(s))
                {
                    int result = 0;
                    if (int.TryParse(s, out result))
                    {
                        GlobalVars.EditMultiPlayRoomPassCode = result.ToString();
                    }
                }
                bool isPrivate = flag;
                FlowNode_MultiPlayAPI.RoomMakeTime = Time.get_realtimeSinceStartup();
                bool limit  = GlobalVars.SelectedMultiPlayLimit & GlobalVars.EditMultiPlayRoomPassCode == "0";
                int  unitlv = isPrivate || !limit ? 0 : GlobalVars.MultiPlayJoinUnitLv;
                bool clear  = !isPrivate && limit && GlobalVars.MultiPlayClearOnly;
                int  selectedMultiTowerFloor1 = GlobalVars.SelectedMultiTowerFloor;
                if (Network.Mode != Network.EConnectMode.Online)
                {
                    GlobalVars.SelectedMultiPlayRoomID      = (int)(DateTime.Now - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds;
                    GlobalVars.SelectedMultiPlayPhotonAppID = string.Empty;
                    GlobalVars.SelectedMultiPlayRoomName    = Guid.NewGuid().ToString();
                    DebugUtility.Log("MakeRoom RoomID:" + (object)GlobalVars.SelectedMultiPlayRoomID + " AppID:" + GlobalVars.SelectedMultiPlayPhotonAppID + " Name:" + GlobalVars.SelectedMultiPlayRoomName);
                    this.Success();
                    break;
                }
                MultiInvitationSendWindow.ClearInvited();
                ((Behaviour)this).set_enabled(true);
                this.API = FlowNode_MultiPlayAPI.EAPI.MAKE;
                if (pinID != 22)
                {
                    this.ExecRequest((WebAPI) new ReqMPRoomMake(GlobalVars.SelectedQuestID, str1, GlobalVars.EditMultiPlayRoomPassCode, isPrivate, limit, unitlv, clear, new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback)));
                    break;
                }
                this.ExecRequest((WebAPI) new ReqMultiTwRoomMake(GlobalVars.SelectedMultiTowerID, str1, GlobalVars.EditMultiPlayRoomPassCode, selectedMultiTowerFloor1, new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback)));
                break;

            case 2:
            case 5:
            case 23:
            case 50:
                string fuid = (string)null;
                if (pinID == 5)
                {
                    fuid = FlowNode_OnUrlSchemeLaunch.LINEParam_decided.creatorFUID;
                }
                else if (pinID == 50)
                {
                    fuid = GlobalVars.MultiInvitationRoomOwner;
                }
                DebugUtility.Log("ListRoom FUID:" + fuid);
                if (Network.Mode != Network.EConnectMode.Online)
                {
                    this.StartCoroutine(this.GetPhotonRoomList(fuid));
                    break;
                }
                FlowNode_MultiPlayAPI.RoomList = (ReqMPRoom.Response)null;
                string iname = string.Empty;
                if (pinID == 2)
                {
                    iname = GlobalVars.SelectedQuestID;
                }
                int selectedMultiTowerFloor2 = GlobalVars.SelectedMultiTowerFloor;
                ((Behaviour)this).set_enabled(true);
                this.API = FlowNode_MultiPlayAPI.EAPI.ROOM;
                if (pinID != 23)
                {
                    this.ExecRequest((WebAPI) new ReqMPRoom(fuid, iname, new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback)));
                    break;
                }
                this.ExecRequest((WebAPI) new ReqMultiTwRoom(fuid, iname, selectedMultiTowerFloor2, new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback)));
                break;

            case 3:
            case 6:
            case 24:
            case 51:
                if (FlowNode_MultiPlayAPI.RoomList == null || FlowNode_MultiPlayAPI.RoomList.rooms == null || FlowNode_MultiPlayAPI.RoomList.rooms.Length <= 0)
                {
                    this.Failure();
                    break;
                }
                this.ResetPlacementParam();
                bool LockRoom = false;
                switch (pinID)
                {
                case 6:
                    if (FlowNode_MultiPlayAPI.RoomList.rooms.Length != 1 || FlowNode_MultiPlayAPI.RoomList.rooms[0] == null)
                    {
                        this.Failure();
                        return;
                    }
                    GlobalVars.SelectedMultiPlayRoomID = FlowNode_MultiPlayAPI.RoomList.rooms[0].roomid;
                    DebugUtility.Log("JoinRoom for LINE RoomID:" + (object)GlobalVars.SelectedMultiPlayRoomID);
                    break;

                case 51:
                    if (FlowNode_MultiPlayAPI.RoomList.rooms.Length != 1 || FlowNode_MultiPlayAPI.RoomList.rooms[0] == null)
                    {
                        this.Failure();
                        return;
                    }
                    LockRoom = GlobalVars.MultiInvitationRoomLocked;
                    GlobalVars.SelectedMultiPlayRoomID = FlowNode_MultiPlayAPI.RoomList.rooms[0].roomid;
                    DebugUtility.Log("JoinRoom for Invitation RoomID:" + (object)GlobalVars.SelectedMultiPlayRoomID);
                    break;
                }
                GlobalVars.ResumeMultiplayPlayerID = 0;
                GlobalVars.ResumeMultiplaySeatID   = 0;
                GlobalVars.SelectedQuestID         = (string)null;
                for (int index = 0; index < FlowNode_MultiPlayAPI.RoomList.rooms.Length; ++index)
                {
                    if (FlowNode_MultiPlayAPI.RoomList.rooms[index].quest != null && !string.IsNullOrEmpty(FlowNode_MultiPlayAPI.RoomList.rooms[index].quest.iname) && FlowNode_MultiPlayAPI.RoomList.rooms[index].roomid == GlobalVars.SelectedMultiPlayRoomID)
                    {
                        GlobalVars.SelectedQuestID = FlowNode_MultiPlayAPI.RoomList.rooms[index].quest.iname;
                        break;
                    }
                }
                if (string.IsNullOrEmpty(GlobalVars.SelectedQuestID))
                {
                    this.Failure();
                    break;
                }
                if (Network.Mode != Network.EConnectMode.Online)
                {
                    this.StartCoroutine(this.GetPhotonRoomName());
                    break;
                }
                int selectedMultiTowerFloor3 = GlobalVars.SelectedMultiTowerFloor;
                ((Behaviour)this).set_enabled(true);
                this.API = FlowNode_MultiPlayAPI.EAPI.JOIN;
                if (pinID != 24)
                {
                    this.ExecRequest((WebAPI) new ReqMPRoomJoin(GlobalVars.SelectedMultiPlayRoomID, new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback), LockRoom));
                    break;
                }
                this.ExecRequest((WebAPI) new ReqMultiTwRoomJoin(GlobalVars.SelectedMultiPlayRoomID, new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback), LockRoom, selectedMultiTowerFloor3, false));
                break;

            case 7:
            case 26:
            case 55:
            case 56:
                if (Network.Mode != Network.EConnectMode.Online)
                {
                    this.Success();
                    break;
                }
                if (!string.IsNullOrEmpty(GlobalVars.EditMultiPlayRoomComment) && !MyMsgInput.isLegal(GlobalVars.EditMultiPlayRoomComment))
                {
                    DebugUtility.Log("comment is not legal");
                    this.ActivateOutputLinks(4801);
                    break;
                }
                switch (pinID)
                {
                case 55:
                    GlobalVars.EditMultiPlayRoomPassCode = "0";
                    GlobalVars.EditMultiPlayRoomComment  = GlobalVars.SelectedMultiPlayRoomComment;
                    break;

                case 56:
                    GlobalVars.EditMultiPlayRoomPassCode = "1";
                    GlobalVars.EditMultiPlayRoomComment  = GlobalVars.SelectedMultiPlayRoomComment;
                    break;
                }
                ((Behaviour)this).set_enabled(true);
                this.API = FlowNode_MultiPlayAPI.EAPI.UPDATE;
                if (GlobalVars.SelectedMultiPlayRoomType != JSON_MyPhotonRoomParam.EType.TOWER)
                {
                    this.ExecRequest((WebAPI) new ReqMPRoomUpdate(GlobalVars.SelectedMultiPlayRoomID, GlobalVars.EditMultiPlayRoomComment, GlobalVars.EditMultiPlayRoomPassCode, new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback)));
                    break;
                }
                string selectedMultiTowerId     = GlobalVars.SelectedMultiTowerID;
                int    selectedMultiTowerFloor4 = GlobalVars.SelectedMultiTowerFloor;
                this.ExecRequest((WebAPI) new ReqMultiTwRoomUpdate(GlobalVars.SelectedMultiPlayRoomID, GlobalVars.EditMultiPlayRoomComment, GlobalVars.EditMultiPlayRoomPassCode, selectedMultiTowerId, selectedMultiTowerFloor4, new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback)));
                break;

            case 8:
            case 25:
            case 28:
                if (Network.Mode != Network.EConnectMode.Online)
                {
                    this.Failure();
                    break;
                }
                if (GlobalVars.SelectedMultiPlayRoomID < FlowNode_MultiPlayAPI.ROOMID_VALIDATE_MIN || GlobalVars.SelectedMultiPlayRoomID > FlowNode_MultiPlayAPI.ROOMID_VALIDATE_MAX)
                {
                    this.Failure();
                    break;
                }
                this.ResetPlacementParam();
                GlobalVars.ResumeMultiplayPlayerID = 0;
                GlobalVars.ResumeMultiplaySeatID   = 0;
                ((Behaviour)this).set_enabled(true);
                this.API = FlowNode_MultiPlayAPI.EAPI.JOIN;
                if (pinID != 25 && pinID != 28)
                {
                    this.ExecRequest((WebAPI) new ReqMPRoomJoin(GlobalVars.SelectedMultiPlayRoomID, new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback), true));
                    break;
                }
                this.API = FlowNode_MultiPlayAPI.EAPI.MT_JOIN;
                this.ExecRequest((WebAPI) new ReqMultiTwRoomJoin(GlobalVars.SelectedMultiPlayRoomID, new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback), true, 0, pinID == 28));
                break;

            case 9:
                if (Network.Mode != Network.EConnectMode.Online)
                {
                    this.Success();
                    break;
                }
                ((Behaviour)this).set_enabled(true);
                this.API = FlowNode_MultiPlayAPI.EAPI.VERSION;
                this.ExecRequest((WebAPI) new ReqMPVersion(new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback)));
                break;

            case 10:
                if (Network.Mode != Network.EConnectMode.Online)
                {
                    this.Success();
                    break;
                }
                GlobalVars.SelectedMultiPlayRoomName = string.Empty;
                GlobalVars.VersusRoomReuse           = false;
                GlobalVars.ResumeMultiplayPlayerID   = 0;
                GlobalVars.ResumeMultiplaySeatID     = 0;
                GlobalVars.MultiPlayVersusKey        = MonoSingleton <GameManager> .Instance.GetVersusKey(GlobalVars.SelectedMultiPlayVersusType);

                ((Behaviour)this).set_enabled(true);
                this.API = FlowNode_MultiPlayAPI.EAPI.VERSUS_START;
                this.ExecRequest((WebAPI) new ReqVersusStart(GlobalVars.SelectedMultiPlayVersusType, new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback)));
                break;

            case 11:
                if (Network.Mode != Network.EConnectMode.Online)
                {
                    this.Success();
                    break;
                }
                string empty2 = string.Empty;
                string str2   = !PlayerPrefsUtility.HasKey(PlayerPrefsUtility.ROOM_COMMENT_KEY) ? LocalizedText.Get("sys.DEFAULT_ROOM_COMMENT") : PlayerPrefsUtility.GetString(PlayerPrefsUtility.ROOM_COMMENT_KEY, string.Empty);
                if (string.IsNullOrEmpty(str2))
                {
                    str2 = LocalizedText.Get("sys.DEFAULT_ROOM_COMMENT");
                }
                if (!MyMsgInput.isLegal(str2))
                {
                    DebugUtility.Log("comment is not legal");
                    this.ActivateOutputLinks(4801);
                    break;
                }
                FlowNode_MultiPlayAPI.RoomMakeTime      = Time.get_realtimeSinceStartup();
                GlobalVars.SelectedMultiPlayRoomComment = str2;
                ((Behaviour)this).set_enabled(true);
                this.API = FlowNode_MultiPlayAPI.EAPI.VERSUS_MAKE;
                this.ExecRequest((WebAPI) new ReqVersusMake(GlobalVars.SelectedMultiPlayVersusType, str2, GlobalVars.SelectedQuestID, false, new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback)));
                break;

            case 12:
                if (Network.Mode != Network.EConnectMode.Online)
                {
                    this.Failure();
                    break;
                }
                if (GlobalVars.SelectedMultiPlayRoomID < FlowNode_MultiPlayAPI.ROOMID_VALIDATE_MIN || GlobalVars.SelectedMultiPlayRoomID > FlowNode_MultiPlayAPI.ROOMID_VALIDATE_MAX)
                {
                    this.Failure();
                    break;
                }
                ((Behaviour)this).set_enabled(true);
                this.API = FlowNode_MultiPlayAPI.EAPI.VERSUS_JOIN;
                this.ExecRequest((WebAPI) new ReqVersusRoomJoin(GlobalVars.SelectedMultiPlayRoomID, new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback)));
                break;

            case 13:
                if (Network.Mode != Network.EConnectMode.Online)
                {
                    this.Success();
                    break;
                }
                if (!MyMsgInput.isLegal(GlobalVars.EditMultiPlayRoomComment))
                {
                    DebugUtility.Log("comment is not legal");
                    this.ActivateOutputLinks(4801);
                    break;
                }
                ((Behaviour)this).set_enabled(true);
                this.API = FlowNode_MultiPlayAPI.EAPI.UPDATE;
                this.ExecRequest((WebAPI) new ReqVersusRoomUpdate(GlobalVars.SelectedMultiPlayRoomID, GlobalVars.EditMultiPlayRoomComment, GlobalVars.SelectedQuestID, new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback)));
                break;

            case 14:
                GlobalVars.SelectedMultiPlayRoomName = string.Empty;
                GlobalVars.VersusRoomReuse           = false;
                GlobalVars.ResumeMultiplayPlayerID   = 0;
                GlobalVars.ResumeMultiplaySeatID     = 0;
                GlobalVars.MultiPlayVersusKey        = MonoSingleton <GameManager> .Instance.GetVersusKey(GlobalVars.SelectedMultiPlayVersusType);

                this.Success();
                break;

            case 15:
                if (Network.Mode != Network.EConnectMode.Online)
                {
                    this.Success();
                    break;
                }
                ((Behaviour)this).set_enabled(true);
                this.API = FlowNode_MultiPlayAPI.EAPI.VERSUS_LINE_REQ;
                this.ExecRequest((WebAPI) new ReqVersusLine(GlobalVars.SelectedMultiPlayRoomName, new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback)));
                break;

            case 16:
                if (Network.Mode != Network.EConnectMode.Online)
                {
                    this.Success();
                    break;
                }
                GlobalVars.VersusRoomReuse         = false;
                FlowNode_MultiPlayAPI.RoomMakeTime = Time.get_realtimeSinceStartup();
                ((Behaviour)this).set_enabled(true);
                this.API = FlowNode_MultiPlayAPI.EAPI.VERSUS_LINE_MAKE;
                this.ExecRequest((WebAPI) new ReqVersusLineMake(GlobalVars.SelectedMultiPlayRoomName, new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback)));
                break;

            case 17:
                if (Network.Mode != Network.EConnectMode.Online)
                {
                    this.Failure();
                    break;
                }
                GlobalVars.SelectedMultiPlayRoomID = FlowNode_OnUrlSchemeLaunch.LINEParam_decided.roomid;
                if (GlobalVars.SelectedMultiPlayRoomID < FlowNode_MultiPlayAPI.ROOMID_VALIDATE_MIN || GlobalVars.SelectedMultiPlayRoomID > FlowNode_MultiPlayAPI.ROOMID_VALIDATE_MAX)
                {
                    this.Failure();
                    break;
                }
                ((Behaviour)this).set_enabled(true);
                this.API = FlowNode_MultiPlayAPI.EAPI.VERSUS_JOIN;
                this.ExecRequest((WebAPI) new ReqVersusRoomJoin(GlobalVars.SelectedMultiPlayRoomID, new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback)));
                break;

            case 18:
                if (Network.Mode != Network.EConnectMode.Online)
                {
                    this.Failure();
                    break;
                }
                ((Behaviour)this).set_enabled(true);
                this.API = FlowNode_MultiPlayAPI.EAPI.VERSUS_STATUS;
                this.ExecRequest((WebAPI) new ReqVersusStatus(new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback)));
                break;

            case 19:
                if (Network.Mode != Network.EConnectMode.Online)
                {
                    this.Failure();
                    break;
                }
                ((Behaviour)this).set_enabled(true);
                this.API = FlowNode_MultiPlayAPI.EAPI.VERSUS_SEASON;
                this.ExecRequest((WebAPI) new ReqVersusSeason(new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback)));
                break;

            case 20:
                if (Network.Mode != Network.EConnectMode.Online)
                {
                    this.Failure();
                    break;
                }
                ((Behaviour)this).set_enabled(true);
                this.API = FlowNode_MultiPlayAPI.EAPI.VERSUS_FRIEND;
                this.ExecRequest((WebAPI) new ReqVersusFriendScore(new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback)));
                break;

            case 21:
                GameManager instance1 = MonoSingleton <GameManager> .Instance;
                MyPhoton    instance2 = PunMonoSingleton <MyPhoton> .Instance;
                if (UnityEngine.Object.op_Inequality((UnityEngine.Object)instance2, (UnityEngine.Object)null) && instance2.IsConnectedInRoom())
                {
                    GlobalVars.CreateAutoMultiTower = true;
                    if (instance2.IsCreatedRoom())
                    {
                        instance2.OpenRoom(true, false);
                        MyPhoton.MyRoom currentRoom = instance2.GetCurrentRoom();
                        if (currentRoom != null)
                        {
                            JSON_MyPhotonRoomParam myPhotonRoomParam = JSON_MyPhotonRoomParam.Parse(currentRoom.json);
                            if (myPhotonRoomParam != null)
                            {
                                List <MultiTowerFloorParam> mtAllFloorParam = instance1.GetMTAllFloorParam(GlobalVars.SelectedMultiTowerID);
                                if (mtAllFloorParam != null)
                                {
                                    GlobalVars.SelectedMultiTowerFloor = Mathf.Min(mtAllFloorParam.Count, GlobalVars.SelectedMultiTowerFloor + 1);
                                }
                                myPhotonRoomParam.challegedMTFloor = GlobalVars.SelectedMultiTowerFloor;
                                myPhotonRoomParam.iname            = GlobalVars.SelectedMultiTowerID + "_" + myPhotonRoomParam.challegedMTFloor.ToString();
                                instance2.SetRoomParam(myPhotonRoomParam.Serialize());
                            }
                        }
                    }
                    instance2.AddMyPlayerParam("BattleStart", (object)false);
                    instance2.AddMyPlayerParam("resume", (object)false);
                    MyPhoton.MyPlayer myPlayer = instance2.GetMyPlayer();
                    if (myPlayer != null)
                    {
                        JSON_MyPhotonPlayerParam photonPlayerParam = JSON_MyPhotonPlayerParam.Parse(myPlayer.json);
                        if (photonPlayerParam != null)
                        {
                            photonPlayerParam.mtChallengeFloor = instance1.GetMTChallengeFloor();
                            photonPlayerParam.mtClearedFloor   = instance1.GetMTClearedMaxFloor();
                            instance2.SetMyPlayerParam(photonPlayerParam.Serialize());
                        }
                    }
                    this.Success();
                    break;
                }
                this.Failure();
                break;

            case 27:
                if (Network.Mode != Network.EConnectMode.Online)
                {
                    this.Failure();
                    break;
                }
                ((Behaviour)this).set_enabled(true);
                this.API = FlowNode_MultiPlayAPI.EAPI.MT_STATUS;
                this.ExecRequest((WebAPI) new ReqMultiTwStatus(GlobalVars.SelectedMultiTowerID, new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback)));
                break;

            case 29:
                MyPhoton instance3 = PunMonoSingleton <MyPhoton> .Instance;
                if (UnityEngine.Object.op_Inequality((UnityEngine.Object)instance3, (UnityEngine.Object)null) && instance3.IsConnectedInRoom())
                {
                    this.Success();
                    break;
                }
                this.Failure();
                break;
            }
        }
Esempio n. 23
0
            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;
                                    }
                                }
                            }
                        }
                    }
                }
            }
Esempio n. 24
0
        public override void OnActivate(int pinID)
        {
            int num1 = pinID;

            if (pinID == 0 || pinID == 100 || pinID == 200)
            {
                PunMonoSingleton <MyPhoton> .Instance.IsMultiPlay   = pinID == 100 || pinID == 200;
                PunMonoSingleton <MyPhoton> .Instance.IsMultiVersus = pinID == 200;
                pinID = 0;
            }
            if (pinID == 10)
            {
                this.mResume = true;
                pinID        = 0;
            }
            if (pinID != 0 || ((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
            {
                GameManager instance = MonoSingleton <GameManager> .Instance;
                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)
                {
                    PartyData partyOfType = instance.Player.FindPartyOfType(partyIndex1);
                    int       partyIndex2 = instance.Player.Partys.IndexOf(partyOfType);
                    if (this.mStartingQuest.type == QuestTypes.Arena)
                    {
                        ArenaPlayer selectedArenaPlayer = (ArenaPlayer)GlobalVars.SelectedArenaPlayer;
                        this.ExecRequest((WebAPI) new ReqBtlColoReq(this.mStartingQuest.iname, selectedArenaPlayer.FUID, selectedArenaPlayer, new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback), partyIndex2));
                    }
                    else
                    {
                        // ISSUE: object of a compiler-generated type is created
                        // ISSUE: variable of a compiler-generated type
                        FlowNode_StartQuest.\u003COnActivate\u003Ec__AnonStorey20E activateCAnonStorey20E = new FlowNode_StartQuest.\u003COnActivate\u003Ec__AnonStorey20E();
                        // ISSUE: reference to a compiler-generated field
                        activateCAnonStorey20E.pt = PunMonoSingleton <MyPhoton> .Instance;
                        bool   multi  = false;
                        bool   isHost = false;
                        int    seat   = -1;
                        int    plid   = -1;
                        string uid    = string.Empty;
                        // ISSUE: reference to a compiler-generated field
                        if (Object.op_Inequality((Object)activateCAnonStorey20E.pt, (Object)null))
                        {
                            // ISSUE: reference to a compiler-generated field
                            multi = activateCAnonStorey20E.pt.IsMultiPlay;
                            // ISSUE: reference to a compiler-generated field
                            isHost = activateCAnonStorey20E.pt.IsOldestPlayer();
                            // ISSUE: reference to a compiler-generated field
                            seat = activateCAnonStorey20E.pt.MyPlayerIndex;
                            // ISSUE: reference to a compiler-generated field
                            MyPhoton.MyPlayer myPlayer = activateCAnonStorey20E.pt.GetMyPlayer();
                            if (myPlayer != null)
                            {
                                plid = myPlayer.playerID;
                            }
                            // ISSUE: reference to a compiler-generated field
                            if (activateCAnonStorey20E.pt.IsMultiVersus)
                            {
                                // ISSUE: reference to a compiler-generated field
                                List <JSON_MyPhotonPlayerParam> myPlayersStarted = activateCAnonStorey20E.pt.GetMyPlayersStarted();
                                // ISSUE: reference to a compiler-generated field
                                MyPhoton.MyRoom currentRoom = activateCAnonStorey20E.pt.GetCurrentRoom();
                                int             num2        = currentRoom == null ? 1 : currentRoom.playerCount;
                                // ISSUE: reference to a compiler-generated method
                                JSON_MyPhotonPlayerParam photonPlayerParam = myPlayersStarted.Find(new Predicate <JSON_MyPhotonPlayerParam>(activateCAnonStorey20E.\u003C\u003Em__1F5));
                                if (photonPlayerParam != null)
                                {
                                    uid = photonPlayerParam.UID;
                                }
                                if (string.IsNullOrEmpty(uid) || num2 == 1)
                                {
                                    this.OnVersusNoPlayer();
                                    return;
                                }
                            }
                        }
                        if (num1 == 200)
                        {
                            this.ExecRequest((WebAPI) new ReqVersus(this.mStartingQuest.iname, plid, seat, uid, new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback), GlobalVars.SelectedMultiPlayVersusType));
                        }
                        else
                        {
                            this.ExecRequest((WebAPI) new ReqBtlComReq(this.mStartingQuest.iname, GlobalVars.SelectedFriendID, new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback), multi, partyIndex2, isHost, plid, seat));
                        }
                    }
                }
                else
                {
                    this.StartCoroutine(this.StartScene((BattleCore.Json_Battle)null));
                }
            }
        }
Esempio n. 25
0
        public override void OnActivate(int pinID)
        {
            GameManager instance = MonoSingleton <GameManager> .Instance;

            instance.AudienceMode = false;
            this.mReqID           = pinID;
            if (pinID == 0 || pinID == 100 || (pinID == 200 || pinID == 500))
            {
                PunMonoSingleton <MyPhoton> .Instance.IsMultiPlay   = pinID == 100 || pinID == 200 || pinID == 500;
                PunMonoSingleton <MyPhoton> .Instance.IsMultiVersus = pinID == 200;
                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)
                    {
                        PartyData partyOfType = instance.Player.FindPartyOfType(partyIndex1);
                        int       partyIndex2 = instance.Player.Partys.IndexOf(partyOfType);
                        if (this.mStartingQuest.type == QuestTypes.Arena)
                        {
                            this.ActivateOutputLinks(5);
                            this.StartCoroutine(this.StartScene((BattleCore.Json_Battle)null));
                        }
                        else
                        {
                            // ISSUE: object of a compiler-generated type is created
                            // ISSUE: variable of a compiler-generated type
                            FlowNode_StartQuest.\u003COnActivate\u003Ec__AnonStorey2CC activateCAnonStorey2Cc = new FlowNode_StartQuest.\u003COnActivate\u003Ec__AnonStorey2CC();
                            // ISSUE: reference to a compiler-generated field
                            activateCAnonStorey2Cc.pt = PunMonoSingleton <MyPhoton> .Instance;
                            bool          multi      = false;
                            bool          isHost     = false;
                            int           seat       = -1;
                            int           plid       = -1;
                            string        uid        = string.Empty;
                            List <string> stringList = new List <string>();
                            // ISSUE: reference to a compiler-generated field
                            if (UnityEngine.Object.op_Inequality((UnityEngine.Object)activateCAnonStorey2Cc.pt, (UnityEngine.Object)null))
                            {
                                // ISSUE: reference to a compiler-generated field
                                multi = activateCAnonStorey2Cc.pt.IsMultiPlay;
                                // ISSUE: reference to a compiler-generated field
                                isHost = activateCAnonStorey2Cc.pt.IsOldestPlayer();
                                // ISSUE: reference to a compiler-generated field
                                seat = activateCAnonStorey2Cc.pt.MyPlayerIndex;
                                // ISSUE: reference to a compiler-generated field
                                MyPhoton.MyPlayer myPlayer = activateCAnonStorey2Cc.pt.GetMyPlayer();
                                if (myPlayer != null)
                                {
                                    plid = myPlayer.playerID;
                                }
                                // ISSUE: reference to a compiler-generated field
                                if (activateCAnonStorey2Cc.pt.IsMultiVersus)
                                {
                                    // ISSUE: reference to a compiler-generated field
                                    List <JSON_MyPhotonPlayerParam> myPlayersStarted = activateCAnonStorey2Cc.pt.GetMyPlayersStarted();
                                    // ISSUE: reference to a compiler-generated field
                                    MyPhoton.MyRoom currentRoom = activateCAnonStorey2Cc.pt.GetCurrentRoom();
                                    int             num         = currentRoom == null ? 1 : currentRoom.playerCount;
                                    // ISSUE: reference to a compiler-generated method
                                    JSON_MyPhotonPlayerParam photonPlayerParam = myPlayersStarted.Find(new Predicate <JSON_MyPhotonPlayerParam>(activateCAnonStorey2Cc.\u003C\u003Em__2AB));
                                    if (photonPlayerParam != null)
                                    {
                                        uid = photonPlayerParam.UID;
                                    }
                                    if (string.IsNullOrEmpty(uid) || num == 1)
                                    {
                                        this.OnVersusNoPlayer();
                                        return;
                                    }
                                }
                                else
                                {
                                    // ISSUE: reference to a compiler-generated field
                                    List <JSON_MyPhotonPlayerParam> myPlayersStarted = activateCAnonStorey2Cc.pt.GetMyPlayersStarted();
                                    for (int index = 0; index < myPlayersStarted.Count; ++index)
                                    {
                                        // ISSUE: reference to a compiler-generated field
                                        if (myPlayersStarted[index].playerIndex != activateCAnonStorey2Cc.pt.MyPlayerIndex)
                                        {
                                            stringList.Add(myPlayersStarted[index].UID);
                                        }
                                    }
                                }
                            }
                            if (this.mReqID == 200)
                            {
                                this.ExecRequest((WebAPI) new ReqVersus(this.mStartingQuest.iname, plid, seat, uid, new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback), GlobalVars.SelectedMultiPlayVersusType));
                            }
                            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
                            {
                                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
                        {
                            DebugUtility.LogError("Not Exist btlInfo");
                            if (audienceManager.IsRetryError)
                            {
                                Network.Abort();
                                this.ActivateOutputLinks(300);
                            }
                            else
                            {
                                this.ActivateOutputLinks(9);
                            }
                        }
                    }
                    else
                    {
                        DebugUtility.LogError("Not Exist StartParam");
                        if (audienceManager.IsRetryError)
                        {
                            Network.Abort();
                            this.ActivateOutputLinks(300);
                        }
                        else
                        {
                            this.ActivateOutputLinks(9);
                        }
                    }
                }
            }
        }
Esempio n. 26
0
        private void RefreshItems()
        {
            Transform transform = ((Component)this).get_transform();

            if (Object.op_Equality((Object)this.ItemTemplate, (Object)null))
            {
                return;
            }
            MyPhoton instance = PunMonoSingleton <MyPhoton> .Instance;

            MyPhoton.MyRoom          currentRoom        = instance.GetCurrentRoom();
            JSON_MyPhotonRoomParam   data1              = JSON_MyPhotonRoomParam.Parse(currentRoom.json);
            JSON_MyPhotonPlayerParam photonPlayerParam1 = data1 != null?data1.GetOwner() : (JSON_MyPhotonPlayerParam)null;

            int num1 = photonPlayerParam1 != null ? photonPlayerParam1.playerIndex : 0;
            List <MyPhoton.MyPlayer> roomPlayerList = instance.GetRoomPlayerList();

            for (int count = this.UIItemList.Count; count < currentRoom.maxPlayers; ++count)
            {
                this.UIItemList.Add((GameObject)Object.Instantiate <GameObject>((M0)this.ItemTemplate));
            }
            for (int index1 = 0; index1 < currentRoom.maxPlayers; ++index1)
            {
                JSON_MyPhotonPlayerParam data2 = (JSON_MyPhotonPlayerParam)null;
                int num2 = index1 + 1;
                if (num1 > 0)
                {
                    if (index1 == 0)
                    {
                        num2 = num1;
                    }
                    else if (index1 < num1)
                    {
                        num2 = index1;
                    }
                }
                using (List <MyPhoton.MyPlayer> .Enumerator enumerator = roomPlayerList.GetEnumerator())
                {
                    while (enumerator.MoveNext())
                    {
                        MyPhoton.MyPlayer current = enumerator.Current;
                        if (current.json != null)
                        {
                            JSON_MyPhotonPlayerParam photonPlayerParam2 = JSON_MyPhotonPlayerParam.Parse(current.json);
                            if (photonPlayerParam2 != null && photonPlayerParam2.playerIndex == num2)
                            {
                                data2 = photonPlayerParam2;
                                break;
                            }
                        }
                    }
                }
                if (data2 == null)
                {
                    data2             = new JSON_MyPhotonPlayerParam();
                    data2.playerIndex = num2;
                }
                GameObject uiItem = this.UIItemList[index1];
                ((Object)uiItem).set_hideFlags((HideFlags)52);
                DataSource.Bind <JSON_MyPhotonPlayerParam>(uiItem, data2);
                DataSource.Bind <JSON_MyPhotonRoomParam>(uiItem, data1);
                GameObjectID[] componentsInChildren = (GameObjectID[])uiItem.GetComponentsInChildren <GameObjectID>(true);
                if (data2 != null && data2.units != null && componentsInChildren != null)
                {
                    for (int index2 = 0; index2 < componentsInChildren.Length; ++index2)
                    {
                        GameObjectID gameObjectId = componentsInChildren[index2];
                        if (gameObjectId.ID != null)
                        {
                            DataSource.Bind <UnitData>(((Component)gameObjectId).get_gameObject(), (UnitData)null);
                        }
                    }
                    for (int index2 = 0; index2 < data2.units.Length; ++index2)
                    {
                        int      slotId = data2.units[index2].slotID;
                        UnitData unit   = data2.units[index2].unit;
                        if (unit != null)
                        {
                            for (int index3 = 0; index3 < componentsInChildren.Length; ++index3)
                            {
                                GameObjectID gameObjectId = componentsInChildren[index3];
                                if (gameObjectId.ID != null && gameObjectId.ID.Equals("unit" + (object)slotId))
                                {
                                    DataSource.Bind <UnitData>(((Component)gameObjectId).get_gameObject(), unit);
                                    break;
                                }
                            }
                        }
                    }
                }
                ListItemEvents component = (ListItemEvents)uiItem.GetComponent <ListItemEvents>();
                if (Object.op_Inequality((Object)component, (Object)null))
                {
                    component.OnSelect      = new ListItemEvents.ListItemEvent(this.OnSelectItem);
                    component.OnOpenDetail  = new ListItemEvents.ListItemEvent(this.OnOpenItemDetail);
                    component.OnCloseDetail = new ListItemEvents.ListItemEvent(this.OnCloseItemDetail);
                }
                uiItem.get_transform().SetParent(transform, false);
                uiItem.get_gameObject().SetActive(true);
            }
            DataSource.Bind <QuestParam>(this.Root, MonoSingleton <GameManager> .Instance.FindQuest(data1.iname));
            GameParameter.UpdateAll(this.Root);
            FlowNode_GameObject.ActivateOutputLinks((Component)this, 1);
        }
            public override void Update(FlowNode_MultiPlayJoinRoom self)
            {
                MyPhoton instance = PunMonoSingleton <MyPhoton> .Instance;

                if (instance.CurrentState != MyPhoton.MyState.ROOM)
                {
                    self.Failure();
                }
                else
                {
                    MyPhoton.MyPlayer        myPlayer       = instance.GetMyPlayer();
                    List <MyPhoton.MyPlayer> roomPlayerList = instance.GetRoomPlayerList();
                    using (List <MyPhoton.MyPlayer> .Enumerator enumerator = roomPlayerList.GetEnumerator())
                    {
                        while (enumerator.MoveNext())
                        {
                            MyPhoton.MyPlayer        current           = enumerator.Current;
                            JSON_MyPhotonPlayerParam photonPlayerParam = JSON_MyPhotonPlayerParam.Parse(current.json);
                            if (current.playerID < myPlayer.playerID && photonPlayerParam.playerIndex <= 0)
                            {
                                DebugUtility.Log("[PUN]waiting for player index turn..." + (object)current.playerID + " me:" + (object)myPlayer.playerID);
                                return;
                            }
                        }
                    }
                    MyPhoton.MyRoom currentRoom = instance.GetCurrentRoom();
                    if (currentRoom.maxPlayers == 0)
                    {
                        self.Failure();
                    }
                    else
                    {
                        bool[] flagArray = new bool[currentRoom.maxPlayers];
                        for (int index = 0; index < flagArray.Length; ++index)
                        {
                            flagArray[index] = false;
                        }
                        using (List <MyPhoton.MyPlayer> .Enumerator enumerator = roomPlayerList.GetEnumerator())
                        {
                            while (enumerator.MoveNext())
                            {
                                MyPhoton.MyPlayer        current           = enumerator.Current;
                                JSON_MyPhotonPlayerParam photonPlayerParam = JSON_MyPhotonPlayerParam.Parse(current.json);
                                if (current.playerID < myPlayer.playerID && photonPlayerParam.playerIndex > 0)
                                {
                                    flagArray[photonPlayerParam.playerIndex - 1] = true;
                                    DebugUtility.Log("[PUN]player index " + (object)photonPlayerParam.playerIndex + " is used. (room:" + (object)currentRoom.maxPlayers + ")");
                                }
                            }
                        }
                        for (int index = 0; index < currentRoom.maxPlayers; ++index)
                        {
                            if (!flagArray[index])
                            {
                                int num = index + 1;
                                DebugUtility.Log("[PUN]empty player index found: " + (object)num);
                                self.mJoinPlayerParam.playerID    = myPlayer.playerID;
                                self.mJoinPlayerParam.playerIndex = num;
                                instance.SetMyPlayerParam(self.mJoinPlayerParam.Serialize());
                                instance.MyPlayerIndex = num;
                                self.Success();
                                break;
                            }
                        }
                    }
                }
            }
Esempio n. 28
0
            public override void Update(FlowNode_MultiPlayJoinRoom self)
            {
                MyPhoton instance = PunMonoSingleton <MyPhoton> .Instance;

                if (instance.CurrentState != MyPhoton.MyState.ROOM)
                {
                    self.Failure();
                }
                else
                {
                    MyPhoton.MyPlayer        myPlayer       = instance.GetMyPlayer();
                    List <MyPhoton.MyPlayer> roomPlayerList = instance.GetRoomPlayerList();
                    using (List <MyPhoton.MyPlayer> .Enumerator enumerator = roomPlayerList.GetEnumerator())
                    {
                        while (enumerator.MoveNext())
                        {
                            MyPhoton.MyPlayer        current           = enumerator.Current;
                            JSON_MyPhotonPlayerParam photonPlayerParam = JSON_MyPhotonPlayerParam.Parse(current.json);
                            if (current.playerID < myPlayer.playerID && photonPlayerParam.playerIndex <= 0)
                            {
                                DebugUtility.Log("[PUN]waiting for player index turn..." + (object)current.playerID + " me:" + (object)myPlayer.playerID);
                                return;
                            }
                        }
                    }
                    MyPhoton.MyRoom currentRoom = instance.GetCurrentRoom();
                    if (currentRoom.maxPlayers == 0)
                    {
                        Debug.LogError((object)("Invalid Room:" + currentRoom.name));
                        PhotonNetwork.room.IsOpen = false;
                        self.Failure();
                    }
                    else
                    {
                        bool[] flagArray = new bool[currentRoom.maxPlayers];
                        for (int index = 0; index < flagArray.Length; ++index)
                        {
                            flagArray[index] = false;
                        }
                        using (List <MyPhoton.MyPlayer> .Enumerator enumerator = roomPlayerList.GetEnumerator())
                        {
                            while (enumerator.MoveNext())
                            {
                                MyPhoton.MyPlayer        current           = enumerator.Current;
                                JSON_MyPhotonPlayerParam photonPlayerParam = JSON_MyPhotonPlayerParam.Parse(current.json);
                                if (current.playerID < myPlayer.playerID && photonPlayerParam.playerIndex > 0)
                                {
                                    flagArray[photonPlayerParam.playerIndex - 1] = true;
                                    DebugUtility.Log("[PUN]player index " + (object)photonPlayerParam.playerIndex + " is used. (room:" + (object)currentRoom.maxPlayers + ")");
                                }
                            }
                        }
                        for (int index = 0; index < currentRoom.maxPlayers; ++index)
                        {
                            if (!flagArray[index])
                            {
                                int num = index + 1;
                                DebugUtility.Log("[PUN]empty player index found: " + (object)num);
                                if (instance.IsMultiVersus && num >= 3)
                                {
                                    foreach (PhotonPlayer player in PhotonNetwork.playerList)
                                    {
                                        new MyPhoton.MyPlayer().playerID = player.ID;
                                        Hashtable customProperties = player.CustomProperties;
                                        if (customProperties != null && ((Dictionary <object, object>)customProperties).Count > 0 && ((Dictionary <object, object>)customProperties).ContainsKey((object)"json"))
                                        {
                                            string buffer;
                                            GameUtility.Binary2Object <string>(out buffer, (byte[])customProperties.get_Item((object)"json"));
                                            Debug.Log((object)("player json : " + buffer));
                                        }
                                    }
                                    Debug.LogError((object)"MultiVersus is playerindex over : 3");
                                }
                                self.mJoinPlayerParam.playerID    = myPlayer.playerID;
                                self.mJoinPlayerParam.playerIndex = num;
                                self.mJoinPlayerParam.UpdateMultiTowerPlacement(true);
                                instance.SetMyPlayerParam(self.mJoinPlayerParam.Serialize());
                                instance.MyPlayerIndex = num;
                                self.Success();
                                break;
                            }
                        }
                    }
                }
            }