Esempio n. 1
0
        private async Task LoadAbility()
        {
            await Task.Delay(10);

            Label[] abilityMags =
            {
                TDollDic_TDollInfo_AbilityHPMag,
                TDollDic_TDollInfo_AbilityFRMag,
                TDollDic_TDollInfo_AbilityEVMag,
                TDollDic_TDollInfo_AbilityACMag,
                TDollDic_TDollInfo_AbilityASMag
            };

            try
            {
                string[] abilities = { "HP", "FireRate", "Evasion", "Accuracy", "AttackSpeed" };


                string[] grow_ratio = doll.Abilities["Grow"].Split(';');

                for (int i = 0; i < abilityMags.Length; ++i)
                {
                    string[] basic_ratio = doll.Abilities[abilities[i]].Split(';');

                    int value = 0;

                    switch (modIndex)
                    {
                    case 0:
                        value = das.CalcAbility(abilities[i], int.Parse(basic_ratio[0]), int.Parse(grow_ratio[0]), abilityLv, abilityFavor, false);
                        break;

                    case 1:
                    case 2:
                    case 3:
                        value = das.CalcAbility(abilities[i], int.Parse(basic_ratio[1]), int.Parse(grow_ratio[1]), abilityLv, abilityFavor, true);
                        break;
                    }

                    abilityValues[i] = value;

                    abilityMags[i].Text = $"{value} ({doll.AbilityGrade[i]})";
                }

                if ((doll.Type == "MG") || (doll.Type == "SG"))
                {
                    TDollDic_TDollInfo_AbilityBulletPanel.Visible = true;
                    TDollDic_TDollInfo_AbilityReloadPanel.Visible = true;

                    double ReloadTime = CalcReloadTime(doll, doll.Type, abilityValues[4]);
                    int    Bullet     = 0;

                    if (doll.HasMod == false)
                    {
                        Bullet = int.Parse(doll.Abilities["Bullet"]);
                    }
                    else
                    {
                        Bullet = int.Parse(doll.Abilities["Bullet"].Split(';')[modIndex]);
                    }

                    TDollDic_TDollInfo_AbilityBulletMag.Text = Bullet.ToString();
                    TDollDic_TDollInfo_AbilityReloadMag.Text = $"{ReloadTime} 초";
                }
                else
                {
                    TDollDic_TDollInfo_AbilityBulletPanel.Visible = false;
                    TDollDic_TDollInfo_AbilityReloadPanel.Visible = false;
                }

                if (doll.Type == "SG")
                {
                    TDollDic_TDollInfo_AbilityAMPanel.Visible = true;

                    string[] basic_ratio = doll.Abilities["Armor"].Split(';');
                    int      value       = 0;

                    switch (modIndex)
                    {
                    case 0:
                        value = das.CalcAbility("Armor", int.Parse(basic_ratio[0]), int.Parse(grow_ratio[0]), abilityLv, abilityFavor, false);
                        break;

                    case 1:
                    case 2:
                    case 3:
                        value = das.CalcAbility("Armor", int.Parse(basic_ratio[1]), int.Parse(grow_ratio[1]), abilityLv, abilityFavor, true);
                        break;
                    }

                    abilityValues[5] = value;
                    TDollDic_TDollInfo_AbilityAMMag.Text = $"{value} ({doll.AbilityGrade[6]})";
                }
                else
                {
                    abilityValues[5] = 0;
                    TDollDic_TDollInfo_AbilityAMPanel.Visible = false;
                }
            }
            catch (Exception ex)
            {
                ETC.LogError(ex);
                ETC.ShowErrorMessage("인형 불러오기 오류", "능력치 정보를 불러오는 동안 오류가 발생했습니다.");
            }
        }
Esempio n. 2
0
        internal static void InitializeAverageAbility()
        {
            string[]  AbilityList  = { "HP", "FireRate", "Evasion", "Accuracy", "AttackSpeed" };
            const int TypeCount    = 6;
            const int AbilityCount = 6;

            AverageAbility Avg_HG  = new AverageAbility();
            AverageAbility Avg_SMG = new AverageAbility();
            AverageAbility Avg_AR  = new AverageAbility();
            AverageAbility Avg_RF  = new AverageAbility();
            AverageAbility Avg_MG  = new AverageAbility();
            AverageAbility Avg_SG  = new AverageAbility();

            Avg_List = new AverageAbility[TypeCount]
            {
                Avg_HG,
                Avg_SMG,
                Avg_AR,
                Avg_RF,
                Avg_MG,
                Avg_SG
            };

            int[] count = { 0, 0, 0, 0, 0, 0 };
            int[,] total = new int[TypeCount, AbilityCount];

            for (int i = 0; i < TypeCount; ++i)
            {
                for (int j = 0; j < AbilityCount; ++j)
                {
                    total[i, j] = 0;
                }
            }

            for (int i = 0; i < dollList.Rows.Count; ++i)
            {
                Doll           doll  = new Doll(dollList.Rows[i]);
                DollAbilitySet DAS   = new DollAbilitySet(doll.Type);
                int            index = 0;

                switch (doll.Type)
                {
                case "HG":
                    index = 0;
                    break;

                case "SMG":
                    index = 1;
                    break;

                case "AR":
                    index = 2;
                    break;

                case "RF":
                    index = 3;
                    break;

                case "MG":
                    index = 4;
                    break;

                case "SG":
                    index = 5;
                    break;
                }

                count[index] += 1;

                int grow_value = int.Parse(doll.Abilities["Grow"].Split(';')[0]);

                for (int j = 0; j < AbilityList.Length; ++j)
                {
                    int ability_value = int.Parse(doll.Abilities[AbilityList[j]].Split(';')[0]);

                    total[index, j] += DAS.CalcAbility(AbilityList[j], ability_value, grow_value, 100, 100, false);
                }

                if (doll.Type == "SG")
                {
                    int ability_value = int.Parse(doll.Abilities["Armor"].Split(';')[0]);

                    total[index, 5] += DAS.CalcAbility("Armor", ability_value, grow_value, 100, 100, false);
                }
            }

            for (int i = 0; i < TypeCount; ++i)
            {
                for (int j = 0; j < AbilityCount; ++j)
                {
                    int value = Convert.ToInt32(Math.Round((double)total[i, j] / count[i]));

                    switch (j)
                    {
                    case 0:
                        Avg_List[i].HP = value;
                        break;

                    case 1:
                        Avg_List[i].FR = value;
                        break;

                    case 2:
                        Avg_List[i].EV = value;
                        break;

                    case 3:
                        Avg_List[i].AC = value;
                        break;

                    case 4:
                        Avg_List[i].AS = value;
                        break;

                    case 5:
                        Avg_List[i].AM = value;
                        break;
                    }
                }
            }
        }