C#   Уроки программирования с нуля. Си-шарп для чайников   C#

1-е задание:


int home_goals, guest_goals;

Console.WriteLine("Введите количество голов, забитых хозяевами, и нажмите ENTER:");
home_goals = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("Введите количество голов, забитых гостями, и нажмите ENTER:");
guest_goals = Convert.ToInt32(Console.ReadLine());

if (home_goals > guest_goals)
{
 Console.WriteLine("Победили хозяева.");
}
else if (home_goals < guest_goals)
{
 Console.WriteLine("Победили гости.");
}
else
{
 Console.WriteLine("Победила дружба!");
}
Console.ReadKey();





2-е задание:


int number;
Console.WriteLine("Введите число, которое вы хотите проверить на кратность 3-м и 7-ми, и нажмите ENTER:");
number = Convert.ToInt32(Console.ReadLine());
Console.WriteLine((number % 3 == 0) && (number % 7 == 0) ? "Введённое число кратно 3-м и 7-ми." : "Введённое число НЕ кратно 3-м и 7-ми.");
Console.ReadKey();

using System;
using System.Collections;
using System.Collections.Generic;

namespace miniBOX
{
    class Player
    {
        private int Health, Stamina;
        private string Stance;
        private const string Block = "Блокирование";          //Стойка Силы
        private const string Evade = "Уклонение";             //Стойка Ловкости
        private const string CounterAttack = "Контратака";    //Стойка Хитрости
        private const string Defense = "Глухая оборона";      //Стойка для восстановления Выносливости (бафы/дебафы не накладываются, урон обороняющегося отсутствует, приходящий урон / 2)

        private string Condition;
        private List<ArrayList> Conditions_Array = new List<ArrayList>();
        private int Cycles;

        //Состояния Силы
        private const string Unsteadiness = "Шаткость";    //Урон по игроку * 2
        private const string Weakness = "Слабость";        //Урон игроком / 2
        private const string Adrenaline = "Адреналин";     //Урон по игроку / 2
        private const string Rage = "Ярость";              //Урон игроком * 2
        //Состояния Ловкости
        private const string Daze = "Ошеломление";         //Урон по игроку * 2
        private const string Stiffness = "Скованность";    //Урон игроком / 2
        private const string Foxery = "Верткость";         //Урон по игроку / 2
        private const string Acceleration = "Разгон";      //Урон игроком * 2
        //Состояния Хитрости
        private const string Distraction = "Рассеянность"; //Урон по игроку * 2
        private const string Pain = "Боль";                //Урон игроком / 2
        private const string Warn = "Внимание";            //Урон по игроку / 2
        private const string Dishonesty = "Подлость";      //Урон игроком * 2
        //Альтернативное состояние
        private const string Paralize = "Обездвижен";      //Игрок не атакует и не блокирует

        private string[] ConditionsArray_Strength = new string[4] { Unsteadiness, Weakness, Adrenaline, Rage };
        private string[] ConditionsArray_Dextirity = new string[4] { Daze, Stiffness, Foxery, Acceleration };
        private string[] ConditionsArray_Cunning = new string[4] { Distraction, Pain, Warn, Dishonesty };
        private string[] ConditionsArray_Alternative = new string[1] { Paralize };

        private int DMG;
        private string Attack;

        private const string ScalePunch = "Удар с размаха";   //Удар Силы
        private void ScalePunchDMG_Calculate(Player Attacker, Player Deffender)
        {
            if (Deffender.ContainsCondition(Unsteadiness))
                Attacker.DMG = Attacker.DMG * 2;
            if (Attacker.ContainsCondition(Weakness))
                Attacker.DMG = Attacker.DMG / 2;
            if (Deffender.ContainsCondition(Adrenaline))
                Attacker.DMG = Attacker.DMG / 2;
            if (Attacker.ContainsCondition(Rage))
                Attacker.DMG = Attacker.DMG * 2;
        }

        private const string AccuratePunch = "Точный удар";   //Удар Ловкости
        private void AccuratePunchDMG_Calculate(Player Attacker, Player Deffender)
        {
            if (Deffender.ContainsCondition(Daze))
                Attacker.DMG = Attacker.DMG * 2;
            if (Attacker.ContainsCondition(Stiffness))
                Attacker.DMG = Attacker.DMG / 2;
            if (Deffender.ContainsCondition(Foxery))
                Attacker.DMG = Attacker.DMG / 2;
            if (Attacker.ContainsCondition(Acceleration))
                Attacker.DMG = Attacker.DMG * 2;
        }

        private const string Cutting = "Подсечка";            //Удар Хитрости
        private void CuttingDMG_Calculate(Player Attacker, Player Deffender)
        {
            if (Deffender.ContainsCondition(Distraction))
                Attacker.DMG = Attacker.DMG * 2;
            if (Attacker.ContainsCondition(Pain))
                Attacker.DMG = Attacker.DMG / 2;
            if (Deffender.ContainsCondition(Warn))
                Attacker.DMG = Attacker.DMG / 2;
            if (Attacker.ContainsCondition(Dishonesty))
                Attacker.DMG = Attacker.DMG * 2;
        }

        public Player()
        {
            Health = 100;
            Stamina = 200;
            Stance = Block;
            Attack = ScalePunch;
        }
        public int health
        {
            get
            {
                return Health;
            }
            set
            {
                if (value > 100)
                    Health = 100;
                else Health = value;
            }
        }
        public int stamina
        {
            get
            {
                return Stamina;
            }
            set
            {
                if (value > 200)
                    Stamina = 200;
                else Stamina = value;
            }
        }
        public string stance
        {
            get { return Stance; }
        }
        public string condition
        {
            get { return Condition; }
        }
        public string attack
        {
            get { return Attack; }
        }
        public bool PlayerLose { get; set; }

        private bool ContainsCondition(string condition)
        {
            try
            {
                return Condition.Contains(condition);
            }
            catch (Exception)
            {
                return false;
            }
        }
        public void SwitchStance()
        {
            if (Stance == Block)
                Stance = Evade;
            else if (Stance == Evade)
                Stance = CounterAttack;
            else if (Stance == CounterAttack)
                Stance = Defense;
            else Stance = Block;
        }
        public void SwitchAttack()
        {
            if (Attack == ScalePunch)
                Attack = AccuratePunch;
            else if (Attack == AccuratePunch)
                Attack = Cutting;
            else Attack = ScalePunch;
        }
        public void DMGCalculate(Player Attacker, Player Deffender)
        {
            Random rnd = new Random();
            Attacker.DMG = 4;
            //Урон Силовых атак
            if (Attacker.Attack == ScalePunch && Deffender.Stance == Block)
            {
                if (Attacker.Stance == Defense || Attacker.ContainsCondition(Paralize))
                { Attacker.DMG = 0; }
                else if (Deffender.ContainsCondition(Paralize))
                {
                    ScalePunchDMG_Calculate(Attacker, Deffender);
                    if (rnd.Next(100) > 64)
                        Attacker.DMG = Attacker.DMG * 2;
                }
                ScalePunchDMG_Calculate(Attacker, Deffender);
            }
            if (Attacker.Attack == ScalePunch && Deffender.Stance == Evade)
            {
                if (Attacker.Stance == Defense || Attacker.ContainsCondition(Paralize))
                { Attacker.DMG = 0; }
                else if (Deffender.ContainsCondition(Paralize))
                {
                    ScalePunchDMG_Calculate(Attacker, Deffender);
                    if (rnd.Next(100) > 64)
                        Attacker.DMG = Attacker.DMG * 2;
                }
                else
                {
                    ScalePunchDMG_Calculate(Attacker, Deffender);
                    if (rnd.Next(100) > 64)
                        Attacker.DMG = Attacker.DMG * 2;
                    if (rnd.Next(100) > 69)
                        Attacker.DMG = 0;
                }
            }
            if (Attacker.Attack == ScalePunch && Deffender.Stance == CounterAttack)
            {
                if (Attacker.Stance == Defense || Attacker.ContainsCondition(Paralize))
                { Attacker.DMG = 0; }
                else if (Deffender.ContainsCondition(Paralize))
                {
                    ScalePunchDMG_Calculate(Attacker, Deffender);
                    if (rnd.Next(100) > 64)
                        Attacker.DMG = Attacker.DMG * 2;
                }
                else
                {
                    ScalePunchDMG_Calculate(Attacker, Deffender);
                    if (rnd.Next(100) > 64)
                        Attacker.DMG = Attacker.DMG * 2;
                    if (rnd.Next(100) > 79)
                    {
                        Attacker.health = Attacker.health - Attacker.DMG;
                        Attacker.stamina = Attacker.stamina - Attacker.DMG * 5;
                        Attacker.DMG = Attacker.DMG / 2;
                    }
                }
            }
            if (Attacker.Attack == ScalePunch && Deffender.Stance == Defense)
            {
                if (Attacker.Stance == Defense || Attacker.ContainsCondition(Paralize))
                { Attacker.DMG = 0; }
                else if (Deffender.ContainsCondition(Paralize))
                {
                    ScalePunchDMG_Calculate(Attacker, Deffender);
                    if (rnd.Next(100) > 64)
                        Attacker.DMG = Attacker.DMG * 2;
                }
                else
                {
                    ScalePunchDMG_Calculate(Attacker, Deffender);
                    Attacker.DMG = Attacker.DMG / 2;
                }
            }
            //Урон Ловких атак
            if (Attacker.Attack == AccuratePunch && Deffender.Stance == Block)
            {
                if (Attacker.Stance == Defense || Attacker.ContainsCondition(Paralize))
                { Attacker.DMG = 0; }
                else if (Deffender.ContainsCondition(Paralize))
                {
                    AccuratePunchDMG_Calculate(Attacker, Deffender);
                    if (rnd.Next(100) > 84)
                        Attacker.DMG = Attacker.DMG * 8;
                }
                else
                {
                    AccuratePunchDMG_Calculate(Attacker, Deffender);
                    if (rnd.Next(100) > 84)
                        Attacker.DMG = Attacker.DMG * 8;
                    if (rnd.Next(100) > 39)
                    { Attacker.DMG = Attacker.DMG / 2; }
                }
            }
            if (Attacker.Attack == AccuratePunch && Deffender.Stance == Evade)
            {
                if (Attacker.Stance == Defense || Attacker.ContainsCondition(Paralize))
                { Attacker.DMG = 0; }
                else if (Deffender.ContainsCondition(Paralize))
                {
                    AccuratePunchDMG_Calculate(Attacker, Deffender);
                    if (rnd.Next(100) > 84)
                        Attacker.DMG = Attacker.DMG * 8;
                }
                AccuratePunchDMG_Calculate(Attacker, Deffender);
            }
            if (Attacker.Attack == AccuratePunch && Deffender.Stance == CounterAttack)
            {
                if (Attacker.Stance == Defense || Attacker.ContainsCondition(Paralize))
                { Attacker.DMG = 0; }
                else if (Deffender.ContainsCondition(Paralize))
                {
                    AccuratePunchDMG_Calculate(Attacker, Deffender);
                    if (rnd.Next(100) > 84)
                        Attacker.DMG = Attacker.DMG * 8;
                }
                else
                {
                    AccuratePunchDMG_Calculate(Attacker, Deffender);
                    if (rnd.Next(100) > 84)
                        Attacker.DMG = Attacker.DMG * 8;
                    if (rnd.Next(100) > 79)
                    {
                        Attacker.health = Attacker.health - Attacker.DMG;
                        Attacker.stamina = Attacker.stamina - Attacker.DMG * 5;
                        Attacker.DMG = Attacker.DMG / 2;
                    }
                }
                if (Attacker.Attack == AccuratePunch && Deffender.Stance == Defense)
                {
                    if (Attacker.Stance == Defense || Attacker.ContainsCondition(Paralize))
                    { Attacker.DMG = 0; }
                    else if (Deffender.ContainsCondition(Paralize))
                    {
                        AccuratePunchDMG_Calculate(Attacker, Deffender);
                        if (rnd.Next(100) > 84)
                            Attacker.DMG = Attacker.DMG * 8;
                    }
                    else
                    {
                        Attacker.DMG = Attacker.DMG / 2;
                        AccuratePunchDMG_Calculate(Attacker, Deffender);
                    }
                }
            }
            //Урон Хитрых атак
            if (Attacker.Attack == Cutting && Deffender.Stance == Block)
            {
                if (Attacker.Stance == Defense || Attacker.ContainsCondition(Paralize))
                { Attacker.DMG = 0; }
                else if (Deffender.ContainsCondition(Paralize))
                {
                    CuttingDMG_Calculate(Attacker, Deffender);
                }
                else
                {
                    CuttingDMG_Calculate(Attacker, Deffender);
                    if (rnd.Next(100) > 39)
                        Attacker.DMG = Attacker.DMG / 2;
                }
            }
            if (Attacker.Attack == Cutting && Deffender.Stance == Evade)
            {
                if (Attacker.Stance == Defense || Attacker.ContainsCondition(Paralize))
                { Attacker.DMG = 0; }
                else if (Deffender.ContainsCondition(Paralize))
                {
                    CuttingDMG_Calculate(Attacker, Deffender);
                }
                else
                {
                    CuttingDMG_Calculate(Attacker, Deffender);
                    if (rnd.Next(100) > 69)
                        Attacker.DMG = 0;
                }
            }
            if (Attacker.Attack == Cutting && Deffender.Stance == CounterAttack)
            {
                if (Attacker.Stance == Defense || Attacker.ContainsCondition(Paralize))
                { Attacker.DMG = 0; }
                else if (Deffender.ContainsCondition(Paralize))
                {
                    CuttingDMG_Calculate(Attacker, Deffender);
                }
                CuttingDMG_Calculate(Attacker, Deffender);
            }
            if (Attacker.Attack == Cutting && Deffender.Stance == Defense)
            {
                if (Attacker.Stance == Defense || Attacker.ContainsCondition(Paralize))
                { Attacker.DMG = 0; }
                else if (Deffender.ContainsCondition(Paralize))
                {
                    CuttingDMG_Calculate(Attacker, Deffender);
                }
                else
                {
                    CuttingDMG_Calculate(Attacker, Deffender);
                    Attacker.DMG = Attacker.DMG / 2;
                }
            }
            Deffender.health = Deffender.health - Attacker.DMG;
            Deffender.stamina = Deffender.stamina - (Attacker.DMG * 5) + 20;
        }
        public void AddCondition(Player Attacker, Player Deffender)
        {
            Random rnd = new Random();
            string AttCondition = null;
            string DeffCondition = null;
            int temp_rnd = rnd.Next(100);
            //Условия Силовых атак
            if (Attacker.Attack == ScalePunch && Deffender.Stance == Block)
            {
            }
            if (Attacker.Attack == ScalePunch && Deffender.Stance == Evade)
            {
                if (Attacker.Stance == Defense || Attacker.ContainsCondition(Paralize))
                { }
                else
                {
                    AttCondition = ConditionsArray_Strength[rnd.Next(2, 4)];
                    DeffCondition = ConditionsArray_Cunning[rnd.Next(2)];
                }
            }
            if (Attacker.Attack == ScalePunch && Deffender.Stance == CounterAttack)
            {
                if (Attacker.Stance == Defense || Attacker.ContainsCondition(Paralize))
                { }
                else
                {
                    AttCondition = ConditionsArray_Dextirity[rnd.Next(2, 4)];
                    DeffCondition = ConditionsArray_Strength[rnd.Next(2)];
                }
            }
            if (Attacker.Attack == ScalePunch && Deffender.Stance == Defense)
            {
            }
            //Уcловия Ловких атак
            if (Attacker.Attack == AccuratePunch && Deffender.Stance == Block)
            {
                if (Attacker.Stance == Defense || Attacker.ContainsCondition(Paralize))
                { }
                else
                {
                    AttCondition = ConditionsArray_Cunning[rnd.Next(2, 4)];
                    DeffCondition = ConditionsArray_Dextirity[rnd.Next(2)];
                }
            }
            if (Attacker.Attack == AccuratePunch && Deffender.Stance == Evade)
            {
            }
            if (Attacker.Attack == AccuratePunch && Deffender.Stance == CounterAttack)
            {
                if (Attacker.Stance == Defense || Attacker.ContainsCondition(Paralize))
                { }
                else
                {
                    AttCondition = ConditionsArray_Dextirity[rnd.Next(2, 4)];
                    DeffCondition = ConditionsArray_Strength[rnd.Next(2)];
                }
            }
            if (Attacker.Attack == AccuratePunch && Deffender.Stance == Defense)
            {
            }
            //Уcловия Хитрых атак
            if (Attacker.Attack == Cutting && Deffender.Stance == Block)
            {
                if (Attacker.Stance == Defense || Attacker.ContainsCondition(Paralize))
                { }
                else
                {
                    AttCondition = ConditionsArray_Cunning[rnd.Next(2, 4)];
                    DeffCondition = ConditionsArray_Dextirity[rnd.Next(2)];
                    if (rnd.Next(100) > 84)
                        Deffender.Conditions_Array.Add(new ArrayList() { Paralize, 2 });
                }
            }
            if (Attacker.Attack == Cutting && Deffender.Stance == Evade)
            {
                if (Attacker.Stance == Defense || Attacker.ContainsCondition(Paralize))
                { }
                else
                {
                    AttCondition = ConditionsArray_Strength[rnd.Next(2, 4)];
                    DeffCondition = ConditionsArray_Cunning[rnd.Next(2)];
                    if (rnd.Next(100) > 84 && Attacker.DMG != 0)
                        Deffender.Conditions_Array.Add(new ArrayList() { Paralize, 2 });
                }
            }
            if (Attacker.Attack == Cutting && Deffender.Stance == CounterAttack)
            {
            }
            if (Attacker.Attack == Cutting && Deffender.Stance == Defense)
            {
            }
            Cycles = rnd.Next(1, 4) * Convert.ToInt32((rnd.Next(3) / 2));
            if (Deffender.ContainsCondition(Paralize) && Cycles != 0)
            {
                Attacker.Conditions_Array.Add(new ArrayList() { ConditionsArray_Strength[rnd.Next(2, 4)], Cycles });
                Attacker.Conditions_Array.Add(new ArrayList() { ConditionsArray_Dextirity[rnd.Next(2, 4)], Cycles });
                Attacker.Conditions_Array.Add(new ArrayList() { ConditionsArray_Cunning[rnd.Next(2, 4)], Cycles });
            }
            else if (AttCondition != null && Cycles != 0)
            {
                Attacker.Conditions_Array.Add(new ArrayList() { AttCondition, Cycles });
            }
            Cycles = rnd.Next(1, 4) * Convert.ToInt32((rnd.Next(3) / 2));
            if (Deffender.ContainsCondition(Paralize) && Cycles != 0)
            {
                Deffender.Conditions_Array.Add(new ArrayList() { ConditionsArray_Strength[rnd.Next(2)], Cycles });
                Deffender.Conditions_Array.Add(new ArrayList() { ConditionsArray_Dextirity[rnd.Next(2)], Cycles });
                Deffender.Conditions_Array.Add(new ArrayList() { ConditionsArray_Cunning[rnd.Next(2)], Cycles });
            }
            else if (DeffCondition != null && Cycles != 0)
            {
                Deffender.Conditions_Array.Add(new ArrayList() { DeffCondition, Cycles });
            }
            Attacker.FixCondition(Attacker);
            Deffender.FixCondition(Deffender);
            Attacker.Condition = null;
            foreach (ArrayList el in Attacker.Conditions_Array)
            {
                Attacker.Condition = Attacker.Condition + el[0] + " " + "[" + el[1] + "]" + "\n";
            }
            Deffender.Condition = null;
            foreach (ArrayList el in Deffender.Conditions_Array)
            {
                Deffender.Condition = Deffender.Condition + el[0] + " " + "[" + el[1] + "]" + "\n";
            }
        }
        private void FixCondition(Player player)
        {
            if (player.Conditions_Array.Count > 1)
            {
                int i = 0;
                int j = 0;
                ArrayList temp;
                for (i = 0; i < Conditions_Array.Count - 1; i++)
                {
                    for (j = i + 1; j < Conditions_Array.Count; j++)
                    {
                        if ((string.Compare((string)Conditions_Array[i][0], (string)Conditions_Array[j][0])) > 0)
                        {
                            temp = Conditions_Array[i];
                            Conditions_Array[i] = Conditions_Array[j];
                            Conditions_Array[j] = temp;
                        }
                    }
                }
                List<ArrayList> bufer = new List<ArrayList>();
                i = 0;
                j = 0;
                for (i = 0; i < Conditions_Array.Count; i++)
                {
                    try
                    {
                        if (Conditions_Array[i][0] == bufer[j][0])
                            bufer[j][1] = (int)bufer[j][1] + (int)Conditions_Array[i][1];
                        else
                        {
                            bufer.Add(Conditions_Array[i]);
                            j++;
                        }
                    }
                    catch (ArgumentOutOfRangeException)
                    {
                        bufer.Add(Conditions_Array[i]);
                    }
                }
                player.Conditions_Array.Clear();
                player.Conditions_Array.AddRange(bufer);
            }
        }
        public void DeleteCondition(Player player)
        {
            List<ArrayList> bufer = new List<ArrayList>();
            foreach (ArrayList el in Conditions_Array)
            {
                if ((int)el[1] > 1)
                {
                    el[1] = (int)el[1] - 1;
                    bufer.Add(el);
                }
            }
            player.Conditions_Array.Clear();
            player.Conditions_Array.AddRange(bufer);
        }
    }
    class Program
    {

        private static void Help(ConsoleKey key, ref int page)
        {
            string[] pages = new string[10];
            pages[0] = "Управление персонажами:" + "\n" +
                    "кнопка '1' - сменить стойку первого игрока;" + "\n" +
                    "кнопка '2' - сменить атаку первого игрока;" + "\n" +
                    "кнопка '9' - сменить стойку второго игрока;" + "\n" +
                    "кнопка '0' - сменить атаку второго игрока;" + "\n" +
                    "\n" +
                    "Правила:" + "\n" +
                    "Цель игры - довести до 0 показатель 'Здоровье'(Убил) или 'Выносливость'(Нокаут) противника." + "\n" +
                    "Здоровье не восстанавливается." + "\n" +
                    "Выносливость снижается по формуле (итоговый урон*5) и восстанавливается по " + "\n" +
                    "20 единиц за раунд." + "\n" +
                    "Базовая атака равна 4 единицы." + "\n" +
                    "У каждого игрока есть параметры: Стойка, Атака и Состояние. Каждый параметр" + "\n" +
                    "может быть одного из трёх типов:" + "\n" +
                    "Сила, Ловкость и Хитрость. Далее перечислены все параметры по типам и пояснения к ним." + "\n" +
                    "\n" +
                    "\n" +
                    "\n" +
                    "\n" +
                    "\n" +
                    "Для навигации по справке используйте стрелки 'влево' и 'вправо'" + "\n" +
                   "Нажмите F1 для продолжения боя";
            pages[1] = "Параметры типа 'Сила':" + "\n" +
                    "Атака: 'Удар с размаха' - силовой приём, 25% шанс нанести двойной урон;" + "\n" +
                    "Стойка: 'Блок' - силовая стойка, 60% шанс сократить урон в 2 раза;" + "\n" +
                    "Состояния: " + "\n" +
                    "\n" +
                    "'Шаткость' - отрицательное состояние силы, " + "\n" +
                    "урон силовой атакой по игроку увеличен вдвое" + "\n" +
                    "\n" +
                    "'Слабость' - отрицательное состояние силы, " + "\n" +
                    "урон силовой атакой игрока уменьшен вдвое" + "\n" +
                    "\n" +
                    "'Адреналин' - положительное состояние силы, " + "\n" +
                    "урон силовой атакой по игроку уменьшен вдвое" + "\n" +
                    "\n" +
                    "'Ярость' - положительное состояние силы, " + "\n" +
                    "урон силовой атакой игрока увеличен вдвое" + "\n" +
                    "\n" +
                    "\n" +
                    "\n" +
                    "\n" +
                    "\n" +
                    "\n" +
                   "Для навигации по справке используйте стрелки 'влево' и 'вправо'" + "\n" +
                   "Нажмите F1 для продолжения боя";
            pages[2] = "Параметры типа 'Ловкость':" + "\n" +
                    "Атака: 'Точный удар' - ловкий приём, 15% шанс нанести 8-кратный урон;" + "\n" +
                    "Стойка: 'Уклонение' - ловкая стойка, 30% шанс избежать урона;" + "\n" +
                    "Состояния: " + "\n" +
                    "\n" +
                    "'Ошеломление' - отрицательное состояние ловкости, " + "\n" +
                    "урон ловкой атакой по игроку увеличен вдвое" + "\n" +
                    "\n" +
                    "'Скованность' - отрицательное состояние ловкости, " + "\n" +
                    "урон ловкой атакой игрока уменьшен вдвое" + "\n" +
                    "\n" +
                    "'Верткость' - положительное состояние ловкости, " + "\n" +
                    "урон ловкой атакой по игроку уменьшен вдвое" + "\n" +
                    "\n" +
                    "'Разгон' - положительное состояние ловкости, " + "\n" +
                    "урон ловкой атакой игрока увеличен вдвое" + "\n" +
                    "\n" +
                    "\n" +
                    "\n" +
                    "\n" +
                    "\n" +
                    "\n" +
                   "Для навигации по справке используйте стрелки 'влево' и 'вправо'" + "\n" +
                   "Нажмите F1 для продолжения боя";
            pages[3] = "Параметры типа 'Хитрость':" + "\n" +
                    "Атака: 'Подсечка' - хитрый приём, 15% шанс сбить противника с ног " + "\n" +
                    "(Состояние: Обездвижевание на 2 раунда);" + "\n" +
                    "Стойка: 'Контратака' - хитрая стойка, 20% шанс отразить урон противника " + "\n" +
                    "обратно и снизить урон по себе вдвое;" + "\n" +
                    "Состояния: " + "\n" +
                    "\n" +
                    "'Рассеянность' - отрицательное состояние хитрости, " + "\n" +
                    "урон хитрой атакой по игроку увеличен вдвое" + "\n" +
                    "\n" +
                    "'Боль' - отрицательное состояние хитрости, " + "\n" +
                    "урон хитрой атакой игрока уменьшен вдвое" + "\n" +
                    "\n" +
                    "'Внимание' - положительное состояние хитрости, " + "\n" +
                    "урон хитрой атакой по игроку уменьшен вдвое" + "\n" +
                    "\n" +
                    "'Подлость' - положительное состояние хитрости, " + "\n" +
                    "урон хитрой атакой игрока увеличен вдвое" + "\n" +
                    "\n" +
                    "\n" +
                    "\n" +
                    "\n" +
                   "Для навигации по справке используйте стрелки 'влево' и 'вправо'" + "\n" +
                   "Нажмите F1 для продолжения боя";
            pages[4] = "Состояния - параметр, который усиливает или ослабляет игрока. Все состояния" + "\n" +
                "накладываются относительно атакующей стороны и то только если тип атаки " + "\n" +
                "атакующего отличается от типа стойки защищающегося. К примеру игрок1 использует" + "\n" +
                "'Удар с размаха', а игрок2 'Блок', то в этом случае для игрока1 не будет" + "\n" +
                "положительных эффектов, а для игрока2 - отрицательных, в то время как" + "\n" +
                "если игрок2 использует атаку 'Подсечка', а игрок1 стойку 'Уклонение', то" + "\n" +
                "могут появиться состояния положительные для игрока2 и отрицательные" + "\n" +
                "для игрока1. Длительность состояний указана в квадратных скобках." + "\n" +
                "Есть ещё альтернативная стойка 'Глухая оборона', во время которой" + "\n" +
                "игрок не может атаковать, но также на данного игрока не могут быть" + "\n" +
                "наложены отрицательные состояния, а урон по нему снижен вдвое. полезно" + "\n" +
                "в случае, когда нужно переждать дебафы и восстановить выносливость." + "\n" +
                 "Шанс появления нового состояния равен 33% с количеством раундов от 1 до 3." + "\n" +
                 "В случае если состояние повторяется, то раунды суммируются" + "\n" +
                 "\n" +
                 "Не только состояния имеют особые эффекты, но также атаки и стойки, которые " + "\n" +
                 "принимаются в рассчёт только если типы атака-стойка атакующего и защищающегося," + "\n" +
                 "соответственно, не совпадают. Если совпадают, то рассчитывается (базовый урон*" + "\n" +
                 "2^n), где n - сумма положительных(+1) и отрицательных (-1) остаточных состояний." + "\n" +
                 "\n" +
                 "Желаю приятной совместной игры! =)" + "\n" +
                 "Для навигации по справке используйте стрелки 'влево' и 'вправо'" + "\n" +
                   "Нажмите F1 для продолжения боя";
            Console.Clear();
            Console.WriteLine(pages[page]);
            do
            {
                key = Console.ReadKey(true).Key;
                switch (key)
                {
                    case ConsoleKey.LeftArrow:
                        if (page > 0)
                            page = page - 1;
                        Console.Clear();
                        Console.WriteLine(pages[page]);
                        break;
                    case ConsoleKey.RightArrow:
                        if (page < 4)
                            page = page + 1;
                        Console.Clear();
                        Console.WriteLine(pages[page]);
                        break;
                    default:
                        break;
                }
            } while (key != ConsoleKey.F1);
        }
        private static void Greetings()
        {
            Console.WriteLine("Это тестовая версия консольного файтинга" + "\n" + "Чтобы начать играть с другим человеком, нажмите ENTER" + "\n"
               + "\n" + "Чтобы вызвать подсказку по управлению - во время игры нажмите F1");
            Console.ReadLine();
        }
        private static void BattleInfo(Player p1, Player p2, int takendmg1, int takendmg2, int Round)
        {
            Console.Clear();
            Console.WriteLine("РАУНД " + Round + "\n");
            Console.WriteLine("Игрок1:" + "\n" + "Здоровье = " + p1.health + "\n" + "Выносливость = " + p1.stamina
                + "\n" + "Текущая стойка = " + p1.stance + "\n" + "Атака = " + p1.attack + "\n" + "Состояние:" + "\n" + "\n" + p1.condition + "\n");
            Console.WriteLine("Игрок1 получил урона: " + takendmg1 + "\n" + "Игрок2 получил урона: " + takendmg2 + "\n");
            Console.WriteLine("Игрок2:" + "\n" + "Здоровье = " + p2.health + "\n" + "Выносливость = " + p2.stamina
                + "\n" + "Текущая стойка = " + p2.stance + "\n" + "Атака = " + p2.attack + "\n" + "Состояние:" + "\n" + "\n" + p2.condition + "\n");
            Console.WriteLine("Нажмите ENTER чтобы провести раунд");
        }
        private static void BattleEnd(Player p1, Player p2)
        {
            if (p1.PlayerLose == true && p2.PlayerLose == true)
                Console.WriteLine("НИЧЬЯ");
            else if (p1.PlayerLose == true)
                Console.WriteLine("ПОБЕДИЛ ИГРОК2");
            else Console.WriteLine("ПОБЕДИЛ ИГРОК1");
            Console.ReadLine();
        }

        static void Main(string[] args)
        {
            //Объявление переменных
            int page = 0;
            int Round = 0;
            Player player1 = new Player();
            Player player2 = new Player();
            int takendmg1 = 0;
            int takendmg2 = 0;
            ConsoleKey key;
            //Тело программы
            Greetings();
            do
            {
                Round++;
                int p1Hbefore = player1.health;
                int p2Hbefore = player2.health;
                do
                {
                    BattleInfo(player1, player2, takendmg1, takendmg2, Round);
                    key = Console.ReadKey(true).Key;
                    switch (key)
                    {
                        case ConsoleKey.D1:
                            player1.SwitchStance();
                            break;
                        case ConsoleKey.D2:
                            player1.SwitchAttack();
                            break;
                        case ConsoleKey.D9:
                            player2.SwitchStance();
                            break;
                        case ConsoleKey.D0:
                            player2.SwitchAttack();
                            break;
                        case ConsoleKey.F1:
                            Help(key, ref page);
                            break;
                        default:
                            break;
                    }
                } while (key != ConsoleKey.Enter);
                player1.DMGCalculate(player1, player2);
                player2.DMGCalculate(player2, player1);
                player1.DeleteCondition(player1);
                player2.DeleteCondition(player2);
                player1.AddCondition(player1, player2);
                player2.AddCondition(player2, player1);
                takendmg1 = p1Hbefore - player1.health;
                takendmg2 = p2Hbefore - player2.health;
                if (player1.health <= 0)
                    player1.PlayerLose = true;
                if (player2.health <= 0)
                    player2.PlayerLose = true;
                if (player1.stamina <= 0 && player2.health <= 0) { }
                else if (player1.stamina <= 0)
                    player1.PlayerLose = true;
                if (player2.stamina <= 0 && player1.health <= 0) { }
                else if (player2.stamina <= 0)
                    player2.PlayerLose = true;
            } while (player1.PlayerLose == false && player2.PlayerLose == false);
            //Завершение боя - объявление победителя
            BattleInfo(player1, player2, takendmg1, takendmg2, Round);
            BattleEnd(player1, player2);
            Console.Clear();
            BattleEnd(player1, player2);
        }
    }
}

Console.OutputEncoding = Encoding.UTF8;

Console.OutputEncoding = Encoding.Unicode;

Console.OutputEncoding = Encoding.GetEncoding(1251);

Console.OutputEncoding = Encoding.Default;

Console.OutputEncoding = Encoding.ASCII;

HttpWebRequest request = (HttpWebRequest)WebRequest.Create("http://mycsharp.ru");
			HttpWebResponse response = request.GetResponse() as HttpWebResponse;
			StreamReader reader = new StreamReader(response.GetResponseStream());
			string html = reader.ReadToEnd();
			MatchCollection matches = Regex.Matches(html,"<h2>.*?</h2>",RegexOptions.Singleline);
			foreach (Match element in matches) {
				
				string header = Regex.Replace(element.Value, "<.*?>","");
				Console.WriteLine(header);
				Console.WriteLine();
			}
			Console.ReadLine();

HttpWebRequest request = (HttpWebRequest)WebRequest.Create("http://mycsharp.ru");
			HttpWebResponse response = request.GetResponse() as HttpWebResponse;
			StreamReader reader = new StreamReader(response.GetResponseStream());
			string html = reader.ReadToEnd();
			MatchCollection matches = Regex.Matches(html,"<h2>.*</h2>",RegexOptions.Singleline);
			foreach (Match element in matches) {
				
				Console.WriteLine(element.Value);
			}
			Console.ReadLine();

 static void Main(string[] args)
        {
            string uri = "http://mycsharp.ru/";
            
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(uri);
            HttpWebResponse response = (HttpWebResponse)request.GetResponse();
            
            StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.UTF8);
            Regex myReg = new Regex("(?<=color=\"\\#454545\" size=\"6\">)([^<]+)");
            MatchCollection matches = myReg.Matches(reader.ReadToEnd());
            foreach (Match m in matches)
                Console.WriteLine(m.Value);
            Console.ReadLine();
        }

using System;
using System.Text;
using System.Net;
using System.IO;
using System.Text.RegularExpressions;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            string uri = "http://mycsharp.ru/";

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(uri);

            //Console.BufferHeight = 500;       // раскомментировать, чтобы
            //request.UserAgent = "lesson34";   // увидеть разницу (пустой вывод)
            HttpWebResponse response = (HttpWebResponse)request.GetResponse();

            StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.UTF8);

            Regex myReg = new Regex("<a id=\"ContentPlaceHolder1_DataListPosts_HyperLink1");

            while (!reader.EndOfStream)
            {
                string str = reader.ReadLine();

                if (myReg.IsMatch(str))
                {
                    int posA = str.IndexOf("\"6\">") + 4; // 4 = размер текста '"6">'
                    int posB = str.IndexOf("</font>");
                    Console.WriteLine(str.Substring(posA, posB - posA));
                }
            }
            Console.ReadLine();
        }
    }
}