コード例 #1
0
        /// <summary>
        /// Remove Attack from UI and Attacks list
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnRemoveAttack_Click(object sender, RoutedEventArgs e)
        {
            if (lstAttacks.SelectedIndex > -1)
            {
                Attack        attack          = (Attack)lstAttacks.SelectedItem;
                List <Attack> attacksToRemove = new List <Attack>();

                if (attack.Trigger)
                {
                    foreach (Attack a in Attacks)
                    {
                        if (a.TriggeredBy != null && a.TriggeredBy.Name == attack.Name)
                        {
                            attacksToRemove.Add(a);
                        }
                    }
                }

                attacksToRemove.Add(attack);

                if (Attacks.Any(a => a.Name == attack.Name))
                {
                    attacksToRemove.Add(attack);
                }

                foreach (Attack a in attacksToRemove)
                {
                    Attacks.Remove(a);
                    UpdateAttacksUI();
                }
            }
        }
コード例 #2
0
    /// <summary>
    /// Check if the distance between the player and its target on the x axis is smaller than the minimum attack range
    /// Then check if the distance between the player and its target on the z axis is smaller than the agent's radius
    /// </summary>
    /// <returns></returns>
    protected override bool AttackCanBeCasted()
    {
        float _distance  = Mathf.Abs(transform.position.x - playerTarget.transform.position.x);
        bool  _canAttack = Attacks.Any(a => a != null && a.MaxRange >= _distance && a.MinRange <= _distance);

        if (!_canAttack)
        {
            return(false);
        }
        _canAttack = Attacks.Any(a => a.MinRange > 0) || Mathf.Abs(transform.position.z - playerTarget.transform.position.z) <= collider.size.z;

        ///
        if (_canAttack)
        {
            _canAttack = IsFacingRight ? transform.position.x <playerTarget.transform.position.x : transform.position.x> playerTarget.transform.position.x;
        }
        return(_canAttack);
    }
コード例 #3
0
        public void Initialize()
        {
            Clans = Clans.OrderBy(x => x.ClanTag).ToList();

            WarId = $"{PreparationStartTimeUtc};{Clans[0].ClanTag}";

            //ClanTag1 = Clans.First().ClanTag;

            Flags.WarId = WarId;

            TimeSpan timeSpan = StartTimeUtc - PreparationStartTimeUtc;

            if (timeSpan.TotalHours == 24 ||
                timeSpan.TotalHours == 20 ||
                timeSpan.TotalHours == 16 ||
                timeSpan.TotalHours == 12 ||
                timeSpan.TotalHours == 8 ||
                timeSpan.TotalHours == 6 ||
                timeSpan.TotalHours == 4 ||
                timeSpan.TotalHours == 2 ||
                timeSpan.TotalHours == 1 ||
                timeSpan.TotalMinutes == 30 ||
                timeSpan.TotalMinutes == 15)
            {
                WarType = WarType.Friendly;
            }

            if (WarIsOverOrAllAttacksUsed())
            {
                if (Clans[0].Stars == Clans[1].Stars)
                {
                    if (Clans[0].DestructionPercentage == Clans[1].DestructionPercentage)
                    {
                        Clans[0].Result = Result.Draw;
                        Clans[1].Result = Result.Draw;
                    }
                    else if (Clans[0].DestructionPercentage > Clans[1].DestructionPercentage)
                    {
                        Clans[0].Result = Result.Win;
                        Clans[1].Result = Result.Lose;
                    }
                    else
                    {
                        Clans[0].Result = Result.Lose;
                        Clans[1].Result = Result.Win;
                    }
                }
                else if (Clans[0].Stars > Clans[1].Stars)
                {
                    Clans[0].Result = Result.Win;
                    Clans[1].Result = Result.Lose;
                }
                else
                {
                    Clans[0].Result = Result.Lose;
                    Clans[1].Result = Result.Win;
                }
            }

            foreach (WarClanApiModel clan in Clans)
            {
                foreach (WarVillageApiModel warVillage in clan.Villages.EmptyIfNull())
                {
                    foreach (AttackApiModel attack in warVillage.Attacks.EmptyIfNull())
                    {
                        if (!Attacks.Any(a => a.Order == attack.Order))
                        {
                            Attacks.Add(attack);
                        }
                    }
                }
            }

            Attacks = Attacks.OrderBy(a => a.Order).ToList();

            var attacksByDefenderTag = Attacks.GroupBy(a => a.DefenderTag);

            foreach (var defendingVillage in attacksByDefenderTag)
            {
                defendingVillage.OrderBy(d => d.Order).First().Fresh = true;
            }

            foreach (var attack in Attacks)
            {
                foreach (var clan in Clans)
                {
                    WarVillageApiModel?attacker = clan.Villages.FirstOrDefault(m => m.VillageTag == attack.AttackerTag);

                    if (attacker != null)
                    {
                        attack.AttackerClanTag = clan.ClanTag;
                    }

                    WarVillageApiModel?defender = clan.Villages.FirstOrDefault(m => m.VillageTag == attack.DefenderTag);

                    if (defender != null)
                    {
                        attack.DefenderClanTag = clan.ClanTag;
                    }
                }
            }

            foreach (WarClanApiModel clan in Clans)
            {
                clan.DefenseCount = Attacks.Count(a => a.DefenderClanTag == clan.ClanTag);
            }
        }