Example #1
0
        public void UseSpall(Map map, Game_Object_In_Call obj, IUnit unit, object property)
        {
            _bullet            = property as Bullet;
            _bullet.BuffDemage = true;
            _map     = map;
            _unit    = _bullet.UnitUsed;
            Duration = _bullet.Duration;
            ///Ячейка где действует шрапнель
            _oldCall = map.Calls.Single(p => p.IndexLeft == _bullet.PositionX &&
                                        p.IndexTop == _bullet.PositionY);
            _oldCall.Bullet.Add(_bullet);

            ///Таймер время жизни шрапнели
            _firstTimer = new Storyboard()
            {
                Duration = TimeSpan.FromSeconds(1)
            };
            _firstTimer.Completed += _firstTimer_Completed;
            _firstTimer.Begin();

            if (Paused)
            {
                Pause();
            }
        }
Example #2
0
        public void UseSpall(Map map, Game_Object_In_Call obj, IUnit unit, object property)
        {
            _bullet      = property as Bullet;
            _bullet.Name = "SPB_Jakiro_Ice_Path";

            _map     = map;
            _unit    = _bullet.UnitUsed;
            Duration = _bullet.Duration;
            ///Ячейка где действует тучка
            _oldCall = map.Calls.Single(p => p.IndexLeft == _bullet.PositionX &&
                                        p.IndexTop == _bullet.PositionY);
            _oldCall.Bullet.Add(_bullet);

            for (int i = 0; i < _oldCall.IUnits.Count; i++)
            {
                var item = _oldCall.IUnits[i];
                if (item != null && item.GroupType != _unit.GroupType)
                {
                    UnitGenerator.AddStuneTwo(_oldCall, _bullet, _bullet.StunDuration, 4);
                }
            }

            ///Таймер время жизни тучки
            _firstTimer = new Storyboard()
            {
                Duration = TimeSpan.FromSeconds(1)
            };
            _firstTimer.Completed += _firstTimer_Completed;
            _firstTimer.Begin();

            if (Paused)
            {
                Pause();
            }
        }
Example #3
0
        /// <summary>
        /// Счастливая монетка, пасивная способновть
        /// </summary>
        public void UseSpall(Map map, Game_Object_In_Call obj, IUnit unit, object property)
        {
            bool upSpell = UnitGenerator.UpPlayerSpell(unit, this);

            _unit = unit;

            if (upSpell && !CuldaunBool)
            {
                CuldaunBool = true;
                ///Данная способность является бафом для игрока, в этом случае алхимика

                Buff buff = unit.Buffs.FirstOrDefault(p => p.Name == "GreevilsGreed");
                if (buff != null)
                {
                    buff.GoldBonus = LevelCast * 2;
                }
                else
                {
                    Buff alchBuff = new Buff()
                    {
                        Passive   = true,
                        GoldBonus = LevelCast * 2,
                        Duration  = LevelCast,
                        Name      = "GreevilsGreed"
                    };
                    unit.Buffs.Add(alchBuff);
                }

                UnitGenerator.UpdatePlayerView(unit);
            }
        }
Example #4
0
 public void StartUseAura(Map map, Game_Object_In_Call obj, IUnit unit, object property)
 {
     if (!Stop)
     {
         UseSpall(map, obj, unit, property);
     }
 }
Example #5
0
        /// <summary>
        /// Ульт алхимика, усиливает героя
        /// </summary>
        public void UseSpall(Map map, Game_Object_In_Call obj, IUnit unit, object property)
        {
            bool upSpell = UnitGenerator.UpPlayerSpell(unit, this);

            _unit = unit as Player;
            if (unit.UnitFrozen == false &&
                !_culdaunBool && LevelCast != 0 && !upSpell &&
                !unit.Silenced &&
                !unit.Hexed &&
                _unit != null)
            {
                if (unit.Mana >= ManaCost)
                ///Проверка есть ли мана на каст
                {
                    ///Флаг кулдауна
                    _culdaunBool = true;

                    ///Отнимаем нужное количество
                    unit.Mana -= ManaCost;

                    _unit.Invisibility            = true;
                    _unit.GameObject.View.Opacity = 0.25;
                    if (!_unit.Buffs.Any(p => p.Name == "SP_Mirana_MoonlightShadow"))
                    {
                        Buff alchBuff = new Buff()
                        {
                            Duration = Duration,
                            Name     = "SP_Mirana_MoonlightShadow"
                        };
                        _unit.Buffs.Add(alchBuff);
                    }

                    _firstTimer = new Storyboard()
                    {
                        Duration = TimeSpan.FromSeconds(Duration)
                    };
                    _firstTimer.Completed += mouveTimer_Tick;
                    _firstTimer.Begin();

                    _secondTimer = new Storyboard()
                    {
                        Duration = TimeSpan.FromSeconds(Culdaun)
                    };
                    _secondTimer.Completed += mouveTimerCuldaun_Tick;
                    _secondTimer.Begin();

                    if (Paused)
                    {
                        Pause();
                    }

                    if (StartUseSpell != null)
                    {
                        StartUseSpell(this, null);
                    }
                    UnitGenerator.UpdatePlayerView(unit);
                }
            }
        }
Example #6
0
        public void UseSpall(Map map, Game_Object_In_Call obj, IUnit unit, object property)
        {
            _bullet = property as Bullet;
            _map    = map;
            _unit   = unit;

            Map_Cell oldCall = map.Calls.Single(p => p.IndexLeft == _bullet.PositionX &&
                                                p.IndexTop == _bullet.PositionY);

            oldCall.Bullet.Add(_bullet);

            BulletMuve(_bullet);
        }
Example #7
0
        public void UseSpall(Map map, Game_Object_In_Call obj, IUnit unit, object property)
        {
            _unit = unit;

            if (unit.UnitFrozen == false &&
                !_culdaunBool && !_unit.Hexed)
            {
                if (unit.Mana >= ManaCost)
                ///Проверка есть ли мана на каст
                {
                    ///Флаг кулдауна
                    _culdaunBool  = true;
                    _spellStopped = false;

                    ///Отнимаем нужное количество
                    unit.Mana -= ManaCost;
                    _unit      = unit;



                    unit.OrijSpeed -= _speed;


                    _firstTimer = new Storyboard()
                    {
                        Duration = TimeSpan.FromSeconds(Duration)
                    };
                    _firstTimer.Completed += mouveTimer_Tick;
                    _firstTimer.Begin();

                    _secondTimer = new Storyboard()
                    {
                        Duration = TimeSpan.FromSeconds(Culdaun)
                    };
                    _secondTimer.Completed += mouveTimerCuldaun_Tick;
                    _secondTimer.Begin();

                    if (Paused)
                    {
                        Pause();
                    }

                    if (StartUseSpell != null)
                    {
                        StartUseSpell(this, null);
                    }
                    UnitGenerator.UpdatePlayerView(unit);
                }
            }
        }
Example #8
0
        /// <summary>
        /// Обычная атака моба
        /// </summary>
        /// <param name="property">Колонка куда наносится удар</param>
        public void UseSpall(Map map, Game_Object_In_Call obj, IUnit unit, object property)
        {
            if (unit.UnitFrozen == false &&
                !_culdaunBool)
            {
                ///Флаг кулдауна
                _culdaunBool = true;
                _unit        = unit;

                CurrentCall = property as Map_Cell;
                if (CurrentCall != null)
                {
                    if (!unit.Hexed)
                    {
                        Bullet bullet = new Bullet()
                        {
                            UnitUsed   = unit,
                            DemagePhys = unit.Demage
                        };
                        UnitGenerator.AddDamage(CurrentCall, bullet);
                    }

                    _firstTimer = new Storyboard()
                    {
                        Duration = TimeSpan.FromSeconds(unit.AttackSpeed)
                    };
                    _firstTimer.Completed += _firstTimer_Completed;
                    _firstTimer.Begin();

                    if (Paused)
                    {
                        Pause();
                    }
                }
            }
            else if (CompletedUseSpell != null)
            {
                CompletedUseSpell(this, null);
            }
        }
Example #9
0
        public void UseSpall(Map map, Game_Object_In_Call obj, IUnit unit, object property)
        {
            if (unit.UnitFrozen == false &&
                LevelCast != 0 &&
                !unit.Hexed)
            {
                Player player = unit as Player;
                if (player != null && player.Name == "Alchemist")
                {
                    player.DropItem(player.Items.FirstOrDefault(p => p.Name == "Aghanims Scepter"));
                }

                if (Paused)
                {
                    Pause();
                }

                if (StartUseSpell != null)
                {
                    StartUseSpell(this, null);
                }
                UnitGenerator.UpdatePlayerView(unit);
            }
        }
Example #10
0
        /// <summary>
        /// Счастливая монетка, пасивная способновть
        /// </summary>
        public void UseSpall(Map map, Game_Object_In_Call obj, IUnit unit, object property)
        {
            bool upSpell = UnitGenerator.UpPlayerSpell(unit, this);

            _unit = unit;

            if (upSpell && !CuldaunBool)
            {
                CuldaunBool = true;
                ///Данная способность является бафом для игрока, в этом случае дальность снайпера
                _unit.Range += 1;

                foreach (var item in unit.Spells)
                {
                    if (item.GetType() == typeof(SP_Sniper_Headshot))
                    {
                        SP_Sniper_Headshot headshot = (SP_Sniper_Headshot)item;
                        headshot.Speed -= 0.05;
                    }
                }

                UnitGenerator.UpdatePlayerView(unit);
            }
        }
Example #11
0
        /// <summary>
        /// Запуск пули
        /// </summary>
        /// <param name="property">Уровень прокача способности, умножется на 5 и получается магический урон стрелы</param>
        public void UseSpall(Map map, Game_Object_In_Call obj, IUnit unit, object property)
        {
            _unit = unit;
            bool upSpell = UnitGenerator.UpPlayerSpell(unit, this);

            if (unit.UnitFrozen == false &&
                !_culdaunBool && LevelCast != 0 &&
                !upSpell &&
                !unit.Hexed &&
                !Paused)
            {
                if (unit.Mana >= ManaCost)
                ///Проверка есть ли мана на каст
                {
                    //Speed = unit.AttackSpeed;

                    ///Флаг кулдауна
                    _culdaunBool = true;

                    ///Отнимаем нужное количество
                    unit.Mana -= ManaCost;

                    Culdaun = unit.AttackSpeed * 2;
                    if (Culdaun < StaticVaribl.AttackSpeedRangeMaximum)
                    {
                        Culdaun = StaticVaribl.AttackSpeedRangeMaximum;
                    }

                    Bullet bullArrow = new Bullet();

                    bullArrow.GameObject = new Game_Object_In_Call()
                    {
                        EnumCallType = EnumCallType.Bullet,
                    };

                    /// Если есть скади
                    if (UnitGenerator.HasSkadi(unit))
                    {
                        UC_Skadi skadiArrow = new UC_Skadi();
                        skadiArrow.ChengAngel(unit.Angel);
                        bullArrow.GameObject.View = skadiArrow;
                    }
                    else
                    {
                        ///Создаем визуальный объект стрела
                        UC_Sf_Bullet arrow = new UC_Sf_Bullet();
                        arrow.ChengAngel(unit.Angel);
                        bullArrow.GameObject.View = arrow;
                    }


                    bullArrow.UnitUsed   = unit;
                    bullArrow.PositionX  = unit.PositionX;
                    bullArrow.PositionY  = unit.PositionY;
                    bullArrow.Speed      = Speed;
                    bullArrow.DemagePhys = unit.Demage;

                    UnitGenerator.MKB_Bush(bullArrow, unit);
                    ///Магический урон зависит от прокача стрел
                    //bullArrow.DemageMagic = 5 * (int)property;


                    #region SoulCount
                    Buff buff = _unit.Buffs.FirstOrDefault(p => p.Name == "SoulCount");
                    if (buff == null)
                    {
                        buff = new Buff()
                        {
                            Passive  = true,
                            Duration = LevelCast,
                            Name     = "SoulCount"
                        };
                        _unit.Buffs.Add(buff);
                    }
                    bullArrow.DemagePhys += buff.SoulCount;
                    #endregion

                    if (LevelCast == 1)
                    {
                        buff.MaxSoulCount    = 12;
                        bullArrow.MinusArmor = 1;
                    }
                    else if (LevelCast == 2)
                    {
                        buff.MaxSoulCount    = 20;
                        bullArrow.MinusArmor = 2;
                    }
                    else if (LevelCast == 3)
                    {
                        buff.MaxSoulCount    = 32;
                        bullArrow.MinusArmor = 3;
                    }

                    bullArrow.CurrentMap = map;
                    bullArrow.Angel      = unit.Angel;
                    bullArrow.Range      = _unit.Range;
                    ///Поведение такое же как у стрел боника
                    bullArrow.Spells.Add(new SPB_FireArrow()
                    {
                        Name = "Fly"
                    });

                    ///И его же добавим в масив всех объектов
                    map.GameObjectInCall.Add(bullArrow.GameObject);

                    Canvas.SetLeft(bullArrow.GameObject.View, bullArrow.PositionX * 50);
                    Canvas.SetTop(bullArrow.GameObject.View, bullArrow.PositionY * 50);
                    ///Отображение
                    map.MapCanvas.Children.Add(bullArrow.GameObject.View);

                    bullArrow.UseSpall("Fly");

                    ///Таймер кулдауна заклинания
                    _secondTimer = new Storyboard()
                    {
                        Duration = TimeSpan.FromSeconds(Culdaun)
                    };
                    _secondTimer.Completed += _secondTimer_Completed;
                    _secondTimer.Begin();

                    if (Paused)
                    {
                        Pause();
                    }

                    if (StartUseSpell != null)
                    {
                        StartUseSpell(this, null);
                    }

                    UnitGenerator.UpdatePlayerView(unit);
                }
                else
                ///Маны нету
                {
                }
            }
        }
Example #12
0
        /// <summary>
        /// Запуск пули
        /// </summary>
        /// <param name="property">Уровень прокача способности, умножется на 5 и получается магический урон стрелы</param>
        public void UseSpall(Map map, Game_Object_In_Call obj, IUnit unit, object property)
        {
            _unit = unit;
            bool upSpell = UnitGenerator.UpPlayerSpell(unit, this);

            if (unit.UnitFrozen == false &&
                !_culdaunBool && LevelCast != 0 &&
                !upSpell &&
                !unit.Hexed &&
                !Paused)
            {
                if (unit.Mana >= ManaCost)
                ///Проверка есть ли мана на каст
                {
                    //Speed = unit.AttackSpeed;

                    ///Флаг кулдауна
                    _culdaunBool = true;

                    ///Отнимаем нужное количество
                    unit.Mana -= ManaCost;

                    Culdaun = unit.AttackSpeed * 2;
                    if (Culdaun < StaticVaribl.AttackSpeedRangeMaximum)
                    {
                        Culdaun = StaticVaribl.AttackSpeedRangeMaximum;
                    }


                    Bullet bullArrow = new Bullet();
                    bullArrow.GameObject = new Game_Object_In_Call()
                    {
                        EnumCallType = EnumCallType.Bullet,
                    };

                    /// Если есть скади
                    if (UnitGenerator.HasSkadi(unit))
                    {
                        UC_Skadi skadiArrow = new UC_Skadi();
                        skadiArrow.ChengAngel(unit.Angel);
                        bullArrow.GameObject.View = skadiArrow;
                    }
                    else
                    {
                        ///Создаем визуальный объект стрела
                        UC_Sniper_Headshot arrow = new UC_Sniper_Headshot();
                        arrow.ChengAngel(unit.Angel);
                        bullArrow.GameObject.View = arrow;
                    }

                    bullArrow.UnitUsed   = unit;
                    bullArrow.PositionX  = unit.PositionX;
                    bullArrow.PositionY  = unit.PositionY;
                    bullArrow.Speed      = Speed;
                    bullArrow.DemagePhys = unit.Demage;

                    ///Магический урон зависит от прокача стрел
                    //bullArrow.DemageMagic = 5 * (int)property;

                    int bonusDemagePerBushHit = 5;
                    int chans = 25;

                    if (LevelCast == 1)
                    {
                        bonusDemagePerBushHit = 5;
                        chans = 25;
                    }
                    else if (LevelCast == 2)
                    {
                        bonusDemagePerBushHit = 10;
                        chans = 30;
                    }
                    else if (LevelCast == 3)
                    {
                        bonusDemagePerBushHit = 15;
                        chans = 35;
                    }

                    ///Мкб микробаши не стакаются со снайперовыми
                    Random rand = new Random((int)DateTime.Now.Ticks);
                    if (chans > rand.Next(0, 100))
                    {
                        bullArrow.StunDuration = 1;
                        bullArrow.DemagePhys  += bonusDemagePerBushHit;
                    }

                    bullArrow.CurrentMap = map;
                    bullArrow.Angel      = unit.Angel;
                    bullArrow.Range      = _unit.Range;
                    ///Поведение такое же как у стрел боника
                    bullArrow.Spells.Add(new SPB_FireArrow()
                    {
                        Name = "Fly"
                    });

                    ///И его же добавим в масив всех объектов
                    map.GameObjectInCall.Add(bullArrow.GameObject);

                    Canvas.SetLeft(bullArrow.GameObject.View, bullArrow.PositionX * 50);
                    Canvas.SetTop(bullArrow.GameObject.View, bullArrow.PositionY * 50);
                    ///Отображение
                    map.MapCanvas.Children.Add(bullArrow.GameObject.View);

                    bullArrow.UseSpall("Fly");

                    ///Таймер кулдауна заклинания
                    _secondTimer = new Storyboard()
                    {
                        Duration = TimeSpan.FromSeconds(Culdaun)
                    };
                    _secondTimer.Completed += _secondTimer_Completed;
                    _secondTimer.Begin();

                    if (Paused)
                    {
                        Pause();
                    }

                    if (StartUseSpell != null)
                    {
                        StartUseSpell(this, null);
                    }

                    UnitGenerator.UpdatePlayerView(unit);
                }
                else
                ///Маны нету
                {
                }
            }
        }
Example #13
0
        /// <summary>
        /// Запуск шарика который бъет врагов
        /// </summary>
        public void UseSpall(Map map, Game_Object_In_Call obj, IUnit unit, object property)
        {
            _unit = unit;

            if (unit.UnitFrozen == false &&
                !_culdaunBool && !unit.Silenced &&
                !unit.Hexed &&
                !Paused)
            {
                if (unit.Mana >= ManaCost)
                ///Проверка есть ли мана на каст
                {
                    Speed = unit.AttackSpeed;

                    ///Флаг кулдауна
                    _culdaunBool = true;

                    ///Отнимаем нужное количество
                    unit.Mana -= ManaCost;

                    ///Создаем визуальный объект шарик
                    UC_EasyMobAttackBall arrow = new UC_EasyMobAttackBall();
                    arrow.ViewBall(2);
                    //arrow.ChengAngel(unit.Angel);

                    Bullet bullArrow = new Bullet();
                    bullArrow.GameObject = new Game_Object_In_Call()
                    {
                        EnumCallType = EnumCallType.Bullet,
                        View         = arrow
                    };
                    bullArrow.UnitUsed   = unit;
                    bullArrow.PositionX  = unit.PositionX;
                    bullArrow.PositionY  = unit.PositionY;
                    bullArrow.Speed      = 0.25;
                    bullArrow.DemagePhys = unit.Demage;


                    ///Мкб микробаши не стакаются со снайперовыми
                    Random rand = new Random((int)DateTime.Now.Ticks);
                    if (30 > rand.Next(0, 100))
                    {
                        bullArrow.StunDuration = 1;
                    }

                    bullArrow.CurrentMap = map;
                    bullArrow.Angel      = unit.Angel;
                    bullArrow.Range      = _unit.Range;

                    bullArrow.Spells.Add(new SPB_EasyMobArrow()
                    {
                        Name = "Fly"
                    });

                    ///И его же добавим в масив всех объектов
                    map.GameObjectInCall.Add(bullArrow.GameObject);

                    Canvas.SetLeft(bullArrow.GameObject.View, bullArrow.PositionX * 50);
                    Canvas.SetTop(bullArrow.GameObject.View, bullArrow.PositionY * 50);
                    ///Отображение
                    map.MapCanvas.Children.Add(bullArrow.GameObject.View);

                    bullArrow.UseSpall("Fly");

                    ///Таймер кулдауна заклинания
                    _secondTimer = new Storyboard()
                    {
                        Duration = TimeSpan.FromSeconds(Culdaun)
                    };
                    _secondTimer.Completed += _secondTimer_Completed;
                    _secondTimer.Begin();

                    if (Paused)
                    {
                        Pause();
                    }

                    if (StartUseSpell != null)
                    {
                        StartUseSpell(this, null);
                    }

                    UnitGenerator.UpdatePlayerView(unit);
                }
                else
                ///Маны нету
                {
                }
            }
        }
Example #14
0
        /// <summary>
        /// Запуск пули
        /// </summary>
        /// <param name="property">Уровень прокача способности, умножется на 5 и получается магический урон стрелы</param>
        public void UseSpall(Map map, Game_Object_In_Call obj, IUnit unit, object property)
        {
            _unit = unit;
            bool upSpell = UnitGenerator.UpPlayerSpell(unit, this);


            /// Если есть аганим
            if (UnitGenerator.HasAghanim(unit))
            {
                /// То ульт у снайпера быстрее востанавливается
                _culdaun = _culdaun / 2;
            }


            if (unit.UnitFrozen == false &&
                !_culdaunBool && LevelCast != 0 &&
                !upSpell && !unit.Silenced &&
                !unit.Hexed &&
                !Paused)
            {
                if (unit.Mana >= ManaCost)
                ///Проверка есть ли мана на каст
                {
                    Speed = unit.AttackSpeed;

                    ///Флаг кулдауна
                    _culdaunBool = true;

                    ///Отнимаем нужное количество
                    unit.Mana -= ManaCost;

                    ///Создаем визуальный объект стрела
                    UC_Sniper_Headshot arrow = new UC_Sniper_Headshot();
                    arrow.ChengAngel(unit.Angel);
                    Bullet bullArrow = new Bullet();
                    bullArrow.GameObject = new Game_Object_In_Call()
                    {
                        EnumCallType = EnumCallType.Bullet,
                        View         = arrow
                    };
                    bullArrow.UnitUsed   = unit;
                    bullArrow.PositionX  = unit.PositionX;
                    bullArrow.PositionY  = unit.PositionY;
                    bullArrow.Speed      = 0.3;
                    bullArrow.DemagePhys = unit.Demage;

                    if (LevelCast == 1)
                    {
                        bullArrow.DemageMagic = 30;
                    }


                    bullArrow.CurrentMap = map;
                    bullArrow.Angel      = unit.Angel;
                    bullArrow.Range      = 30;

                    ///Теперь выбераем цель пули
                    ///Это первый юнит на которого была наведена пуля

                    Map_Cell callsPoint = null;
                    ///Получаем ячейки которые находятся перед героем
                    #region Select first unit
                    int xNew = unit.PositionX;
                    int yNew = unit.PositionY;
                    if (unit.Angel == EAngel.Left)
                    {
                        for (int i = 0; i <= map.Width / 50; i++)
                        {
                            xNew = xNew - 1;
                            Map_Cell call = map.Calls.FirstOrDefault(p => p.IndexLeft == xNew && p.IndexTop == yNew);
                            if (call != null && !call.Block)
                            {
                                if (call.IUnits.Any(p => p.GameObject.EnumCallType == EnumCallType.Unit ||
                                                    p.GameObject.EnumCallType == EnumCallType.Player))
                                {
                                    callsPoint = call;
                                    break;
                                }
                            }
                        }
                    }
                    else if (unit.Angel == EAngel.Right)
                    {
                        for (int i = 0; i <= map.Width / 50; i++)
                        {
                            xNew = xNew + 1;
                            Map_Cell call = map.Calls.FirstOrDefault(p => p.IndexLeft == xNew && p.IndexTop == yNew);
                            if (call != null && !call.Block)
                            {
                                if (call.IUnits.Any(p => p.GameObject.EnumCallType == EnumCallType.Unit ||
                                                    p.GameObject.EnumCallType == EnumCallType.Player))
                                {
                                    callsPoint = call;
                                    break;
                                }
                            }
                        }
                    }
                    else if (unit.Angel == EAngel.Top)
                    {
                        for (int i = 0; i <= map.Height / 50; i++)
                        {
                            yNew = yNew - 1;
                            Map_Cell call = map.Calls.FirstOrDefault(p => p.IndexLeft == xNew && p.IndexTop == yNew);
                            if (call != null && !call.Block)
                            {
                                if (call.IUnits.Any(p => p.GameObject.EnumCallType == EnumCallType.Unit ||
                                                    p.GameObject.EnumCallType == EnumCallType.Player))
                                {
                                    callsPoint = call;
                                    break;
                                }
                            }
                        }
                    }
                    else if (unit.Angel == EAngel.Bottom)
                    {
                        for (int i = 0; i <= map.Height / 50; i++)
                        {
                            yNew = yNew + 1;
                            Map_Cell call = map.Calls.FirstOrDefault(p => p.IndexLeft == xNew && p.IndexTop == yNew);
                            if (call != null && !call.Block)
                            {
                                if (call.IUnits.Any(p => p.GameObject.EnumCallType == EnumCallType.Unit ||
                                                    p.GameObject.EnumCallType == EnumCallType.Player))
                                {
                                    callsPoint = call;
                                    break;
                                }
                            }
                        }
                    }

                    if (callsPoint != null)
                    {
                        bullArrow.Aim = callsPoint.IUnits.FirstOrDefault(p => p.GameObject.EnumCallType == EnumCallType.Player);
                        if (bullArrow.Aim == null)
                        {
                            bullArrow.Aim = callsPoint.IUnits.FirstOrDefault(p => p.GameObject.EnumCallType == EnumCallType.Unit);
                        }
                    }
                    #endregion

                    bullArrow.Spells.Add(new SPB_Sniper_Assassinate()
                    {
                        Name = "Fly"
                    });

                    ///И его же добавим в масив всех объектов
                    map.GameObjectInCall.Add(bullArrow.GameObject);

                    Canvas.SetLeft(bullArrow.GameObject.View, bullArrow.PositionX * 50);
                    Canvas.SetTop(bullArrow.GameObject.View, bullArrow.PositionY * 50);
                    ///Отображение
                    map.MapCanvas.Children.Add(bullArrow.GameObject.View);

                    bullArrow.UseSpall("Fly");

                    ///Таймер кулдауна заклинания
                    _secondTimer = new Storyboard()
                    {
                        Duration = TimeSpan.FromSeconds(Culdaun)
                    };
                    _secondTimer.Completed += _secondTimer_Completed;
                    _secondTimer.Begin();

                    if (Paused)
                    {
                        Pause();
                    }

                    if (StartUseSpell != null)
                    {
                        StartUseSpell(this, null);
                    }

                    UnitGenerator.UpdatePlayerView(unit);
                }
                else
                ///Маны нету
                {
                }
            }
        }
Example #15
0
        /// <summary>
        /// Запуск шарика который бъет врагов
        /// </summary>
        public void UseSpall(Map map, Game_Object_In_Call obj, IUnit unit, object property)
        {
            _unit = unit;

            if (unit.UnitFrozen == false &&
                !_culdaunBool && !unit.Silenced &&
                !unit.Hexed &&
                !Paused)
            {
                if (unit.Mana >= ManaCost)
                ///Проверка есть ли мана на каст
                {
                    Speed = unit.AttackSpeed;

                    ///Флаг кулдауна
                    _culdaunBool = true;

                    ///Отнимаем нужное количество
                    unit.Mana -= ManaCost;

                    EAngel[] angels = new EAngel[] { EAngel.Left, EAngel.Top, EAngel.Right, EAngel.Bottom };

                    foreach (var item in angels)
                    {
                        ///Создаем визуальный объект шарик
                        UC_EasyMobAttackBall arrow = new UC_EasyMobAttackBall();
                        //arrow.ViewBall(1);
                        //arrow.ChengAngel(unit.Angel);

                        Bullet bullArrow = new Bullet();
                        bullArrow.GameObject = new Game_Object_In_Call()
                        {
                            EnumCallType = EnumCallType.Bullet,
                            View         = arrow
                        };
                        bullArrow.UnitUsed   = unit;
                        bullArrow.PositionX  = unit.PositionX;
                        bullArrow.PositionY  = unit.PositionY;
                        bullArrow.Speed      = 0.4;
                        bullArrow.DemagePhys = unit.Demage;

                        bullArrow.CurrentMap = map;
                        bullArrow.Angel      = item;
                        bullArrow.Range      = _unit.Range;
                        bullArrow.Splash     = 0.5;

                        bullArrow.Spells.Add(new SPB_Jinx_Zap_Roket()
                        {
                            Name = "Fly", ExplosionStyle = 1
                        });

                        ///И его же добавим в масив всех объектов
                        map.GameObjectInCall.Add(bullArrow.GameObject);

                        Canvas.SetLeft(bullArrow.GameObject.View, bullArrow.PositionX * 50);
                        Canvas.SetTop(bullArrow.GameObject.View, bullArrow.PositionY * 50);
                        ///Отображение
                        map.MapCanvas.Children.Add(bullArrow.GameObject.View);

                        bullArrow.UseSpall("Fly");
                    }

                    ///Таймер кулдауна заклинания
                    _secondTimer = new Storyboard()
                    {
                        Duration = TimeSpan.FromSeconds(Culdaun)
                    };
                    _secondTimer.Completed += _secondTimer_Completed;
                    _secondTimer.Begin();

                    if (Paused)
                    {
                        Pause();
                    }

                    if (StartUseSpell != null)
                    {
                        StartUseSpell(this, null);
                    }

                    UnitGenerator.UpdatePlayerView(unit);
                }
                else
                ///Маны нету
                {
                }
            }
        }
Example #16
0
        /// <summary>
        /// Ульт алхимика, усиливает героя
        /// </summary>
        public void UseSpall(Map map, Game_Object_In_Call obj, IUnit unit, object property)
        {
            bool upSpell = UnitGenerator.UpPlayerSpell(unit, this);

            _unit = unit as Player;

            if (unit.UnitFrozen == false &&
                !_culdaunBool &&
                LevelCast != 0 &&
                !upSpell &&
                !unit.Silenced &&
                !unit.Hexed &&
                _unit != null)
            {
                if (unit.Mana >= ManaCost)
                ///Проверка есть ли мана на каст
                {
                    ///Флаг кулдауна
                    _culdaunBool = true;

                    ///Отнимаем нужное количество
                    unit.Mana -= ManaCost;


                    _unit.OrijSpeed -= _bonusSpeed;


                    ///Реген здоровъя
                    _unit.OrijHealthRegeneration += _hpRegen;

                    _unit.OrijManaRegeneration += _manaRegen;
                    ///Бонусная скорость атаки
                    _unit.OrijAttackSpeed -= _bonusAttackSpeed;

                    (_unit.GameObject.View as UC_Player).ShowEffect(1, true);

                    _firstTimer = new Storyboard()
                    {
                        Duration = TimeSpan.FromSeconds(Duration)
                    };
                    _firstTimer.Completed += mouveTimer_Tick;
                    _firstTimer.Begin();

                    _secondTimer = new Storyboard()
                    {
                        Duration = TimeSpan.FromSeconds(Culdaun)
                    };
                    _secondTimer.Completed += mouveTimerCuldaun_Tick;
                    _secondTimer.Begin();

                    if (Paused)
                    {
                        Pause();
                    }

                    if (StartUseSpell != null)
                    {
                        StartUseSpell(this, null);
                    }
                    UnitGenerator.UpdatePlayerView(unit);
                }
            }
        }
        /// <summary>
        /// Запуск стрелы
        /// </summary>
        /// <param name="property">Уровень прокача способности, умножется на 5 и получается магический урон стрелы</param>
        public void UseSpall(Map map, Game_Object_In_Call obj, IUnit unit, object property)
        {
            _unit = unit;
            bool upSpell = UnitGenerator.UpPlayerSpell(unit, this);

            if (unit.UnitFrozen == false &&
                !_culdaunBool && LevelCast != 0 &&
                !upSpell &&
                !unit.Hexed &&
                !Paused)
            {
                if (unit.Mana >= ManaCost)
                ///Проверка есть ли мана на каст
                {
                    ///Флаг кулдауна
                    _culdaunBool = true;

                    ///Отнимаем нужное количество
                    unit.Mana -= ManaCost;

                    ///Создаем визуальный объект стрела
                    UC_Super_Mega_Death_Rocket arrow = new UC_Super_Mega_Death_Rocket();
                    arrow.ChengAngelArrow(_unit.Angel);



                    Bullet bullArrow = new Bullet();
                    bullArrow.GameObject = new Game_Object_In_Call()
                    {
                        EnumCallType = EnumCallType.Bullet,
                        View         = arrow
                    };
                    bullArrow.UnitUsed  = unit;
                    bullArrow.PositionX = unit.PositionX;
                    bullArrow.PositionY = unit.PositionY;
                    bullArrow.Speed     = Speed;

                    bullArrow.DemageMagic = 20;
                    ///Магический урон зависит от прокача стрел
                    //bullArrow.DemageMagic = 5 * (int)property;

                    bullArrow.BonusDemage = 30;

                    /// Если есть аганим
                    if (UnitGenerator.HasAghanim(unit))
                    {
                        bullArrow.BonusDemage += 10;
                        arrow.Opacity          = 0.5;
                    }

                    bullArrow.CurrentMap = map;
                    bullArrow.Angel      = unit.Angel;
                    bullArrow.Range      = 30;

                    UnitGenerator.MKB_Bush(bullArrow, unit);

                    bullArrow.Spells.Add(new SPB_Super_Mega_Death_Rocket()
                    {
                        Name = "Fly"
                    });

                    ///И его же добавим в масив всех объектов
                    map.GameObjectInCall.Add(bullArrow.GameObject);

                    Canvas.SetLeft(bullArrow.GameObject.View, bullArrow.PositionX * 50);
                    Canvas.SetTop(bullArrow.GameObject.View, bullArrow.PositionY * 50);
                    ///Отображение
                    map.MapCanvas.Children.Add(bullArrow.GameObject.View);

                    bullArrow.UseSpall("Fly");

                    ///Таймер кулдауна заклинания
                    _secondTimer = new Storyboard()
                    {
                        Duration = TimeSpan.FromSeconds(Culdaun)
                    };
                    _secondTimer.Completed += _secondTimer_Completed;
                    _secondTimer.Begin();

                    if (Paused)
                    {
                        Pause();
                    }

                    if (StartUseSpell != null)
                    {
                        StartUseSpell(this, null);
                    }

                    UnitGenerator.UpdatePlayerView(unit);
                }
                else
                ///Маны нету
                {
                }
            }
        }
Example #18
0
        /// <summary>
        /// Запуск стрелы
        /// </summary>
        /// <param name="property">Уровень прокача способности, умножется на 5 и получается магический урон стрелы</param>
        public void UseSpall(Map map, Game_Object_In_Call obj, IUnit unit, object property)
        {
            _unit = unit;
            bool upSpell = UnitGenerator.UpPlayerSpell(unit, this);

            if (unit.UnitFrozen == false &&
                !_culdaunBool && LevelCast != 0 &&
                !upSpell &&
                !unit.Hexed &&
                !Paused)
            {
                if (unit.Mana >= ManaCost)
                ///Проверка есть ли мана на каст
                {
                    Speed = unit.AttackSpeed;

                    ///Флаг кулдауна
                    _culdaunBool = true;

                    ///Отнимаем нужное количество
                    unit.Mana -= ManaCost;

                    Bullet bullLiquidFire = new Bullet();
                    bullLiquidFire.GameObject = new Game_Object_In_Call()
                    {
                        EnumCallType = EnumCallType.Bullet,
                    };

                    ///Создаем визуальный объект стрела
                    UC_Jakiro_LiquidFire arrow = new UC_Jakiro_LiquidFire();
                    arrow.ChengAngel(unit.Angel);
                    bullLiquidFire.GameObject.View = arrow;


                    bullLiquidFire.UnitUsed    = unit;
                    bullLiquidFire.PositionX   = unit.PositionX;
                    bullLiquidFire.PositionY   = unit.PositionY;
                    bullLiquidFire.Speed       = Speed / 2;
                    bullLiquidFire.DemageMagic = unit.Demage;

                    ///Магический урон зависит от прокача стрел
                    //bullArrow.DemageMagic = 5 * (int)property;

                    if (LevelCast == 1)
                    {
                        bullLiquidFire.AttackSpeedSlow = 0.1;
                    }
                    else if (LevelCast == 2)
                    {
                        bullLiquidFire.AttackSpeedSlow = 0.2;
                    }
                    else if (LevelCast == 3)
                    {
                        bullLiquidFire.AttackSpeedSlow = 0.3;
                    }

                    bullLiquidFire.CurrentMap = map;
                    bullLiquidFire.Angel      = unit.Angel;
                    bullLiquidFire.Range      = _unit.Range;


                    UnitGenerator.MKB_Bush(bullLiquidFire, unit);

                    bullLiquidFire.Spells.Add(new SPB_Jakiro_Liquid_Fire()
                    {
                        Name = "Fly"
                    });

                    ///И его же добавим в масив всех объектов
                    map.GameObjectInCall.Add(bullLiquidFire.GameObject);

                    Canvas.SetLeft(bullLiquidFire.GameObject.View, bullLiquidFire.PositionX * 50);
                    Canvas.SetTop(bullLiquidFire.GameObject.View, bullLiquidFire.PositionY * 50);
                    ///Отображение
                    map.MapCanvas.Children.Add(bullLiquidFire.GameObject.View);

                    bullLiquidFire.UseSpall("Fly");

                    ///Таймер кулдауна заклинания
                    _secondTimer = new Storyboard()
                    {
                        Duration = TimeSpan.FromSeconds(Culdaun)
                    };
                    _secondTimer.Completed += _secondTimer_Completed;
                    _secondTimer.Begin();

                    if (Paused)
                    {
                        Pause();
                    }

                    if (StartUseSpell != null)
                    {
                        StartUseSpell(this, null);
                    }

                    UnitGenerator.UpdatePlayerView(unit);
                }
                else
                ///Маны нету
                {
                }
            }
        }
Example #19
0
        public void UseSpall(Map map, Game_Object_In_Call obj, IUnit unit, object property)
        {
            _unit   = unit;
            _map    = map;
            _player = _unit as Player;

            if (unit.UnitFrozen == false &&
                !_culdaunBool && LevelCast != 0 &&
                !unit.Hexed)
            {
                if (unit.Mana >= ManaCost)
                ///Проверка есть ли мана на каст
                {
                    ///Флаг кулдауна
                    _culdaunBool = true;
                    ///Отнимаем нужное количество
                    unit.Mana -= ManaCost;

                    _size = 100;
                    if (LevelCast == 1)
                    {
                        _culdaun = 20;
                    }
                    else if (LevelCast == 2)
                    {
                        _culdaun = 12;
                    }

                    if (_player != null)
                    {
                        (_player.GameObject.View as UC_Player).ShowEffect(3, true);
                    }

                    ///Выбираем клетку куда прыгнуть
                    ///Тут кординаты ячеек в которых действует тучка
                    _callsPoints = new List <Point>();
                    ///Получаем ячейки которые находятся перед героем
                    ///использывавшим тучку
                    ///Сначала добавляем ячеку с героем
                    int xNew = unit.PositionX;
                    int yNew = unit.PositionY;
                    if (unit.Angel == EAngel.Left)
                    {
                        for (int i = 0; i <= _size; i++)
                        {
                            xNew = xNew - 1;

                            _callsPoints.Add(new Point(xNew, yNew));
                        }
                    }
                    else if (unit.Angel == EAngel.Right)
                    {
                        for (int i = 0; i <= _size; i++)
                        {
                            xNew = xNew + 1;

                            _callsPoints.Add(new Point(xNew, yNew));
                        }
                    }
                    else if (unit.Angel == EAngel.Top)
                    {
                        for (int i = 0; i <= _size; i++)
                        {
                            yNew = yNew - 1;

                            _callsPoints.Add(new Point(xNew, yNew));
                        }
                    }
                    else if (unit.Angel == EAngel.Bottom)
                    {
                        for (int i = 0; i <= _size; i++)
                        {
                            yNew = yNew + 1;

                            _callsPoints.Add(new Point(xNew, yNew));
                        }
                    }

                    _activeCall = null;
                    _callsPoints.Reverse();
                    ///Выбираем ячейку куда прыгать
                    foreach (var item in _callsPoints)
                    {
                        Map_Cell activeCall = map.Calls.FirstOrDefault(p => p.IndexLeft == item.X && p.IndexTop == item.Y);
                        if (activeCall != null &&
                            !activeCall.Block &&
                            activeCall.IUnits.Any(p => p.UnitType == EUnitType.Grass))
                        {
                            _activeCall = activeCall;
                            ///Прыгаем, в первую дальнюю ячейку
                            _activeCall.Using = true;
                            break;
                        }
                    }

                    if (_activeCall != null)
                    {
                        _unit.UnitFrozen = true;
                    }

                    ///Таймер время кастования телепорта
                    _firstTimer = new Storyboard()
                    {
                        Duration = TimeSpan.FromSeconds(Duration)
                    };
                    _firstTimer.Completed += _firstTimer_Completed;
                    _firstTimer.Begin();

                    ///Таймер кулдауна заклинания
                    _secondTimer = new Storyboard()
                    {
                        Duration = TimeSpan.FromSeconds(Culdaun)
                    };
                    _secondTimer.Completed += _secondTimer_Completed;
                    _secondTimer.Begin();

                    if (Paused)
                    {
                        Pause();
                    }

                    if (StartUseSpell != null)
                    {
                        StartUseSpell(this, null);
                    }

                    UnitGenerator.UpdatePlayerView(unit);
                }
                else
                ///Маны нету
                {
                }
            }
        }
Example #20
0
        public void UseSpall(Map map, Game_Object_In_Call obj, IUnit unit, object property)
        {
            _unit = unit;
            _map  = map;

            if (!_culdaunBool && !Paused)
            {
                ///Флаг кулдауна
                _culdaunBool = true;

                ///Тут кординаты ячеек в которых действует тучка
                List <Point> callsPoint = new List <Point>();
                ///Получаем ячейки которые находятся перед героем
                ///использывавшим тучку
                ///Сначала добавляем ячеку с героем
                callsPoint.Add(new Point(unit.PositionX, unit.PositionY));
                int xNew = unit.PositionX;
                int yNew = unit.PositionY;

                for (int i = 0; i <= _size; i++)
                {
                    xNew = xNew - 1;
                    callsPoint.Add(new Point(xNew, yNew));
                    callsPoint.Add(new Point(xNew, yNew + 1));
                    callsPoint.Add(new Point(xNew, yNew - 1));
                }
                xNew = unit.PositionX;
                yNew = unit.PositionY;
                for (int i = 0; i <= _size; i++)
                {
                    xNew = xNew + 1;
                    callsPoint.Add(new Point(xNew, yNew));
                    callsPoint.Add(new Point(xNew, yNew + 1));
                    // callsPoint.Add(new Point(xNew, yNew + 2));
                    callsPoint.Add(new Point(xNew, yNew - 1));
                    //  callsPoint.Add(new Point(xNew, yNew - 2));
                }
                xNew = unit.PositionX;
                yNew = unit.PositionY;
                for (int i = 0; i <= _size; i++)
                {
                    yNew = yNew - 1;
                    callsPoint.Add(new Point(xNew, yNew));
                    if (i != 0)
                    {
                        callsPoint.Add(new Point(xNew + 1, yNew));
                        callsPoint.Add(new Point(xNew - 1, yNew));
                    }
                }
                xNew = unit.PositionX;
                yNew = unit.PositionY;
                for (int i = 0; i <= _size; i++)
                {
                    yNew = yNew + 1;
                    callsPoint.Add(new Point(xNew, yNew));
                    if (i != 0)
                    {
                        callsPoint.Add(new Point(xNew + 1, yNew));
                        callsPoint.Add(new Point(xNew - 1, yNew));
                    }
                }

                ///Кординаты ячеек есть
                ///теперь спауним тучку
                foreach (var item in callsPoint)
                {
                    Map_Cell call = map.Calls.FirstOrDefault(p => p.IndexLeft == item.X && p.IndexTop == item.Y);
                    if (call != null &&
                        !call.Block)
                    {
                        ///Создаем визуальный объект тучка
                        // UC_Alchemist_AcidSpray acidSpray = new UC_Alchemist_AcidSpray();
                        //  acidSpray.ChengAngel(unit.Angel);
                        for (int i = 0; i < call.IUnits.Count; i++)
                        {
                            var itemUnit = call.IUnits[i];
                            if (itemUnit != null && itemUnit.GroupType != _unit.GroupType)
                            {
                                //item.GatDamage(_bullet.DemagePhys, _bullet.DemageMagic, _bullet.DemagePure, _unit);

                                Buff buff = itemUnit.Buffs.FirstOrDefault(p => p.Name == "AssaultCuirass");
                                if (buff != null)
                                {
                                    buff.Duration = 2;
                                }
                                else
                                {
                                    Buff alchBuff = new Buff()
                                    {
                                        MinusArmor = _minusArmor,
                                        Duration   = 2,
                                        Name       = "AssaultCuirass"
                                    };
                                    itemUnit.UseBuff(alchBuff);
                                }
                            }
                            else if (itemUnit != null && itemUnit.GroupType == _unit.GroupType)
                            {
                                Buff buff = itemUnit.Buffs.FirstOrDefault(p => p.Name == "AssaultCuirassPositive");
                                if (buff != null)
                                {
                                    buff.Duration = 2;
                                }
                                else
                                {
                                    Buff alchBuff = new Buff()
                                    {
                                        Armor       = _armor,
                                        AttackSpeed = _attackSpeed,
                                        Duration    = 2,
                                        Name        = "AssaultCuirassPositive"
                                    };
                                    itemUnit.UseBuff(alchBuff);
                                }
                            }
                        }
                    }
                }

                if (StartUseSpell != null)
                {
                    StartUseSpell(this, null);
                }

                ///Таймер кулдауна заклинания
                _firstTimer = new Storyboard()
                {
                    Duration = TimeSpan.FromSeconds(Culdaun)
                };
                _firstTimer.Completed += _firstTimer_Completed;
                _firstTimer.Begin();

                if (Paused)
                {
                    Pause();
                }

                UnitGenerator.UpdatePlayerView(unit);
            }
        }
Example #21
0
        public void UseSpall(Map map, Game_Object_In_Call obj, IUnit unit, object property)
        {
            bool upSpell = UnitGenerator.UpPlayerSpell(unit, this);

            _unit = unit;
            if (unit.UnitFrozen == false &&
                !_culdaunBool && LevelCast != 0 && !upSpell && !unit.Silenced &&
                !unit.Hexed &&
                !Paused)
            {
                if (unit.Mana >= ManaCost)
                ///Проверка есть ли мана на каст
                {
                    ///Флаг кулдауна
                    _culdaunBool = true;

                    ///Отнимаем нужное количество
                    unit.Mana -= ManaCost;

                    ///Тут кординаты ячеек в которых действует тучка
                    List <Point> callsPoint = new List <Point>();
                    ///Получаем ячейки которые находятся перед героем
                    int xNew = unit.PositionX;
                    int yNew = unit.PositionY;
                    if (unit.Angel == EAngel.Left)
                    {
                        xNew = xNew - 1;
                        callsPoint.Add(new Point(xNew, yNew));
                        callsPoint.Add(new Point(xNew, yNew + 2));
                        callsPoint.Add(new Point(xNew, yNew - 2));
                    }
                    else if (unit.Angel == EAngel.Right)
                    {
                        xNew = xNew + 1;
                        callsPoint.Add(new Point(xNew, yNew));
                        callsPoint.Add(new Point(xNew, yNew + 2));
                        callsPoint.Add(new Point(xNew, yNew - 2));
                    }
                    else if (unit.Angel == EAngel.Top)
                    {
                        yNew = yNew - 1;
                        callsPoint.Add(new Point(xNew, yNew));
                        callsPoint.Add(new Point(xNew + 2, yNew));
                        callsPoint.Add(new Point(xNew - 2, yNew));
                    }
                    else if (unit.Angel == EAngel.Bottom)
                    {
                        yNew = yNew + 1;
                        callsPoint.Add(new Point(xNew, yNew));
                        callsPoint.Add(new Point(xNew + 2, yNew));
                        callsPoint.Add(new Point(xNew - 2, yNew));
                    }

                    ///Кординаты ячеек есть
                    ///теперь спауним тучку
                    foreach (var item in callsPoint)
                    {
                        Map_Cell call = map.Calls.FirstOrDefault(p => p.IndexLeft == item.X && p.IndexTop == item.Y);
                        if (call != null &&
                            !call.Block)
                        {
                            ///Создаем визуальный объект тучка
                            UC_Jinx_Flame_Chompers acidSpray = new UC_Jinx_Flame_Chompers();
                            acidSpray.ChengAngel(unit.Angel);

                            Bullet bullAcidSpray = new Bullet()
                            {
                                Name = "Jinx_Flame_Chompers"
                            };
                            bullAcidSpray.GameObject = new Game_Object_In_Call()
                            {
                                EnumCallType = EnumCallType.Bullet,
                                View         = acidSpray
                            };
                            bullAcidSpray.UnitUsed  = unit;
                            bullAcidSpray.PositionX = (int)item.X;
                            bullAcidSpray.PositionY = (int)item.Y;
                            bullAcidSpray.Speed     = Speed;
                            bullAcidSpray.IsRoket   = true;
                            ///Магический урон зависит от прокача стрел
                            ///bullArrow.DemageMagic = 5 * (int)property;

                            if (LevelCast == 1)
                            {
                                bullAcidSpray.DemageMagic  = 15;
                                bullAcidSpray.StunDuration = 2;
                            }
                            else if (LevelCast == 2)
                            {
                                bullAcidSpray.DemageMagic  = 25;
                                bullAcidSpray.StunDuration = 2;
                            }
                            else if (LevelCast == 3)
                            {
                                bullAcidSpray.DemageMagic  = 35;
                                bullAcidSpray.StunDuration = 3;
                            }

                            bullAcidSpray.CurrentMap = map;
                            bullAcidSpray.Angel      = unit.Angel;
                            bullAcidSpray.Range      = _unit.Range;
                            bullAcidSpray.Duration   = Duration;

                            bullAcidSpray.Spells.Add(new SPB_Jinx_Flame_Chompers()
                            {
                                Name = "Jinx_Flame_Chompers"
                            });

                            ///И его же добавим в масив всех объектов
                            map.GameObjectInCall.Add(bullAcidSpray.GameObject);

                            Canvas.SetLeft(bullAcidSpray.GameObject.View, bullAcidSpray.PositionX * 50);
                            Canvas.SetTop(bullAcidSpray.GameObject.View, bullAcidSpray.PositionY * 50);
                            ///Отображение
                            map.MapCanvas.Children.Add(bullAcidSpray.GameObject.View);
                            _animationControl = (bullAcidSpray.GameObject.View as IAnimationControl);
                            _animationControl.StartMuveAnimation(0);

                            bullAcidSpray.UseSpall("Jinx_Flame_Chompers");
                        }
                    }

                    if (StartUseSpell != null)
                    {
                        StartUseSpell(this, null);
                    }

                    ///Таймер кулдауна заклинания
                    _firstTimer = new Storyboard()
                    {
                        Duration = TimeSpan.FromSeconds(Culdaun)
                    };
                    _firstTimer.Completed += _firstTimer_Completed;
                    _firstTimer.Begin();


                    if (Paused)
                    {
                        Pause();
                    }



                    UnitGenerator.UpdatePlayerView(unit);
                }
            }

            if (unit.UnitFrozen == false && ///Проверка не в стане ли юнит
                !Paused)
            {
                Map_Cell unitCall = map.Calls.FirstOrDefault(p => p.IndexLeft == unit.PositionX && p.IndexTop == unit.PositionY);
                ///Может тучка была кинута, тогда можно атаковать
                if (unitCall.Bullet.Any(p => p.Name == "SP_Alchemist_AcidSpray" && p.UnitUsed == unit) &&
                    !CuldaunBoolAttack)
                {
                    Point    attackCallPoint = UnitGenerator.AngelCallPoint(unit.Angel, unit.PositionX, unit.PositionY);
                    Map_Cell attackCallCall  = map.Calls.FirstOrDefault(p => p.IndexLeft == attackCallPoint.X && p.IndexTop == attackCallPoint.Y);
                    ///Если на против юнита есть ячейка куда атаковать
                    if (attackCallCall != null && !attackCallCall.Block && attackCallCall.IUnits.Any())
                    {
                        ///Флаг кулдауна
                        CuldaunBoolAttack = true;


                        Bullet bullet = new Bullet()
                        {
                            UnitUsed   = unit,
                            DemagePhys = unit.Demage
                        };
                        UnitGenerator.MKB_Bush(bullet, unit);

                        UnitGenerator.AddDamage(attackCallCall, bullet);
                        (unit.GameObject.View as IGameControl).ShowAttack(unit.Angel, unit.AttackSpeed);

                        _secondTimer = new Storyboard()
                        {
                            Duration = TimeSpan.FromSeconds(unit.AttackSpeed)
                        };
                        _secondTimer.Completed += _secondTimer_Completed;
                        _secondTimer.Begin();

                        if (Paused)
                        {
                            Pause();
                        }
                    }
                }
            }
        }
Example #22
0
        /// <summary>
        /// Бони к съедает крипа и получает бонус к максимальному здоровю и
        /// урону
        /// </summary>
        /// <param name="property">Множетель прироста здоровъя и урона масив double 2 элемента
        /// 0 - множетель на здорове, 1 - на урон</param>
        public void UseSpall(Map map, Game_Object_In_Call obj, IUnit unit, object property)
        {
            _unit   = unit;
            _player = _unit as Player;

            bool upSpell = UnitGenerator.UpPlayerSpell(unit, this);

            /// Если есть аганим
            if (UnitGenerator.HasAghanim(unit))
            {
                /// То ульт у боника работает столько же сколько и кулдаун спела
                _culdaun = _duration;
            }


            if (unit.UnitFrozen == false &&
                !_culdaunBool && LevelCast != 0 && !upSpell && !unit.Silenced &&
                !unit.Hexed)
            {
                if (unit.Mana >= ManaCost)
                ///Проверка есть ли мана на каст
                {
                    ///Получаем клеточку перед боником
                    Point newPos = UnitGenerator.NewX_NewY(unit);

                    if (map.Calls.Any(p => p.IndexLeft == newPos.X && p.IndexTop == newPos.Y))
                    {
                        var call = map.Calls.Single(p => p.IndexLeft == newPos.X && p.IndexTop == newPos.Y);
                        ///Теперь проверим содержит ли колонка юнит который можно съесть
                        if (call.IUnits.Any(p => p.GameObject.EnumCallType == EnumCallType.UnitBlock ||
                                            p.GameObject.EnumCallType == EnumCallType.Unit && p.UnitType != EUnitType.Boss))
                        {
                            ///Флаг кулдауна
                            _culdaunBool = true;

                            ///Отнимаем нужное количество
                            unit.Mana -= ManaCost;

                            ///Берем первого попавшегося юнита
                            IUnit unitCrush = call.IUnits.FirstOrDefault(p => p.GameObject.EnumCallType == EnumCallType.UnitBlock ||
                                                                         p.GameObject.EnumCallType == EnumCallType.Unit);
                            ///Юнит который подвергся спелу унечтожен
                            unitCrush.RemoveUnit(unit);

                            double[] prop = new double[] { 1, 0.3 };

                            _oldMaxHelth = unit.OrijHealth;
                            int healBonus = (int)(unitCrush.Health * prop[0]);
                            if (healBonus > 150)
                            {
                                healBonus = 150;
                            }

                            unit.OrijHealth = unit.OrijHealth + healBonus;
                            unit.Health     = unit.Health + healBonus;

                            _adddDamage = (int)(unitCrush.Health * prop[1]);

                            if (_adddDamage > 50)
                            {
                                _adddDamage = 50;
                            }

                            unit.DemageItem = unit.DemageItem + _adddDamage;

                            if (_player != null)
                            {
                                (_player.GameObject.View as UC_Player).ShowEffect(4, true);
                            }

                            _firstTimer = new Storyboard()
                            {
                                Duration = TimeSpan.FromSeconds(Duration)
                            };
                            _firstTimer.Completed += mouveTimer_Tick;
                            _firstTimer.Begin();

                            _secondTimer = new Storyboard()
                            {
                                Duration = TimeSpan.FromSeconds(Culdaun)
                            };
                            _secondTimer.Completed += mouveTimerCuldaun_Tick;
                            _secondTimer.Begin();

                            if (Paused)
                            {
                                Pause();
                            }

                            if (StartUseSpell != null)
                            {
                                StartUseSpell(this, null);
                            }
                        }
                    }
                    UnitGenerator.UpdatePlayerView(unit);
                }
            }
        }
Example #23
0
        public void UseSpall(Map map, Game_Object_In_Call obj, IUnit unit, object property)
        {
            bool upSpell = UnitGenerator.UpPlayerSpell(unit, this);

            if (unit.UnitFrozen == false &&
                !_culdaunBool && LevelCast != 0 &&
                !upSpell && !unit.Silenced &&
                !unit.Hexed &&
                !Paused)
            {
                if (unit.Mana >= ManaCost)
                ///Проверка есть ли мана на каст
                {
                    int lifeTime    = 10;
                    int trentHealth = 5;
                    int trentArmor  = 0;
                    int trentDamage = 0;

                    if (LevelCast == 1)
                    {
                        _culdaun    = 9;
                        trentHealth = 5;
                        lifeTime    = 10;
                        trentArmor  = 0;
                        trentDamage = 0;
                    }
                    else if (LevelCast == 2)
                    {
                        _culdaun    = 7;
                        trentHealth = 5;
                        lifeTime    = 15;
                        trentArmor  = 2;
                        trentDamage = 5;

                        ManaCost = 35;
                    }
                    else if (LevelCast == 3)
                    {
                        _culdaun    = 6;
                        trentHealth = 5;
                        lifeTime    = 21;
                        trentDamage = 10;
                        trentArmor  = 4;
                        ManaCost    = 40;
                    }

                    ///Метод проверки вернет ячейку в которой произошло столкновение
                    Map_Cell call = UnitGenerator.FiratCollisionOnlyGrass(unit.PositionX, unit.PositionY,
                                                                          unit.Range, map, unit.Angel);

                    _culdaunBool = true;
                    _unit        = unit;
                    ///Отнимаем нужное количество
                    unit.Mana -= ManaCost;

                    if (call != null)
                    ///Произошло попадение
                    {
                        IUnit grass = call.IUnits.FirstOrDefault(p => p.UnitType == EUnitType.Grass);
                        grass.GatDamage(grass.Health * 2, 0, 0, grass);

                        Unit trent = UnitGenerator.M_Trent(call.IndexLeft, call.IndexTop, map, _unit as Player);
                        map.CreateObjectUnitInCall(call, trent);
                        trent.Health  = trent.Health + trentHealth;
                        trent.Demage += trentDamage;
                        trent.Arrmor += trentArmor;

                        trent.AI.Farm = true;
                        trent.AI.Hunt = true;
                        trent.LifeTime(lifeTime);

                        trent.AI.StartAI();
                    }
                    else
                    {
                        (unit.GameObject.View as IGameControl).GetDemage("Miss");
                    }

                    ///Кулдаун
                    _secondTimer = new Storyboard()
                    {
                        Duration = TimeSpan.FromSeconds(Culdaun)
                    };
                    _secondTimer.Completed += _secondTimer_Completed;
                    _secondTimer.Begin();

                    if (Paused)
                    {
                        Pause();
                    }

                    if (StartUseSpell != null)
                    {
                        StartUseSpell(this, null);
                    }
                    UnitGenerator.UpdatePlayerView(unit);
                }
            }
        }
Example #24
0
        public void UseSpall(Map map, Game_Object_In_Call obj, IUnit unit, object property)
        {
            if (unit.UnitFrozen == false &&
                !_culdaunBool && LevelCast != 0 &&
                !unit.Hexed)
            {
                if (unit.Mana >= ManaCost)
                ///Проверка есть ли мана на каст
                {
                    ///Проверка диагонали по которой будет запущено сало
                    ///метод проверки вернет ячейку в которой произошло столкновение
                    Map_Cell call = UnitGenerator.FiratCollision(unit.PositionX, unit.PositionY, map, unit.Angel);

                    _culdaunBool = true;
                    _unit        = unit;
                    ///Отнимаем нужное количество
                    unit.Mana -= ManaCost;

                    if (call != null)
                    ///Произошло попадение
                    {
                        _silencedUnits = new List <IUnit>();
                        _saveDemage    = new List <int>();

                        foreach (var item in call.IUnits)
                        {
                            if (!item.Silenced)
                            {   ///Если на целе не наложен эфект сайленса
                                item.Silenced        = true;
                                item.GetDemageEvent += item_GetDemageEvent;
                                _silencedUnits.Add(item);
                                _saveDemage.Add(0);
                            }
                        }

                        ///Время действия
                        _firstTimer = new Storyboard()
                        {
                            Duration = TimeSpan.FromSeconds(Duration)
                        };
                        _firstTimer.Completed += _firstTimer_Completed;
                        _firstTimer.Begin();
                    }
                    else
                    {
                        (unit.GameObject.View as IGameControl).GetDemage("Miss");
                    }

                    ///Кулдаун
                    _secondTimer = new Storyboard()
                    {
                        Duration = TimeSpan.FromSeconds(Culdaun)
                    };
                    _secondTimer.Completed += _secondTimer_Completed;
                    _secondTimer.Begin();

                    if (Paused)
                    {
                        Pause();
                    }

                    if (StartUseSpell != null)
                    {
                        StartUseSpell(this, null);
                    }
                    UnitGenerator.UpdatePlayerView(unit);
                }
            }
        }
Example #25
0
        public void UseSpall(Map map, Game_Object_In_Call obj, IUnit unit, object property)
        {
            bool upSpell = UnitGenerator.UpPlayerSpell(unit, this);

            _unit = unit;
            _map  = map;

            if (LevelCast == 1)
            {
                ManaCost = 10;
            }
            else if (LevelCast == 2)
            {
                ManaCost = 13;
            }
            else if (LevelCast == 3)
            {
                ManaCost = 15;
            }

            if (unit.UnitFrozen == false &&
                !_culdaunBool && LevelCast != 0 && !upSpell && !unit.Silenced &&
                !unit.Hexed &&
                !Paused)
            {
                if (unit.Mana >= ManaCost)
                ///Проверка есть ли мана на каст
                {
                    if (!_unit.Buffs.Any(p => p.Name == "SP_Mirana_MoonlightShadow"))
                    {
                        Culdaun = 5;
                    }
                    else
                    {
                        Culdaun = 4;
                    }

                    ///Флаг кулдауна
                    _culdaunBool = true;

                    ///Отнимаем нужное количество
                    unit.Mana -= ManaCost;
                    _map       = map;

                    ///Тут кординаты ячеек в которые упадут звездочки
                    _callsPointl = new List <Point>();
                    Starfall(map, unit);

                    _attackView = new List <UC_Mirana_Starstorm>();
                    _removeFire = false;
                    AttackUnits(map, unit, true);

                    ///Таймер второго дыхания, замедляющего
                    _secondTimer = new Storyboard()
                    {
                        Duration = TimeSpan.FromSeconds(0.5)
                    };
                    _secondTimer.Completed += _secondTimer_Completed;
                    _secondTimer.Begin();

                    /// Если есть аганим
                    if (UnitGenerator.HasAghanim(unit))
                    {
                        ///Таймер второго дыхания, замедляющего
                        _therdTimer = new Storyboard()
                        {
                            Duration = TimeSpan.FromSeconds(1.25)
                        };
                        _therdTimer.Completed += _therdTimer_Completed;;
                        _therdTimer.Begin();
                    }

                    if (StartUseSpell != null)
                    {
                        StartUseSpell(this, null);
                    }

                    ///Таймер кулдауна заклинания
                    _firstTimer = new Storyboard()
                    {
                        Duration = TimeSpan.FromSeconds(Culdaun)
                    };
                    _firstTimer.Completed += _firstTimer_Completed;
                    _firstTimer.Begin();


                    if (Paused)
                    {
                        Pause();
                    }

                    UnitGenerator.UpdatePlayerView(unit);
                }
            }
        }
Example #26
0
        /// <summary>
        /// Запуск стрелы
        /// </summary>
        public void UseSpall(Map map, Game_Object_In_Call obj, IUnit unit, object property)
        {
            _unit = unit;
            _map  = map;
            bool upSpell = UnitGenerator.UpPlayerSpell(unit, this);

            if (unit.UnitFrozen == false &&
                !_culdaunBool && LevelCast != 0 &&
                !upSpell && !unit.Silenced &&
                !unit.Hexed &&
                !Paused)
            {
                if (unit.Mana >= ManaCost)
                ///Проверка есть ли мана на каст
                {
                    ///Флаг кулдауна
                    _culdaunBool = true;
                    ///Отнимаем нужное количество
                    unit.Mana -= ManaCost;

                    if (LevelCast == 1)
                    {
                        _bonusSpeed       = 0.05;
                        _bonusAttackSpeed = 0.04;
                        _culdaun          = 15;
                        _size             = 2;
                    }
                    else if (LevelCast == 2)
                    {
                        _bonusSpeed       = 0.075;
                        _bonusAttackSpeed = 0.08;
                        _culdaun          = 14;
                        _size             = 2;
                    }
                    else if (LevelCast == 3)
                    {
                        _bonusSpeed       = 0.1;
                        _bonusAttackSpeed = 0.12;
                        _culdaun          = 12;
                        _size             = 3;
                    }

                    if (!_unit.Buffs.Any(p => p.Name == "SP_Mirana_MoonlightShadow"))
                    {
                        Duration = 7;
                    }
                    else
                    {
                        Duration = 10;
                    }


                    _unit.OrijSpeed -= _bonusSpeed;

                    ///Бонусная скорость атаки
                    _unit.OrijAttackSpeed -= _bonusAttackSpeed;

                    ///Выбираем клетку куда прыгнуть
                    ///Тут кординаты ячеек в которых действует тучка
                    _callsPoints = new List <Point>();
                    ///Получаем ячейки которые находятся перед героем
                    ///использывавшим тучку
                    ///Сначала добавляем ячеку с героем
                    int xNew = unit.PositionX;
                    int yNew = unit.PositionY;
                    if (unit.Angel == EAngel.Left)
                    {
                        for (int i = 0; i <= _size; i++)
                        {
                            xNew = xNew - 1;
                            if (!_unit.Buffs.Any(p => p.Name == "SP_Mirana_MoonlightShadow"))
                            {
                                Map_Cell call = map.Calls.FirstOrDefault(p => p.IndexLeft == xNew && p.IndexTop == yNew);
                                if (call == null || call != null && call.Block)
                                {
                                    break;
                                }
                            }
                            _callsPoints.Add(new Point(xNew, yNew));
                        }
                    }
                    else if (unit.Angel == EAngel.Right)
                    {
                        for (int i = 0; i <= _size; i++)
                        {
                            xNew = xNew + 1;
                            if (!_unit.Buffs.Any(p => p.Name == "SP_Mirana_MoonlightShadow"))
                            {
                                Map_Cell call = map.Calls.FirstOrDefault(p => p.IndexLeft == xNew && p.IndexTop == yNew);
                                if (call == null || call != null && call.Block)
                                {
                                    break;
                                }
                            }
                            _callsPoints.Add(new Point(xNew, yNew));
                        }
                    }
                    else if (unit.Angel == EAngel.Top)
                    {
                        for (int i = 0; i <= _size; i++)
                        {
                            yNew = yNew - 1;
                            if (!_unit.Buffs.Any(p => p.Name == "SP_Mirana_MoonlightShadow"))
                            {
                                Map_Cell call = map.Calls.FirstOrDefault(p => p.IndexLeft == xNew && p.IndexTop == yNew);
                                if (call == null || call != null && call.Block)
                                {
                                    break;
                                }
                            }
                            _callsPoints.Add(new Point(xNew, yNew));
                        }
                    }
                    else if (unit.Angel == EAngel.Bottom)
                    {
                        for (int i = 0; i <= _size; i++)
                        {
                            yNew = yNew + 1;
                            if (!_unit.Buffs.Any(p => p.Name == "SP_Mirana_MoonlightShadow"))
                            {
                                Map_Cell call = map.Calls.FirstOrDefault(p => p.IndexLeft == xNew && p.IndexTop == yNew);
                                if (call == null || call != null && call.Block)
                                {
                                    break;
                                }
                            }
                            _callsPoints.Add(new Point(xNew, yNew));
                        }
                    }

                    _activeCall = null;
                    _callsPoints.Reverse();
                    ///Выбираем ячейку куда прыгать
                    foreach (var item in _callsPoints)
                    {
                        _activeCall = map.Calls.FirstOrDefault(p => p.IndexLeft == item.X && p.IndexTop == item.Y);
                        if (_activeCall != null &&
                            !_activeCall.Block &&
                            !_activeCall.Used &&
                            !_activeCall.Using)
                        {
                            ///Прыгаем, в первую дальнюю ячейку
                            _activeCall.Using = true;
                            break;
                        }
                    }
                    if (_activeCall != null)
                    {
                        _unit.UnitFrozen = true;

                        string animationType = "(Canvas.Left)";
                        double mouvePos      = 0;
                        ///Новая позиция
                        double newPos = 0;

                        if (unit.Angel == EAngel.Left || unit.Angel == EAngel.Right)
                        {
                            animationType = "(Canvas.Left)";
                            mouvePos      = Canvas.GetLeft(unit.GameObject.View);
                            newPos        = _activeCall.IndexLeft;
                        }
                        else
                        {
                            animationType = "(Canvas.Top)";
                            mouvePos      = Canvas.GetTop(unit.GameObject.View);
                            newPos        = _activeCall.IndexTop;
                        }

                        _storyboard = new Storyboard();
                        var animation = new DoubleAnimation
                        {
                            From     = mouvePos,
                            To       = newPos * 50,
                            Duration = TimeSpan.FromSeconds(0.3)
                        };
                        _storyboard.Children.Add(animation);
                        Storyboard.SetTargetProperty(animation, animationType);
                        Storyboard.SetTarget(_storyboard, unit.GameObject.View);
                        _storyboard.Completed += _storyboard_Completed;
                        _storyboard.Begin();
                    }
                    ///Таймер время действия
                    _firstTimer = new Storyboard()
                    {
                        Duration = TimeSpan.FromSeconds(Duration)
                    };
                    _firstTimer.Completed += _firstTimer_Completed;
                    _firstTimer.Begin();

                    ///Таймер кулдауна заклинания
                    _secondTimer = new Storyboard()
                    {
                        Duration = TimeSpan.FromSeconds(Culdaun)
                    };
                    _secondTimer.Completed += _secondTimer_Completed;
                    _secondTimer.Begin();

                    if (Paused)
                    {
                        Pause();
                    }

                    if (StartUseSpell != null)
                    {
                        StartUseSpell(this, null);
                    }

                    UnitGenerator.UpdatePlayerView(unit);
                }
                else
                ///Маны нету
                {
                }
            }
        }
Example #27
0
        public void UseSpall(Map map, Game_Object_In_Call obj, IUnit unit, object property)
        {
            bool upSpell = UnitGenerator.UpPlayerSpell(unit, this);

            if (unit.UnitFrozen == false &&
                !_culdaunBool && LevelCast != 0 && !upSpell &&
                !unit.Silenced &&
                !unit.Hexed)
            {
                if (unit.Mana >= ManaCost)
                ///Проверка есть ли мана на каст
                {
                    ///Флаг кулдауна
                    _culdaunBool  = true;
                    _spellStopped = false;

                    ///Отнимаем нужное количество
                    unit.Mana -= ManaCost;
                    _unit      = unit;

                    ///Проверка не собъет ли какойто каст нам инвиз
                    foreach (var item in unit.Spells)
                    {
                        if (item.GetType() != typeof(SP_InvisibilitiSpeed))
                        {
                            item.StartUseSpell += item_StartUseSpell;
                        }
                    }

                    unit.GameObject.View.Opacity = 0.25;
                    unit.Invisibility            = true;

                    _speed          = unit.Speed / 2.5;
                    unit.OrijSpeed -= _speed;

                    /// lvl 1 - 4 - 10
                    /// lvl 2 - 5 - 9
                    /// lvl 3 - 6 - 8
                    if (LevelCast == 1)
                    {
                        Duration = 4;
                        Culdaun  = 10;
                    }
                    else if (LevelCast == 2)
                    {
                        Duration = 5;
                        Culdaun  = 9;
                    }
                    else if (LevelCast == 3)
                    {
                        Duration = 6;
                        Culdaun  = 8;
                    }

                    _firstTimer = new Storyboard()
                    {
                        Duration = TimeSpan.FromSeconds(Duration)
                    };
                    _firstTimer.Completed += mouveTimer_Tick;
                    _firstTimer.Begin();

                    _secondTimer = new Storyboard()
                    {
                        Duration = TimeSpan.FromSeconds(Culdaun)
                    };
                    _secondTimer.Completed += mouveTimerCuldaun_Tick;
                    _secondTimer.Begin();

                    if (Paused)
                    {
                        Pause();
                    }

                    if (StartUseSpell != null)
                    {
                        StartUseSpell(this, null);
                    }
                    UnitGenerator.UpdatePlayerView(unit);
                }
            }
        }
Example #28
0
        /// <summary>
        /// Перемещение юнита
        /// </summary>
        /// <param name="map">Карта</param>
        /// <param name="obj">нет</param>
        /// <param name="unit">Кто перемещается</param>
        /// <param name="property"></param>
        public void UseSpall(Map map, Game_Object_In_Call obj, IUnit unit, object property)
        {
            UnitGenerator.UpdatePlayerView(unit);
            if (unit.UnitFrozen == false && !CuldaunBool)
            {
                CuldaunBool = true;
                EAngel ang = (EAngel)property;
                _map  = map;
                _unit = unit;
                ///Проверим в какую сторону смотрит юнит, может его нужно просто развернуть
                ///а не перемещать
                if (unit.Angel == ang)
                {///Можно перемещать
                    Rotation = false;

                    int xNew = 0;
                    int yNew = 0;
                    if (unit.Angel == EAngel.Left)
                    {
                        xNew = unit.PositionX - 1;
                        yNew = unit.PositionY;
                    }
                    else if (unit.Angel == EAngel.Right)
                    {
                        xNew = unit.PositionX + 1;
                        yNew = unit.PositionY;
                    }
                    else if (unit.Angel == EAngel.Top)
                    {
                        xNew = unit.PositionX;
                        yNew = unit.PositionY - 1;
                    }
                    else if (unit.Angel == EAngel.Bottom)
                    {
                        xNew = unit.PositionX;
                        yNew = unit.PositionY + 1;
                    }


                    ///Теперь проверка можно ли переместится в данную ячейку
                    if (map.AllowMoveUnit(unit, xNew, yNew))
                    {   ///Можно
                        _invisMuve = unit.Invisibility;

                        ///Отмечаем что в заданную ячейку идет перемещение юнита
                        map.Calls.Single(p => p.IndexLeft == xNew && p.IndexTop == yNew).Using = true;
                        //  unit.UnitFrozen = true;
                        _xNew = xNew;
                        _yNew = yNew;

                        ///Сохраняем ячейку с которой был выполнен переход
                        UnitGenerator.EditWay(map.Calls.Single(p => p.IndexLeft == unit.PositionX &&
                                                               p.IndexTop == unit.PositionY), _unit);

                        ///Запуск анимации перемещения
                        StartStoryboard(unit, xNew, yNew);
                    }
                    else
                    {
                        CuldaunBool = false;

                        if (CompletedUseSpell != null)
                        {
                            CompletedUseSpell(this, null);
                        }
                    }
                }
                else
                {///Только развернуть
                    IGameControl contrGame = unit.GameObject.View as IGameControl;
                    unit.Angel = ang;
                    contrGame.ChengAngel(ang);
                    Rotation = true;

                    CuldaunBool = false;

                    if (CompletedUseSpell != null)
                    {
                        CompletedUseSpell(this, null);
                    }
                }
            }
            else if (CompletedUseSpell != null)
            {
                CompletedUseSpell(this, null);
            }
        }
Example #29
0
        public void UseSpall(Map map, Game_Object_In_Call obj, IUnit unit, object property)
        {
            bool upSpell = UnitGenerator.UpPlayerSpell(unit, this);

            if (unit.UnitFrozen == false &&
                !_culdaunBool && LevelCast != 0 && !upSpell &&
                !unit.Silenced &&
                !unit.Hexed)
            {
                if (unit.Mana >= ManaCost)
                ///Проверка есть ли мана на каст
                {
                    ///Флаг кулдауна
                    _culdaunBool = true;

                    ///Отнимаем нужное количество
                    unit.Mana -= ManaCost;
                    _unit      = unit;

                    foreach (var item in unit.Spells)
                    {
                        if (item.GetType() == typeof(SP_FireArrow))
                        {
                            SP_FireArrow arrowSpell = (SP_FireArrow)item;
                            _oldCuldaun        = arrowSpell.Culdaun;
                            arrowSpell.Culdaun = arrowSpell.Culdaun / 3;
                        }
                    }

                    _unit.AttackSpeed = _unit.OrijAttackSpeed / 2;


                    /// lvl 1 - 3 - 15
                    /// lvl 2 - 5 - 15
                    /// lvl 3 - 6 - 14
                    if (LevelCast == 1)
                    {
                        Duration = 3;
                        Culdaun  = 15;
                    }
                    else if (LevelCast == 2)
                    {
                        Duration = 5;
                        Culdaun  = 15;
                    }
                    else if (LevelCast == 3)
                    {
                        Duration = 6;
                        Culdaun  = 14;
                    }

                    _firstTimer = new Storyboard()
                    {
                        Duration = TimeSpan.FromSeconds(Duration)
                    };
                    _firstTimer.Completed += mouveTimer_Tick;
                    _firstTimer.Begin();

                    _secondTimer = new Storyboard()
                    {
                        Duration = TimeSpan.FromSeconds(Culdaun)
                    };
                    _secondTimer.Completed += mouveTimerCuldaun_Tick;
                    _secondTimer.Begin();

                    if (Paused)
                    {
                        Pause();
                    }

                    if (StartUseSpell != null)
                    {
                        StartUseSpell(this, null);
                    }
                    UnitGenerator.UpdatePlayerView(unit);
                }
            }
        }
Example #30
0
        public void UseSpall(Map map, Game_Object_In_Call obj, IUnit unit, object property)
        {
            bool upSpell = UnitGenerator.UpPlayerSpell(unit, this);

            _unit = unit;
            if (unit.UnitFrozen == false &&
                !_culdaunBool && LevelCast != 0 && !upSpell &&
                !unit.Silenced &&
                !unit.Hexed &&
                !Paused)
            {
                if (unit.Mana >= ManaCost)
                ///Проверка есть ли мана на каст
                {
                    ///Флаг кулдауна
                    _culdaunBool = true;

                    ///Отнимаем нужное количество
                    unit.Mana -= ManaCost;
                    _map       = map;

                    ///Тут кординаты ячеек в которых действует тучка
                    _callsPointl = new List <Point>();
                    ///Получаем ячейки которые находятся перед героем
                    ///использывавшим тучку
                    ///Сначала добавляем ячеку с героем
                    int xNew = unit.PositionX;
                    int yNew = unit.PositionY;
                    if (unit.Angel == EAngel.Left)
                    {
                        for (int i = 0; i <= _size; i++)
                        {
                            xNew = xNew - 1;
                            Map_Cell call = map.Calls.FirstOrDefault(p => p.IndexLeft == xNew && p.IndexTop == yNew);
                            if (call == null || call != null && call.Block)
                            {
                                break;
                            }
                            _callsPointl.Add(new Point(xNew, yNew));
                            if (_size == i)
                            {
                                _callsPointl.Add(new Point(xNew, yNew + 1));
                                _callsPointl.Add(new Point(xNew, yNew - 1));
                            }
                        }
                    }
                    else if (unit.Angel == EAngel.Right)
                    {
                        for (int i = 0; i <= _size; i++)
                        {
                            xNew = xNew + 1;
                            Map_Cell call = map.Calls.FirstOrDefault(p => p.IndexLeft == xNew && p.IndexTop == yNew);
                            if (call == null || call != null && call.Block)
                            {
                                break;
                            }
                            _callsPointl.Add(new Point(xNew, yNew));
                            if (_size == i)
                            {
                                _callsPointl.Add(new Point(xNew, yNew + 1));
                                _callsPointl.Add(new Point(xNew, yNew - 1));
                            }
                        }
                    }
                    else if (unit.Angel == EAngel.Top)
                    {
                        for (int i = 0; i <= _size; i++)
                        {
                            yNew = yNew - 1;
                            Map_Cell call = map.Calls.FirstOrDefault(p => p.IndexLeft == xNew && p.IndexTop == yNew);
                            if (call == null || call != null && call.Block)
                            {
                                break;
                            }
                            _callsPointl.Add(new Point(xNew, yNew));
                            if (_size == i)
                            {
                                _callsPointl.Add(new Point(xNew + 1, yNew));
                                _callsPointl.Add(new Point(xNew - 1, yNew));
                            }
                        }
                    }
                    else if (unit.Angel == EAngel.Bottom)
                    {
                        for (int i = 0; i <= _size; i++)
                        {
                            yNew = yNew + 1;
                            Map_Cell call = map.Calls.FirstOrDefault(p => p.IndexLeft == xNew && p.IndexTop == yNew);
                            if (call == null || call != null && call.Block)
                            {
                                break;
                            }
                            _callsPointl.Add(new Point(xNew, yNew));
                            if (_size == i)
                            {
                                _callsPointl.Add(new Point(xNew + 1, yNew));
                                _callsPointl.Add(new Point(xNew - 1, yNew));
                            }
                        }
                    }

                    if (!_callsPointl.Any())
                    {
                        (unit.GameObject.View as IGameControl).GetDemage("Miss");
                    }

                    _attackView = new List <UC_Jakiro_DualBreath>();
                    ///Кординаты ячеек есть
                    ///теперь спауним атаку
                    foreach (var item in _callsPointl)
                    {
                        Map_Cell call = map.Calls.FirstOrDefault(p => p.IndexLeft == item.X && p.IndexTop == item.Y);
                        if (call != null &&
                            !call.Block)
                        {
                            ///Создаем визуальный объект атака
                            UC_Jakiro_DualBreath dualBreath = new UC_Jakiro_DualBreath();
                            dualBreath.ChengAngel(unit.Angel);

                            _bullDualBreath = new Bullet()
                            {
                                Name = "SP_Jakiro_DualBreath"
                            };
                            _bullDualBreath.GameObject = new Game_Object_In_Call()
                            {
                                EnumCallType = EnumCallType.Bullet,
                                View         = dualBreath
                            };
                            _bullDualBreath.UnitUsed  = unit;
                            _bullDualBreath.PositionX = (int)item.X;
                            _bullDualBreath.PositionY = (int)item.Y;
                            _bullDualBreath.Speed     = Speed;
                            ///Магический урон зависит от прокача стрел
                            //bullArrow.DemageMagic = 5 * (int)property;

                            if (LevelCast == 1)
                            {
                                _bullDualBreath.DemageMagic = 16;
                            }
                            else if (LevelCast == 2)
                            {
                                _bullDualBreath.DemageMagic = 26;
                            }
                            else if (LevelCast == 3)
                            {
                                _bullDualBreath.DemageMagic = 36;
                            }
                            // _bullDualBreath.DemageMagic += unit.Demage/2;

                            _bullDualBreath.CurrentMap = map;
                            _bullDualBreath.Angel      = unit.Angel;
                            _bullDualBreath.Range      = _unit.Range;
                            _bullDualBreath.Duration   = Duration;
                            _bullDualBreath.SpeedSlow  = 0.5;

                            ///И его же добавим в масив всех объектов
                            //map.GameObjectInCall.Add(_bullDualBreath.GameObject);

                            Canvas.SetLeft(_bullDualBreath.GameObject.View, _bullDualBreath.PositionX * 50);
                            Canvas.SetTop(_bullDualBreath.GameObject.View, _bullDualBreath.PositionY * 50);
                            ///Отображение
                            map.MapCanvas.Children.Add(_bullDualBreath.GameObject.View);
                            _attackView.Add(dualBreath);
                            _animationControl = (_bullDualBreath.GameObject.View as IAnimationControl);
                            _animationControl.StartMuveAnimation(0);

                            UnitGenerator.AddDamage(call, _bullDualBreath);

                            _removeFire = false;
                        }
                    }

                    ///Таймер второго дыхания, замедляющего
                    _secondTimer = new Storyboard()
                    {
                        Duration = TimeSpan.FromSeconds(0.4)
                    };
                    _secondTimer.Completed += _secondTimer_Completed;
                    _secondTimer.Begin();


                    if (StartUseSpell != null)
                    {
                        StartUseSpell(this, null);
                    }

                    ///Таймер кулдауна заклинания
                    _firstTimer = new Storyboard()
                    {
                        Duration = TimeSpan.FromSeconds(Culdaun)
                    };
                    _firstTimer.Completed += _firstTimer_Completed;
                    _firstTimer.Begin();


                    if (Paused)
                    {
                        Pause();
                    }

                    UnitGenerator.UpdatePlayerView(unit);
                }
            }
        }