// Token: 0x060071FA RID: 29178 RVA: 0x001F9DC4 File Offset: 0x001F7FC4
        public int RaidHeroDungeonLevel(int leveld, int nums)
        {
            if (!BJLuaObjHelper.IsSkipLuaHotfix && this.TryInitHotFix("") && this.m_RaidHeroDungeonLevelInt32Int32_hotfix != null)
            {
                return(Convert.ToInt32(this.m_RaidHeroDungeonLevelInt32Int32_hotfix.call(new object[]
                {
                    this,
                    leveld,
                    nums
                })));
            }
            BJLuaObjHelper.IsSkipLuaHotfix = false;
            ConfigDataHeroDungeonLevelInfo configDataHeroDungeonLevelInfo = this.m_configDataLoader.GetConfigDataHeroDungeonLevelInfo(leveld);

            if (configDataHeroDungeonLevelInfo == null)
            {
                return(-2900);
            }
            for (int i = 0; i < nums; i++)
            {
                base.SetRaidSuccessHeroDungeonLevel(configDataHeroDungeonLevelInfo);
            }
            BattleReward battleReward = (this.m_battle as BattleComponent).GetBattleReward();

            battleReward.PlayerExp = configDataHeroDungeonLevelInfo.PlayerExpReward * nums;
            battleReward.HeroExp   = 0;
            battleReward.Gold      = configDataHeroDungeonLevelInfo.GoldReward * nums;
            return(0);
        }
        // Token: 0x060071F8 RID: 29176 RVA: 0x001F9BE0 File Offset: 0x001F7DE0
        public int FinishBattleHeroDungeonLevel(int levelId, List <int> gotAchievementIds, int stars, List <int> battleTreasures)
        {
            if (!BJLuaObjHelper.IsSkipLuaHotfix && this.TryInitHotFix("") && this.m_FinishBattleHeroDungeonLevelInt32List ` 1Int32List ` 1_hotfix != null)
            {
                return(Convert.ToInt32(this.m_FinishBattleHeroDungeonLevelInt32List ` 1Int32List ` 1_hotfix.call(new object[]
                {
                    this,
                    levelId,
                    gotAchievementIds,
                    stars,
                    battleTreasures
                })));
            }
            BJLuaObjHelper.IsSkipLuaHotfix = false;
            ConfigDataHeroDungeonLevelInfo configDataHeroDungeonLevelInfo = this.m_configDataLoader.GetConfigDataHeroDungeonLevelInfo(levelId);

            if (configDataHeroDungeonLevelInfo == null)
            {
                this.m_battle.FightFinished(GameFunctionStatus.Error, false, true);
                return(-2900);
            }
            if (stars > 0)
            {
                this.SetSuccessHeroDungeonLevel(configDataHeroDungeonLevelInfo, gotAchievementIds, stars, battleTreasures);
            }
            this.m_battle.FightFinished(GameFunctionStatus.End, stars > 0, true);
            return(0);
        }
        // Token: 0x060071FB RID: 29179 RVA: 0x001F9EB8 File Offset: 0x001F80B8
        public bool IsLevelChallenged(int levelId)
        {
            if (!BJLuaObjHelper.IsSkipLuaHotfix && this.TryInitHotFix("") && this.m_IsLevelChallengedInt32_hotfix != null)
            {
                return(Convert.ToBoolean(this.m_IsLevelChallengedInt32_hotfix.call(new object[]
                {
                    this,
                    levelId
                })));
            }
            BJLuaObjHelper.IsSkipLuaHotfix = false;
            ConfigDataHeroDungeonLevelInfo configDataHeroDungeonLevelInfo = this.m_configDataLoader.GetConfigDataHeroDungeonLevelInfo(levelId);

            return(configDataHeroDungeonLevelInfo != null && this.m_heroDungeonDS.FindLevel(configDataHeroDungeonLevelInfo.m_chapterId, levelId) != null);
        }
Exemple #4
0
        // Token: 0x0600CE0A RID: 52746 RVA: 0x0038B4F8 File Offset: 0x003896F8
        private void CreatePathItemList(List <GetPathData> getPathList, string getPathDesc)
        {
            if (!BJLuaObjHelper.IsSkipLuaHotfix && this.TryInitHotFix("") && this.m_CreatePathItemListList ` 1String_hotfix != null)
            {
                this.m_CreatePathItemListList ` 1String_hotfix.call(new object[]
                {
                    this,
                    getPathList,
                    getPathDesc
                });
                return;
            }
            BJLuaObjHelper.IsSkipLuaHotfix = false;
            GameObjectUtility.DestroyChildren(this.m_contentObj);
            if (getPathList == null || getPathList.Count == 0)
            {
                this.m_tips.gameObject.SetActive(true);
                this.m_tipsText.text = getPathDesc;
                return;
            }
            this.m_tips.gameObject.SetActive(false);
            IConfigDataLoader configDataLoader = GameManager.Instance.ConfigDataLoader as IConfigDataLoader;

            foreach (GetPathData getPathData in getPathList)
            {
                if (getPathData.PathType == GetPathType.GetPathType_HeroDungeon)
                {
                    ConfigDataHeroDungeonLevelInfo configDataHeroDungeonLevelInfo = configDataLoader.GetConfigDataHeroDungeonLevelInfo(getPathData.ID);
                    if (configDataHeroDungeonLevelInfo == null)
                    {
                        continue;
                    }
                    ConfigDataHeroInformationInfo configDataHeroInformationInfo = configDataLoader.GetConfigDataHeroInformationInfo(configDataHeroDungeonLevelInfo.m_chapterId);
                    if (configDataHeroInformationInfo == null || !configDataHeroInformationInfo.IsDungeonLevelsUnLock)
                    {
                        continue;
                    }
                }
                GameObject gameObject = UnityEngine.Object.Instantiate <GameObject>(this.m_itemPrefab);
                GetPathItemUIController getPathItemUIController = GameObjectUtility.AddControllerToGameObject <GetPathItemUIController>(gameObject);
                getPathItemUIController.EventOnGotoButtonClick += this.OnGetPathItemGotoButtonClick;
                getPathItemUIController.SetGetPath(getPathData);
                gameObject.transform.SetParent(this.m_contentObj.transform, false);
            }
        }
        // Token: 0x060071F9 RID: 29177 RVA: 0x001F9CD8 File Offset: 0x001F7ED8
        protected override void SetSuccessHeroDungeonLevel(ConfigDataHeroDungeonLevelInfo levelInfo, List <int> newGotAchievementRelationInds, int stars, List <int> battleTreasures)
        {
            if (!BJLuaObjHelper.IsSkipLuaHotfix && this.TryInitHotFix("") && this.m_SetSuccessHeroDungeonLevelConfigDataHeroDungeonLevelInfoList ` 1Int32List ` 1_hotfix != null)
            {
                this.m_SetSuccessHeroDungeonLevelConfigDataHeroDungeonLevelInfoList ` 1Int32List ` 1_hotfix.call(new object[]
                {
                    this,
                    levelInfo,
                    newGotAchievementRelationInds,
                    stars,
                    battleTreasures
                });
                return;
            }
            BJLuaObjHelper.IsSkipLuaHotfix = false;
            base.SetSuccessHeroDungeonLevel(levelInfo, newGotAchievementRelationInds, stars, battleTreasures);
            BattleReward battleReward = (this.m_battle as BattleComponent).GetBattleReward();

            battleReward.PlayerExp = levelInfo.PlayerExpReward;
            battleReward.HeroExp   = this.m_hero.GetAdditiveHeroAddExp(levelInfo.HeroExpReward);
            battleReward.Gold      = levelInfo.GoldReward;
        }
 // Token: 0x060071F7 RID: 29175 RVA: 0x001F9AD0 File Offset: 0x001F7CD0
 private void InitChapter(ProHeroDungeonChapter pbChapter)
 {
     if (!BJLuaObjHelper.IsSkipLuaHotfix && this.TryInitHotFix("") && this.m_InitChapterProHeroDungeonChapter_hotfix != null)
     {
         this.m_InitChapterProHeroDungeonChapter_hotfix.call(new object[]
         {
             this,
             pbChapter
         });
         return;
     }
     BJLuaObjHelper.IsSkipLuaHotfix = false;
     foreach (ProHeroDungeonLevel proHeroDungeonLevel in pbChapter.ChapterLevels)
     {
         ConfigDataHeroDungeonLevelInfo configDataHeroDungeonLevelInfo = this.m_configDataLoader.GetConfigDataHeroDungeonLevelInfo(proHeroDungeonLevel.LevelId);
         if (configDataHeroDungeonLevelInfo != null && configDataHeroDungeonLevelInfo.m_chapterId != 0)
         {
             base.InitLevel(configDataHeroDungeonLevelInfo.m_chapterId, proHeroDungeonLevel.LevelId, proHeroDungeonLevel.Stars, proHeroDungeonLevel.Nums);
         }
     }
     this.m_heroDungeonDS.InitChapteStarRewardIndexes(pbChapter.ChapterId, pbChapter.StarRewardIndexes);
 }
        // Token: 0x0601159C RID: 71068 RVA: 0x004800B8 File Offset: 0x0047E2B8
        public void SetDungeonInfo(ConfigDataHeroDungeonLevelInfo levelInfo)
        {
            if (!BJLuaObjHelper.IsSkipLuaHotfix && this.TryInitHotFix("") && this.m_SetDungeonInfoConfigDataHeroDungeonLevelInfo_hotfix != null)
            {
                this.m_SetDungeonInfoConfigDataHeroDungeonLevelInfo_hotfix.call(new object[]
                {
                    this,
                    levelInfo
                });
                return;
            }
            BJLuaObjHelper.IsSkipLuaHotfix = false;
            if (levelInfo == null)
            {
                return;
            }
            bool flag = this.m_playerContext.IsLevelChallenged(levelInfo.ID);

            this.m_levelInfo = levelInfo;
            int num = this.m_playerContext.CanUnLockHeroDungeonLevel(levelInfo.ID);

            if (num == 0)
            {
                int heroDungeonLevelStars            = this.m_playerContext.GetHeroDungeonLevelStars(levelInfo);
                int heroDungeonLevelAchievementCount = this.m_playerContext.GetHeroDungeonLevelAchievementCount(levelInfo);
                this.m_nameText.text        = levelInfo.Name;
                this.m_trophyValueText.text = string.Concat(new object[]
                {
                    "<color=yellow>",
                    heroDungeonLevelAchievementCount.ToString(),
                    "</color>/",
                    levelInfo.m_achievements.Length
                });
                this.m_trophyGameObject.SetActive(levelInfo.m_achievements.Length > 0);
                this.m_star1GameObject.SetActive(heroDungeonLevelStars >= 1);
                this.m_star2GameObject.SetActive(heroDungeonLevelStars >= 2);
                this.m_star3GameObject.SetActive(heroDungeonLevelStars >= 3);
                if (flag)
                {
                    if (heroDungeonLevelStars >= 3 && heroDungeonLevelAchievementCount >= levelInfo.m_achievements.Length)
                    {
                        this.m_uiStateController.SetToUIState("Perfect", false, true);
                    }
                    else if (this.m_playerContext.GetHeroDungeonLevelStars(levelInfo) >= 1)
                    {
                        this.m_uiStateController.SetToUIState("Clear", false, true);
                    }
                    else
                    {
                        this.m_uiStateController.SetToUIState("Normal", false, true);
                    }
                }
                else
                {
                    this.m_uiStateController.SetToUIState("New", false, true);
                }
                bool flag2 = levelInfo.HeroFragment_ID != 0;
                if (flag2)
                {
                    this.m_pieceImage.sprite   = AssetUtility.Instance.GetSprite(UIUtility.GetGoodsIconName(GoodsType.GoodsType_Item, levelInfo.HeroFragment_ID));
                    this.m_pieceImage.material = AssetUtility.Instance.GetAsset <Material>(UIUtility.GetGoodsIconMaterialName(GoodsType.GoodsType_Item, levelInfo.HeroFragment_ID));
                }
                this.m_pieceImage.gameObject.SetActive(flag2);
                int heroDungeonLevelCanChallengeNum = this.m_playerContext.GetHeroDungeonLevelCanChallengeNum(levelInfo);
                this.m_lastCountValueText.text = heroDungeonLevelCanChallengeNum.ToString();
                this.m_pieceImage.color        = ((heroDungeonLevelCanChallengeNum == 0) ? Color.grey : Color.white);
            }
            else if (num == -2901)
            {
                this.m_preLevelNotCompleteText.text = string.Format(this.m_configDataLoader.UtilityGetStringByStringTable(StringTableId.StringTableId_Msg_PreLevelCompleteOpen), new object[0]);
                this.m_uiStateController.SetToUIState("PreLevelLock", false, true);
            }
            else if (num == -2903)
            {
                this.m_favorLevelNotEnoughText.text = string.Format(this.m_configDataLoader.UtilityGetStringByStringTable(StringTableId.StringTableId_UnlockCondition_HeroDungeonLevel), levelInfo.UnlockConditions[0].Param2);
                this.m_uiStateController.SetToUIState("FavorLevelLock", false, true);
            }
        }
        // Token: 0x0600CE55 RID: 52821 RVA: 0x0038C0BC File Offset: 0x0038A2BC
        public void SetGetPath(GetPathData getPathInfo)
        {
            if (!BJLuaObjHelper.IsSkipLuaHotfix && this.TryInitHotFix("") && this.m_SetGetPathGetPathData_hotfix != null)
            {
                this.m_SetGetPathGetPathData_hotfix.call(new object[]
                {
                    this,
                    getPathInfo
                });
                return;
            }
            BJLuaObjHelper.IsSkipLuaHotfix = false;
            ProjectLPlayerContext projectLPlayerContext = GameManager.Instance.PlayerContext as ProjectLPlayerContext;
            IConfigDataLoader     configDataLoader      = GameManager.Instance.ConfigDataLoader as IConfigDataLoader;

            this.GetPathInfo = getPathInfo;
            ConfigDataStringTableForListInfo configDataStringTableForListInfo = configDataLoader.GetConfigDataStringTableForListInfo(getPathInfo.Name);

            this.m_nameText.text = configDataStringTableForListInfo.Content;
            int  num   = 0;
            int  num2  = 0;
            bool flag  = false;
            bool flag2 = true;

            switch (getPathInfo.PathType)
            {
            case GetPathType.GetPathType_Rift:
            {
                flag2 = projectLPlayerContext.IsGameFunctionOpened(GameFunctionType.GameFunctionType_Rift);
                RiftLevelStatus riftLevelStatus = projectLPlayerContext.GetRiftLevelStatus(getPathInfo.ID);
                flag2 = (flag2 && riftLevelStatus == RiftLevelStatus.Open);
                ConfigDataRiftLevelInfo configDataRiftLevelInfo = configDataLoader.GetConfigDataRiftLevelInfo(getPathInfo.ID);
                num  = projectLPlayerContext.GetRiftLevelCanChallengeNums(configDataRiftLevelInfo);
                num2 = projectLPlayerContext.GetRiftLevelCanChallengeMaxNums(configDataRiftLevelInfo);
                flag = true;
                break;
            }

            case GetPathType.GetPathType_Aniki:
                flag2 = projectLPlayerContext.IsGameFunctionOpened(GameFunctionType.GameFunctionType_AnikiGym);
                break;

            case GetPathType.GetPathType_ThearchyTrial:
                flag2 = projectLPlayerContext.IsGameFunctionOpened(GameFunctionType.GameFunctionType_ThearchyTrial);
                break;

            case GetPathType.GetPathType_Summon1:
            case GetPathType.GetPathType_Summon2:
            case GetPathType.GetPathType_Summon3:
                flag2 = projectLPlayerContext.IsGameFunctionOpened(GameFunctionType.GameFunctionType_SelectCard);
                break;

            case GetPathType.GetPathType_MemoryCorridor:
                flag2 = projectLPlayerContext.IsGameFunctionOpened(GameFunctionType.GameFunctionType_MemoryCorridor);
                break;

            case GetPathType.GetPathType_HeroTraining:
                flag2 = projectLPlayerContext.IsGameFunctionOpened(GameFunctionType.GameFunctionType_HeroTrainning);
                break;

            case GetPathType.GetPathType_Drill1:
            case GetPathType.GetPathType_Drill2:
                flag2 = projectLPlayerContext.IsGameFunctionOpened(GameFunctionType.GameFunctionType_TrainingGround);
                break;

            case GetPathType.GetPathType_Fetter:
                flag2 = projectLPlayerContext.IsGameFunctionOpened(GameFunctionType.GameFunctionType_Fetters);
                break;

            case GetPathType.GetPathType_Arena:
                flag2 = projectLPlayerContext.IsGameFunctionOpened(GameFunctionType.GameFunctionType_ArenaBattle);
                break;

            case GetPathType.GetPathType_Friend:
                flag2 = projectLPlayerContext.IsGameFunctionOpened(GameFunctionType.GameFunctionType_Friend);
                break;

            case GetPathType.GetPathType_TreasureMap:
                flag2 = projectLPlayerContext.IsGameFunctionOpened(GameFunctionType.GameFunctionType_TreasureMap);
                break;

            case GetPathType.GetPathType_Mission:
                flag2 = projectLPlayerContext.IsGameFunctionOpened(GameFunctionType.GameFunctionType_Mission);
                break;

            case GetPathType.GetPathType_HeroDungeon:
            {
                ConfigDataHeroDungeonLevelInfo configDataHeroDungeonLevelInfo = configDataLoader.GetConfigDataHeroDungeonLevelInfo(getPathInfo.ID);
                flag2 = (configDataHeroDungeonLevelInfo != null && projectLPlayerContext.IsGameFunctionOpened(GameFunctionType.GameFunctionType_HeroDungeon) && (projectLPlayerContext.CanAttackHeroDungeonLevel(getPathInfo.ID) == 0 || projectLPlayerContext.CanAttackHeroDungeonLevel(getPathInfo.ID) == -2905));
                num   = projectLPlayerContext.GetHeroDungeonLevelCanChallengeNum(configDataHeroDungeonLevelInfo);
                num2  = projectLPlayerContext.GetHeroDungeonLevelCanChallengeMaxNum(configDataHeroDungeonLevelInfo);
                flag  = true;
                break;
            }
            }
            if (flag2)
            {
                if (flag)
                {
                    this.m_stateCtrl.SetToUIState("Number", false, true);
                    this.m_timesValue.text    = num.ToString();
                    this.m_timesAllValue.text = num2.ToString();
                    if (num != 0)
                    {
                        this.m_timesStateCtrl.SetToUIState("Normal", false, true);
                    }
                    else
                    {
                        this.m_timesStateCtrl.SetToUIState("None", false, true);
                    }
                }
                else
                {
                    this.m_stateCtrl.SetToUIState("Normal", false, true);
                }
            }
            else
            {
                this.m_stateCtrl.SetToUIState("Lock", false, true);
            }
        }
Exemple #9
0
        // Token: 0x0600403F RID: 16447 RVA: 0x0012AAF0 File Offset: 0x00128CF0
        public int CanPostLevelDanmaku(int gameFunctionTypeId, int locationId, List <PostDanmakuEntry> entries)
        {
            if (!BJLuaObjHelper.IsSkipLuaHotfix && this.TryInitHotFix("") && this.m_CanPostLevelDanmakuInt32Int32List ` 1_hotfix != null)
            {
                return(Convert.ToInt32(this.m_CanPostLevelDanmakuInt32Int32List ` 1_hotfix.call(new object[]
                {
                    this,
                    gameFunctionTypeId,
                    locationId,
                    entries
                })));
            }
            BJLuaObjHelper.IsSkipLuaHotfix = false;
            int battle_ID;

            switch (gameFunctionTypeId)
            {
            case 9:
            {
                ConfigDataRiftLevelInfo configDataRiftLevelInfo = this.m_configDataLoader.GetConfigDataRiftLevelInfo(locationId);
                if (configDataRiftLevelInfo == null)
                {
                    return(-2701);
                }
                battle_ID = configDataRiftLevelInfo.Battle_ID;
                break;
            }

            case 10:
            {
                ConfigDataScenarioInfo configDataScenarioInfo = this.m_configDataLoader.GetConfigDataScenarioInfo(locationId);
                if (configDataScenarioInfo == null)
                {
                    return(-2701);
                }
                battle_ID = configDataScenarioInfo.Battle_ID;
                break;
            }

            case 11:
            {
                ConfigDataEventInfo configDataEventInfo = this.m_configDataLoader.GetConfigDataEventInfo(locationId);
                if (configDataEventInfo == null)
                {
                    return(-2701);
                }
                battle_ID = configDataEventInfo.Battle_ID;
                break;
            }

            case 12:
            {
                ConfigDataAnikiLevelInfo configDataAnikiLevelInfo = this.m_configDataLoader.GetConfigDataAnikiLevelInfo(locationId);
                if (configDataAnikiLevelInfo == null)
                {
                    return(-2701);
                }
                battle_ID = configDataAnikiLevelInfo.Battle_ID;
                break;
            }

            case 13:
            {
                ConfigDataThearchyTrialLevelInfo configDataThearchyTrialLevelInfo = this.m_configDataLoader.GetConfigDataThearchyTrialLevelInfo(locationId);
                if (configDataThearchyTrialLevelInfo == null)
                {
                    return(-2701);
                }
                battle_ID = configDataThearchyTrialLevelInfo.Battle_ID;
                break;
            }

            default:
                if (gameFunctionTypeId != 41)
                {
                    if (gameFunctionTypeId != 42)
                    {
                        if (gameFunctionTypeId != 56)
                        {
                            if (gameFunctionTypeId != 57)
                            {
                                if (gameFunctionTypeId != 79)
                                {
                                    if (gameFunctionTypeId != 80)
                                    {
                                        if (gameFunctionTypeId != 28)
                                        {
                                            if (gameFunctionTypeId != 51)
                                            {
                                                return(-2700);
                                            }
                                            ConfigDataHeroTrainningLevelInfo configDataHeroTrainningLevelInfo = this.m_configDataLoader.GetConfigDataHeroTrainningLevelInfo(locationId);
                                            if (configDataHeroTrainningLevelInfo == null)
                                            {
                                                return(-2701);
                                            }
                                            battle_ID = configDataHeroTrainningLevelInfo.Battle_ID;
                                        }
                                        else
                                        {
                                            ConfigDataHeroDungeonLevelInfo configDataHeroDungeonLevelInfo = this.m_configDataLoader.GetConfigDataHeroDungeonLevelInfo(locationId);
                                            if (configDataHeroDungeonLevelInfo == null)
                                            {
                                                return(-2701);
                                            }
                                            battle_ID = configDataHeroDungeonLevelInfo.Battle_ID;
                                        }
                                    }
                                    else
                                    {
                                        ConfigDataScoreLevelInfo configDataScoreLevelInfo = this.m_configDataLoader.GetConfigDataScoreLevelInfo(locationId);
                                        if (configDataScoreLevelInfo == null)
                                        {
                                            return(-2701);
                                        }
                                        battle_ID = configDataScoreLevelInfo.Battle_ID;
                                    }
                                }
                                else
                                {
                                    ConfigDataChallengeLevelInfo configDataChallengeLevelInfo = this.m_configDataLoader.GetConfigDataChallengeLevelInfo(locationId);
                                    if (configDataChallengeLevelInfo == null)
                                    {
                                        return(-2701);
                                    }
                                    battle_ID = configDataChallengeLevelInfo.Battle_ID;
                                }
                            }
                            else
                            {
                                ConfigDataCooperateBattleLevelInfo configDataCooperateBattleLevelInfo = this.m_configDataLoader.GetConfigDataCooperateBattleLevelInfo(locationId);
                                if (configDataCooperateBattleLevelInfo == null)
                                {
                                    return(-2701);
                                }
                                battle_ID = configDataCooperateBattleLevelInfo.Battle_ID;
                            }
                        }
                        else
                        {
                            ConfigDataHeroPhantomLevelInfo configDataHeroPhantomLevelInfo = this.m_configDataLoader.GetConfigDataHeroPhantomLevelInfo(locationId);
                            if (configDataHeroPhantomLevelInfo == null)
                            {
                                return(-2701);
                            }
                            battle_ID = configDataHeroPhantomLevelInfo.Battle_ID;
                        }
                    }
                    else
                    {
                        ConfigDataMemoryCorridorLevelInfo configDataMemoryCorridorLevelInfo = this.m_configDataLoader.GetConfigDataMemoryCorridorLevelInfo(locationId);
                        if (configDataMemoryCorridorLevelInfo == null)
                        {
                            return(-2701);
                        }
                        battle_ID = configDataMemoryCorridorLevelInfo.Battle_ID;
                    }
                }
                else
                {
                    ConfigDataTreasureLevelInfo configDataTreasureLevelInfo = this.m_configDataLoader.GetConfigDataTreasureLevelInfo(locationId);
                    if (configDataTreasureLevelInfo == null)
                    {
                        return(-2701);
                    }
                    battle_ID = configDataTreasureLevelInfo.Battle_ID;
                }
                break;
            }
            ConfigDataBattleInfo configDataBattleInfo = this.m_configDataLoader.GetConfigDataBattleInfo(battle_ID);
            int num = 0;

            foreach (PostDanmakuEntry postDanmakuEntry in entries)
            {
                if (postDanmakuEntry.Turn > configDataBattleInfo.TurnMax)
                {
                    return(-2702);
                }
                if (postDanmakuEntry.Turn <= num)
                {
                    return(-2703);
                }
                num = postDanmakuEntry.Turn;
            }
            return(0);
        }
 // Token: 0x06007238 RID: 29240 RVA: 0x001FA558 File Offset: 0x001F8758
 public void SetSuccessHeroDungeonLevel(ConfigDataHeroDungeonLevelInfo levelInfo, List <int> newGotAchievementRelationInds, int stars, List <int> battleTreasures)
 {
     this.m_owner.SetSuccessHeroDungeonLevel(levelInfo, newGotAchievementRelationInds, stars, battleTreasures);
 }
 // Token: 0x0600722C RID: 29228 RVA: 0x001FA498 File Offset: 0x001F8698
 public void __callBase_SetRaidSuccessHeroDungeonLevel(ConfigDataHeroDungeonLevelInfo levelInfo)
 {
     this.m_owner.__callBase_SetRaidSuccessHeroDungeonLevel(levelInfo);
 }
 // Token: 0x06007225 RID: 29221 RVA: 0x001FA41C File Offset: 0x001F861C
 public int __callBase_GetLevelCanChallengeMaxNums(ConfigDataHeroDungeonLevelInfo levelInfo)
 {
     return(this.m_owner.__callBase_GetLevelCanChallengeMaxNums(levelInfo));
 }
 // Token: 0x0600720F RID: 29199 RVA: 0x001FA0BC File Offset: 0x001F82BC
 private void __callBase_SetRaidSuccessHeroDungeonLevel(ConfigDataHeroDungeonLevelInfo levelInfo)
 {
     base.SetRaidSuccessHeroDungeonLevel(levelInfo);
 }
 // Token: 0x0600720E RID: 29198 RVA: 0x001FA0AC File Offset: 0x001F82AC
 private void __callBase_SetSuccessHeroDungeonLevel(ConfigDataHeroDungeonLevelInfo levelInfo, List <int> newGotAchievementRelationInds, int stars, List <int> battleTreasures)
 {
     base.SetSuccessHeroDungeonLevel(levelInfo, newGotAchievementRelationInds, stars, battleTreasures);
 }
 // Token: 0x06007208 RID: 29192 RVA: 0x001FA060 File Offset: 0x001F8260
 private int __callBase_GetLevelCanChallengeMaxNums(ConfigDataHeroDungeonLevelInfo levelInfo)
 {
     return(base.GetLevelCanChallengeMaxNums(levelInfo));
 }