C#_2_boss_fight

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace C_Ijun
{
    internal class Program
    {
        static void Main(string[] args)
        {
            bool isMarker = false;
            bool isShadowFlicker = false;
            bool isStealHealth = false;
            bool isSacriface = false;
            bool isConcentrate = false;

            double healthHero = 1000;
            double healthEvil = 1500;
            double startedHealthEvil = healthEvil;
            double resultDamage;

            float modifyDamageFirstSeries = 1.5f;
            float modifyDamageSecondSeries = 2.5f;
            float modifyHeal = 1.1f;

            int weakAttackDamage = 10;
            int middleAttackDamage = 50;
            int strongAttackDamage = 100;
            int criticalAttackDamage = 250;

            int changeChanceHeroForHit = 30;
            int changeChanceForHeroFlicker = 60;
            int changeChanceMissByExhausted = 5;
            int chanceForEvilHit;
            int chanceForHeroHit;
            int chanceForHealingByEvil;
            int chanceForCriticalHit;
            int chanceForMagicMistake;
            int countHeal = 2;
            int countSeriesOfAttack = 4;
            int countStepsBeforeSeries = 3;
            int countStepsActiveShadowFlicker = 0;
            int countStepsActiveConcentrate = 0;
            int countStepsPassForStealHealth = 0;
            int countStepsRestartConcentrate = 0;
            int countStepsRestartShadowFlicker = 0;
            int countStepsRestartStealHealth = 0;
            int countMissedAttacksByEvil = 0;
            int countMissedForSacriface = 3;

            int flickerByEvil;
            int flickerByHero;

            int highChanceForCriticalHit = 3;
            int highChanceForEvilFlicker = 15;
            int highChanceForHeroFlicker = 15;
            int highChanceForHealingByEvil = 100;
            int highChanceForMagicMistake = 15;
            int highChanceEvilForHit = 100;
            int highChanceHeroForHit = 100;
            int highChanceAvgMissByEvil = 30;
            int highChanceWeakMissByHero = 10;
            int highChanceAvgMissByHero = 25;
            int highChanceStrongMissByHero = 65;
            int highFlickerConcentrate = 5;

            int levelEvilExhausted = 0;
            int levelHeroExhausted = 0;
            int lessChanceForCriticalHitByStrongAttack = 2;
            int lowChanceEvilForHit = 0;
            int lowChanceHeroForHit = 0;
            int lowChanceForCriticalHit = 0;
            int lowChanceForEvilFlicker = 0;
            int lowChanceForHeroFlicker = 0;
            int lowChanceForMagicMistake = 0;
            int lowChanceForHealingByEvil = 0;
            int lowChanceAvgMissByEvil = 25;
            int lowChanceWeakMissByHero = 0;
            int lowChanceAvgMissByHero = 10;
            int lowChanceStrongMissByHero = 50;
            int lowFlickerConcentrate = 0;

            int maxLevelExhausted = 5;
            int missAttack;
            int missWeakAttackByHero;
            int missMiddleAttackByEvil;
            int missMiddleAttackByHero;
            int missStrongAttackByHero;
            int multipleExhaustedNewLevelByEvil = 3;
            int multipleExhaustedNewLevelByHero = 5;
            int moreChanceForCriticalHitByMiddleAttack = 2;
            int moreChanceForCriticalHitByStrongAttack = 5;

            int newExhaustedChanceMiss = 2;
            int oneHundredPercent = 100;
            int percentOfDangerousDamage = 60;
            int percentOfDamageByEvil;

            int startedChanceForCriticalHit = highChanceForCriticalHit;
            int startedCountStepsActiveShadowFlicker = 2;
            int startedCountStepsRestartShadowFlicker = 4;
            int startedCountStepsActiveConcentrate = 5;
            int startedCountStepsRestartConcentrate = 4;
            int startedCountStepsPassForStealHealth = 1;
            int startedCountStepsRestartStealHealth = 5;
            int startedCountMissedAttacksByEvil = 0;
            int startedCountStepsBeforeSeries = countStepsBeforeSeries;
            int startedCountSeriesOfAttack = countSeriesOfAttack;
            int stepsFight = 1;
            int stepExhaustedStartByEvil = 20;
            int stepExhaustedStartByHero = 15;
            int sumDamageByHero;

            Random randomChance = new Random();
            string userChoice;

            Console.WriteLine("Ваш ход\n1 - Нанести слабый урон противнику(атака слабовата, зато наверняка попадёте)" +
                              "\n2 - Нанести средний урон противнику(хорошая атака, но вдруг промахнётесь?)" +
                              "\n3 - Нанести большой урон противнику(отличный выбор! Правда мало того, что скорее всего промахнётесь, можете навредить себе.)" +
                              "\n4 - Нанести метку, для повышенного урона(в течение 3х следующих ходов необходимо начать серию - 4 успешных удара по врагу. Серия начинается со 2го успешного удара, максимум серии - 3 удара)" +
                              "\n5 - Уйти в мерцающую тень(увеличить шанс уклонения от удара врага, действует 2 хода, доступно каждые 3 хода)" +
                              "\n6 - Украсть жизнь у врага(можете подлечиться за счёт противника, но знайте, что после этого не сможете наносить удары 5 ходов)" +
                              "\n7 - Жертва(Принесите часть здоровья в жертву, чтобы нанести хороший урон противнику(Доступно, если 3 раза смогли увернуться физическим уклонением. Нельзя сразу после жертвы применять похищение жизни или теневое мерцание. Если мерцание было до этого активно, то оно прекращается.)" +
                              "\n8 - Концентрация(Сосредоточьтесь на противнике и нанесите выверенный удар. Повышает шанс попадания. Правда, снижает шанс уклонения.)" +
                              "\n9 - Проверить статистику(Будьте осторожны, это будет за счёт хода героя)");
            Console.Write("Выберите действие: ");

            while (healthHero > 0 && healthEvil > 0)
            {
                chanceForCriticalHit = randomChance.Next(lowChanceForCriticalHit, highChanceForCriticalHit);
                chanceForEvilHit = randomChance.Next(lowChanceEvilForHit, highChanceEvilForHit);
                chanceForHeroHit = randomChance.Next(lowChanceHeroForHit, highChanceHeroForHit);

                if (isConcentrate)
                {
                    countStepsActiveConcentrate--;

                    if (countStepsActiveConcentrate == 0)
                    {
                        highChanceHeroForHit -= changeChanceHeroForHit;
                        lowChanceHeroForHit -= changeChanceHeroForHit;
                        isConcentrate = false;
                    }
                }

                flickerByEvil = randomChance.Next(lowChanceForEvilFlicker, highChanceForEvilFlicker);
                flickerByHero = randomChance.Next(lowChanceForHeroFlicker, highChanceForHeroFlicker);

                if (isShadowFlicker)
                {
                    countStepsActiveShadowFlicker--;

                    if (countStepsActiveShadowFlicker == 0)
                    {
                        highChanceForHeroFlicker -= changeChanceForHeroFlicker;
                        lowChanceForHeroFlicker -= changeChanceForHeroFlicker;
                        isShadowFlicker = false;
                    }
                }

                if (countStepsRestartConcentrate > 0)
                {
                    countStepsRestartConcentrate--;
                }

                if (countStepsRestartShadowFlicker > 0)
                {
                    countStepsRestartShadowFlicker--;
                }

                if (countStepsRestartStealHealth > 0)
                {
                    countStepsRestartStealHealth--;

                    if (countStepsRestartStealHealth == 0)
                    {
                        isStealHealth = false;
                    }
                }

                if (countStepsPassForStealHealth > 0)
                {
                    countStepsPassForStealHealth--;
                }
                else
                {
                    isSacriface = false;
                }
                userChoice = Console.ReadLine();

                switch (userChoice)
                {
                    case "1":
                        missWeakAttackByHero = randomChance.Next(lowChanceWeakMissByHero, highChanceWeakMissByHero);
                        missAttack = missWeakAttackByHero + flickerByEvil;

                        if (isStealHealth == false)
                        {
                            if (chanceForHeroHit > missAttack)
                            {
                                if (chanceForCriticalHit < missAttack)
                                {
                                    resultDamage = weakAttackDamage;
                                    highChanceForCriticalHit++;
                                }
                                else
                                {
                                    resultDamage = criticalAttackDamage;
                                    highChanceForCriticalHit = startedChanceForCriticalHit;
                                    Console.Write("Критический удар! ");
                                }

                                if (isMarker)
                                {
                                    countStepsBeforeSeries = startedCountStepsBeforeSeries;
                                    countSeriesOfAttack--;
                                    if (countSeriesOfAttack == 1)
                                    {
                                        resultDamage *= modifyDamageFirstSeries;
                                    }
                                    else if (countSeriesOfAttack == 0)
                                    {
                                        resultDamage *= modifyDamageSecondSeries;
                                        countSeriesOfAttack = startedCountSeriesOfAttack;
                                        isMarker = false;
                                    }
                                }
                                healthEvil -= resultDamage;
                                Console.WriteLine($"Попадание. HP Злодея - {healthEvil}");
                            }
                            else
                            {
                                if (highChanceForCriticalHit > 0)
                                {
                                    highChanceForCriticalHit--;
                                }

                                if (isMarker)
                                {
                                    countSeriesOfAttack = startedCountSeriesOfAttack;
                                    isMarker = false;
                                }
                                Console.WriteLine("Мимо.");
                            }
                        }
                        else
                        {
                            Console.WriteLine("Вы не отдохнули после вытягивания жизни.");
                        }
                        break;

                    case "2":
                        missMiddleAttackByHero = randomChance.Next(lowChanceAvgMissByHero, highChanceAvgMissByHero);
                        missAttack = missMiddleAttackByHero + flickerByEvil;

                        if (isStealHealth == false)
                        {
                            if (chanceForHeroHit > missAttack)
                            {
                                if (chanceForCriticalHit < missAttack)
                                {
                                    resultDamage = middleAttackDamage;
                                    highChanceForCriticalHit += moreChanceForCriticalHitByMiddleAttack;
                                }
                                else
                                {
                                    resultDamage = criticalAttackDamage;
                                    highChanceForCriticalHit = startedChanceForCriticalHit;
                                    Console.Write("Критический удар! ");
                                }
                                if (isMarker)
                                {
                                    countStepsBeforeSeries = startedCountStepsBeforeSeries;
                                    countSeriesOfAttack--;

                                    if (countSeriesOfAttack == 1)
                                    {
                                        resultDamage *= modifyDamageFirstSeries;
                                    }
                                    else if (countSeriesOfAttack == 0)
                                    {
                                        resultDamage *= modifyDamageSecondSeries;
                                        countSeriesOfAttack = startedCountSeriesOfAttack;
                                        isMarker = false;
                                    }
                                }
                                healthEvil -= resultDamage;
                                Console.WriteLine($"Попадание. HP Злодея - {healthEvil}");
                            }
                            else
                            {
                                if (highChanceForCriticalHit > 0)
                                {
                                    highChanceForCriticalHit--;
                                }

                                if (isMarker)
                                {
                                    countSeriesOfAttack = startedCountSeriesOfAttack;
                                    isMarker = false;
                                }
                                Console.WriteLine("Мимо.");
                            }
                        }
                        else
                        {
                            Console.WriteLine("Вы не отдохнули после вытягивания жизни.");
                        }
                        break;

                    case "3":
                        chanceForMagicMistake = randomChance.Next(lowChanceForMagicMistake, highChanceForMagicMistake);
                        missStrongAttackByHero = randomChance.Next(lowChanceStrongMissByHero, highChanceStrongMissByHero);
                        missAttack = missStrongAttackByHero + flickerByEvil;

                        if (isStealHealth == false)
                        {
                            if (chanceForHeroHit > missAttack)
                            {
                                if (chanceForCriticalHit < missAttack)
                                {
                                    resultDamage = strongAttackDamage;
                                    highChanceForCriticalHit += moreChanceForCriticalHitByStrongAttack;
                                }
                                else
                                {
                                    resultDamage = criticalAttackDamage;
                                    highChanceForCriticalHit = startedChanceForCriticalHit;
                                    Console.Write("Критический удар! ");
                                }

                                if (isMarker)
                                {
                                    countStepsBeforeSeries = startedCountStepsBeforeSeries;
                                    countSeriesOfAttack--;

                                    if (countSeriesOfAttack == 1)
                                    {
                                        resultDamage *= modifyDamageFirstSeries;
                                    }
                                    else if (countSeriesOfAttack == 0)
                                    {
                                        resultDamage *= modifyDamageSecondSeries;
                                        countSeriesOfAttack = startedCountSeriesOfAttack;
                                        isMarker = false;
                                    }
                                }
                                healthEvil -= resultDamage;
                                Console.WriteLine($"Попадание. HP Злодея - {healthEvil}");
                            }
                            else
                            {
                                if (highChanceForCriticalHit > 1)
                                {
                                    highChanceForCriticalHit -= lessChanceForCriticalHitByStrongAttack;
                                }

                                if (isMarker)
                                {
                                    countSeriesOfAttack = startedCountSeriesOfAttack;
                                    isMarker = false;
                                }
                                Console.WriteLine("Мимо.");

                                if (chanceForHeroHit <= chanceForMagicMistake)
                                {
                                    healthHero -= middleAttackDamage;
                                    Console.WriteLine($"Вы совершили магическую ошибку и поранили себя. HP Героя - {healthHero}");
                                }
                            }
                        }
                        else
                        {
                            Console.WriteLine("Вы не отдохнули после вытягивания жизни.");
                        }
                        break;

                    case "4":
                        countStepsBeforeSeries = startedCountStepsBeforeSeries;
                        countSeriesOfAttack = startedCountSeriesOfAttack;
                        isMarker = true;
                        Console.WriteLine("Вы поставили метку на противника.");
                        break;

                    case "5":
                        if (countStepsRestartShadowFlicker == 0 && isSacriface == false)
                        {
                            isShadowFlicker = true;
                            countStepsActiveShadowFlicker = startedCountStepsActiveShadowFlicker;
                            countStepsRestartShadowFlicker = startedCountStepsRestartShadowFlicker;
                            highChanceForHeroFlicker += changeChanceForHeroFlicker;
                            lowChanceForHeroFlicker += changeChanceForHeroFlicker;
                            flickerByHero = randomChance.Next(lowChanceForHeroFlicker, highChanceForHeroFlicker);
                            Console.WriteLine("Вы ушли мерцающую тень.");
                        }
                        else if (countStepsRestartShadowFlicker > 0)
                        {
                            Console.WriteLine("Вы ещё не восстановили способность ухода в мерцающую тень.");
                        }
                        else if (isSacriface)
                        {
                            Console.WriteLine("Недавно вы приносили себя в жертву.");
                        }

                        if (isMarker)
                        {
                            if (countSeriesOfAttack == startedCountSeriesOfAttack)
                            {
                                countStepsBeforeSeries--;

                                if (countStepsBeforeSeries == 0)
                                {
                                    isMarker = false;
                                }
                            }
                            else
                            {
                                isMarker = false;
                                countSeriesOfAttack = startedCountSeriesOfAttack;
                            }
                        }
                        break;

                    case "6":
                        if (countStepsRestartStealHealth == 0 && isSacriface == false)
                        {
                            healthEvil -= middleAttackDamage;
                            healthHero += weakAttackDamage;
                            countStepsRestartStealHealth = startedCountStepsRestartStealHealth;
                            isStealHealth = true;
                            Console.WriteLine($"Вы украли здоровье у врага. HP Героя - {healthHero}. HP Злодея - {healthEvil}");
                        }
                        else if (isSacriface)
                        {
                            Console.WriteLine("Недавно вы приносили себя в жертву.");
                        }
                        else
                        {
                            Console.WriteLine("Ваши способности не восстановились.");
                        }

                        if (isMarker)
                        {
                            if (countSeriesOfAttack == startedCountSeriesOfAttack)
                            {
                                countStepsBeforeSeries--;

                                if (countStepsBeforeSeries == 0)
                                {
                                    isMarker = false;
                                }
                            }
                            else
                            {
                                isMarker = false;
                                countSeriesOfAttack = startedCountSeriesOfAttack;
                            }
                        }
                        break;

                    case "7":
                        if (countMissedAttacksByEvil >= countMissedForSacriface)
                        {
                            healthEvil -= criticalAttackDamage;
                            healthHero -= middleAttackDamage;
                            countMissedAttacksByEvil = startedCountMissedAttacksByEvil;
                            countStepsPassForStealHealth = startedCountStepsPassForStealHealth;
                            isSacriface = true;

                            if (isShadowFlicker)
                            {
                                highChanceForHeroFlicker -= changeChanceForHeroFlicker;
                                lowChanceForHeroFlicker -= changeChanceForHeroFlicker;
                                isShadowFlicker = false;
                            }
                            Console.WriteLine($"Вы принесли себя в жертву, для нанесения критического урона врагу. HP Героя - {healthHero}. HP Злодея - {healthEvil}");
                        }
                        else
                        {
                            Console.WriteLine("Для принесения жертвы, вы должны увернуться 3 раза подряд, не находясь в теневом мерцании.");
                        }

                        if (isMarker)
                        {
                            if (countSeriesOfAttack == startedCountSeriesOfAttack)
                            {
                                countStepsBeforeSeries--;

                                if (countStepsBeforeSeries == 0)
                                {
                                    isMarker = false;
                                }
                            }
                            else
                            {
                                isMarker = false;
                                countSeriesOfAttack = startedCountSeriesOfAttack;
                            }
                        }
                        break;

                    case "8":
                        if (countStepsRestartConcentrate == 0)
                        {
                            isConcentrate = true;
                            countStepsActiveConcentrate = startedCountStepsActiveConcentrate;
                            countStepsRestartConcentrate = startedCountStepsRestartConcentrate;

                            if (isShadowFlicker == false)
                            {
                                flickerByHero = randomChance.Next(lowFlickerConcentrate, highFlickerConcentrate);
                            }
                            highChanceHeroForHit += changeChanceHeroForHit;
                            lowChanceHeroForHit += changeChanceHeroForHit;
                            Console.WriteLine("Шанс попадания увеличился значительно. Увернуться от удара противника стало тяжело.");
                        }
                        else
                        {
                            Console.WriteLine("Ваши способности не восстановились.");
                        }

                        if (isMarker)
                        {
                            if (countSeriesOfAttack == startedCountSeriesOfAttack)
                            {
                                countStepsBeforeSeries--;

                                if (countStepsBeforeSeries == 0)
                                {
                                    isMarker = false;
                                }
                            }
                            else
                            {
                                isMarker = false;
                                countSeriesOfAttack = startedCountSeriesOfAttack;
                            }
                        }
                        break;

                    case "9":
                        Console.Write($"HP героя - {healthHero}\n" +
                            $"HP героя - {healthEvil}\n" +
                            $"Активность метки - {isMarker}\n" +
                            $"Активность теневого мерцания - {isShadowFlicker}\n" +
                            $"Активность сосредоточения - {isConcentrate}\n" +
                            $"Применение жертвы - {isSacriface}\n" +
                            $"Применение вытягивания жизни - {isStealHealth}\n" +
                            $"Уровень усталости героя - {levelHeroExhausted}\n" +
                            $"Уровень усталости злодея - {levelEvilExhausted}\n" +
                            $"Раунд - {stepsFight}\n");
                        break;

                    default:
                        Console.WriteLine("Нет такого выбора.");
                        break;
                }

                if (healthEvil <= 0)
                {
                    Console.WriteLine($"Злодей погиб. HP Героя - {healthHero}");
                    break;
                }

                sumDamageByHero = Convert.ToInt32(startedHealthEvil - healthEvil);
                percentOfDamageByEvil = sumDamageByHero / (Convert.ToInt32(startedHealthEvil) / oneHundredPercent);
                chanceForHealingByEvil = randomChance.Next(lowChanceForHealingByEvil, highChanceForHealingByEvil);
                missMiddleAttackByEvil = randomChance.Next(lowChanceAvgMissByEvil, highChanceAvgMissByEvil);
                missAttack = missMiddleAttackByEvil + flickerByHero;

                if (countHeal > 0 && (percentOfDamageByEvil > chanceForHealingByEvil || percentOfDamageByEvil >= percentOfDangerousDamage))
                {
                    healthEvil *= modifyHeal;
                    countHeal--;
                    Console.WriteLine($"Противник вылечил себя! HP Злодея - {healthEvil}");
                }
                else if (chanceForEvilHit > missAttack)
                {
                    healthHero -= middleAttackDamage;
                    countMissedAttacksByEvil = startedCountMissedAttacksByEvil;
                    Console.WriteLine($"По вам попали. HP героя - {healthHero}");
                }
                else
                {
                    if (isShadowFlicker == false)
                    {
                        countMissedAttacksByEvil++;
                    }
                    Console.WriteLine("Противник промахнулся!");
                }

                if (healthHero <= 0)
                {
                    Console.WriteLine($"Герой погиб. HP Злодея - {healthEvil}");
                    break;
                }

                if (levelHeroExhausted < maxLevelExhausted && stepsFight >= stepExhaustedStartByHero && stepsFight % multipleExhaustedNewLevelByHero == 0)
                {
                    levelHeroExhausted++;
                    highChanceWeakMissByHero += changeChanceMissByExhausted;
                    highChanceAvgMissByHero += changeChanceMissByExhausted;
                    changeChanceMissByExhausted += newExhaustedChanceMiss;
                    Console.WriteLine($"Герой начинает уставать. Уровень усталости - {levelHeroExhausted}");
                }

                if (levelEvilExhausted < maxLevelExhausted && stepsFight >= stepExhaustedStartByEvil && stepsFight % multipleExhaustedNewLevelByEvil == 0)
                {
                    levelEvilExhausted++;
                    highChanceAvgMissByEvil += changeChanceMissByExhausted;
                    changeChanceMissByExhausted += newExhaustedChanceMiss;
                    Console.WriteLine($"Злодей начинает уставать. Уровень усталости - {levelEvilExhausted}");
                }

                stepsFight++;
            }

            Console.WriteLine("Бой окончен, нажмите любую клавишу");
            Console.ReadLine();
        }
    }
}