public override int Compare(MonsterUserData dataA, MonsterUserData dataB)
        {
            int num  = base.GetMonsterParameter(dataA.GetMonster(), dataA.GetMonsterMaster().Group.growStep);
            int num2 = base.GetMonsterParameter(dataB.GetMonster(), dataB.GetMonsterMaster().Group.growStep);

            num  = MonsterGrowStepData.GetGrowStepSortValue(num);
            num2 = MonsterGrowStepData.GetGrowStepSortValue(num2);
            if (this.sortOrder == MonsterSortOrder.DESC)
            {
                if (num > num2)
                {
                    return(-1);
                }
                if (num < num2)
                {
                    return(1);
                }
            }
            else
            {
                if (num < num2)
                {
                    return(-1);
                }
                if (num > num2)
                {
                    return(1);
                }
            }
            return(base.CompareMonsterIdAndLevel(dataA.GetMonster(), dataB.GetMonster()));
        }
        public bool CanVersionUp()
        {
            bool result = false;

            if (MonsterGrowStepData.IsUltimateScope(this.monsterMaster.Group.growStep) && int.Parse(this.monsterMaster.Simple.rare) == 5)
            {
                result = true;
            }
            return(result);
        }
        public static bool AnyHighGrowStepMonster(List <MonsterData> monsterUserDataList)
        {
            bool result = false;

            for (int i = 0; i < monsterUserDataList.Count; i++)
            {
                if (MonsterGrowStepData.IsGrowStepHigh(monsterUserDataList[i].GetMonsterMaster().Group.growStep))
                {
                    result = true;
                    break;
                }
            }
            return(result);
        }
Пример #4
0
        public static List <MonsterData> Filter(List <MonsterData> targetMonsterList, MonsterFilterType type)
        {
            List <MonsterData> list = new List <MonsterData>();

            switch (type)
            {
            case MonsterFilterType.GROWING_IN_GARDEN:
                for (int i = 0; i < targetMonsterList.Count; i++)
                {
                    bool flag = MonsterGrowStepData.IsGardenDigimonScope(targetMonsterList[i].GetMonsterMaster().Group.growStep);
                    if (flag && (targetMonsterList[i].GetMonster().IsEgg() || !string.IsNullOrEmpty(targetMonsterList[i].GetMonster().growEndDate)))
                    {
                        list.Add(targetMonsterList[i]);
                    }
                }
                break;

            case MonsterFilterType.ALL_OUT_GARDEN:
                for (int j = 0; j < targetMonsterList.Count; j++)
                {
                    if (!MonsterGrowStepData.IsGardenDigimonScope(targetMonsterList[j].GetMonsterMaster().Group.growStep))
                    {
                        list.Add(targetMonsterList[j]);
                    }
                }
                break;

            case MonsterFilterType.RESEARCH_TARGET:
                for (int k = 0; k < targetMonsterList.Count; k++)
                {
                    if (MonsterGrowStepData.IsUltimateScope(targetMonsterList[k].GetMonsterMaster().Group.growStep))
                    {
                        list.Add(targetMonsterList[k]);
                    }
                }
                break;

            case MonsterFilterType.CAN_EVOLVE:
                for (int l = 0; l < targetMonsterList.Count; l++)
                {
                    if (!MonsterGrowStepData.IsGardenDigimonScope(targetMonsterList[l].GetMonsterMaster().Group.growStep))
                    {
                        List <GameWebAPI.RespDataMA_GetMonsterEvolutionM.Evolution> evoList = ClassSingleton <EvolutionData> .Instance.GetEvoList(targetMonsterList[l].GetMonster().monsterId);

                        if (0 < evoList.Count)
                        {
                            list.Add(targetMonsterList[l]);
                        }
                    }
                }
                break;

            case MonsterFilterType.ALL_IN_GARDEN:
                for (int m = 0; m < targetMonsterList.Count; m++)
                {
                    if (MonsterGrowStepData.IsGardenDigimonScope(targetMonsterList[m].GetMonsterMaster().Group.growStep))
                    {
                        list.Add(targetMonsterList[m]);
                    }
                }
                break;

            case MonsterFilterType.HAVE_MEDALS:
                list = MonsterFilter.SelectionMedal(targetMonsterList, true);
                break;

            case MonsterFilterType.CAN_VERSION_UP:
                for (int n = 0; n < targetMonsterList.Count; n++)
                {
                    if (targetMonsterList[n].CanVersionUp())
                    {
                        List <GameWebAPI.RespDataMA_GetMonsterEvolutionM.Evolution> monsterVersionUpList = ClassSingleton <EvolutionData> .Instance.GetMonsterVersionUpList(targetMonsterList[n].GetMonsterMaster().Simple.monsterId);

                        if (0 < monsterVersionUpList.Count)
                        {
                            list.Add(targetMonsterList[n]);
                        }
                    }
                }
                break;

            case MonsterFilterType.ALL_VERSION_UP:
                for (int num = 0; num < targetMonsterList.Count; num++)
                {
                    if (MonsterStatusData.IsVersionUp(targetMonsterList[num].GetMonsterMaster().Simple.rare))
                    {
                        list.Add(targetMonsterList[num]);
                    }
                }
                break;
            }
            return(list);
        }
 public static bool IsChild1Scope(string growStep)
 {
     return(MonsterGrowStepData.IsChild1Scope(MonsterGrowStepData.ToGrowStep(growStep)));
 }
 public static bool IsChild2Scope(int growStep)
 {
     return(MonsterGrowStepData.IsChild2Scope((GrowStep)growStep));
 }
 public static bool IsHybridGroup(int growStep)
 {
     return(MonsterGrowStepData.IsHybridGroup((GrowStep)growStep));
 }
 public static bool IsHybridGroup(string growStep)
 {
     return(MonsterGrowStepData.IsHybridGroup(MonsterGrowStepData.ToGrowStep(growStep)));
 }
 public static bool IsUltimateGroup(int growStep)
 {
     return(MonsterGrowStepData.IsUltimateGroup((GrowStep)growStep));
 }
 public static bool IsUltimateGroup(string growStep)
 {
     return(MonsterGrowStepData.IsUltimateGroup(MonsterGrowStepData.ToGrowStep(growStep)));
 }
 public static bool IsPerfectGroup(int growStep)
 {
     return(MonsterGrowStepData.IsPerfectGroup((GrowStep)growStep));
 }
        public static string GetGrowStepName(string growStep)
        {
            string result = StringMaster.GetString("CharaStatus-03");

            GameWebAPI.RespDataMA_GetMonsterGrowStepM.MonsterGrowStepM growStepMaster = MonsterGrowStepData.GetGrowStepMaster(growStep);
            if (growStepMaster != null)
            {
                result = growStepMaster.monsterGrowStepName;
            }
            return(result);
        }
        public static bool IsGrowStepHigh(string growStep)
        {
            int growStep2 = int.Parse(growStep);

            return(MonsterGrowStepData.IsGrowStepHigh(growStep2));
        }
 public static bool IsGardenDigimonScope(string growStep)
 {
     return(MonsterGrowStepData.IsGardenDigimonScope(MonsterGrowStepData.ToGrowStep(growStep)));
 }
 public static bool IsGardenDigimonScope(int growStep)
 {
     return(MonsterGrowStepData.IsGardenDigimonScope((GrowStep)growStep));
 }