コード例 #1
0
		public Task<double> GetHitGroupDamageAsync(Demo demo, Hitgroup hitGroup, List<long> steamIdList, List<int> roundNumberList)
		{
			double result = 0;
			switch (hitGroup)
			{
				case Hitgroup.Chest:
					result = 110;
					break;
				case Hitgroup.LeftArm:
					result = 20;
					break;
				case Hitgroup.RightArm:
					result = 30;
					break;
				case Hitgroup.Head:
					result = 40;
					break;
				case Hitgroup.LeftLeg:
					result = 50;
					break;
				case Hitgroup.RightLeg:
					result = 60;
					break;
				case Hitgroup.Stomach:
					result = 70;
					break;
			}

			return Task.FromResult(result);
		}
コード例 #2
0
        public async Task <double> GetHitGroupDamageAsync(Demo demo, Hitgroup hitGroup, List <long> steamIdList, List <int> roundNumberList)
        {
            double result = 0;
            await Task.Factory.StartNew(() =>
            {
                // get the total damage made at the specific hitgroup
                switch (hitGroup)
                {
                case Hitgroup.Chest:
                    result += demo.PlayersHurted.Where(e => steamIdList.Contains(e.AttackerSteamId) && e.HitGroup == Hitgroup.Chest &&
                                                       roundNumberList.Contains(e.RoundNumber)).Sum(e => e.HealthDamage);
                    break;

                case Hitgroup.Head:
                    result += demo.PlayersHurted.Where(e => steamIdList.Contains(e.AttackerSteamId) && e.HitGroup == Hitgroup.Head &&
                                                       roundNumberList.Contains(e.RoundNumber)).Sum(e => e.HealthDamage);
                    break;

                case Hitgroup.LeftArm:
                    result += demo.PlayersHurted.Where(e => steamIdList.Contains(e.AttackerSteamId) && e.HitGroup == Hitgroup.LeftArm &&
                                                       roundNumberList.Contains(e.RoundNumber)).Sum(e => e.HealthDamage);
                    break;

                case Hitgroup.RightArm:
                    result += demo.PlayersHurted.Where(e => steamIdList.Contains(e.AttackerSteamId) && e.HitGroup == Hitgroup.RightArm &&
                                                       roundNumberList.Contains(e.RoundNumber)).Sum(e => e.HealthDamage);
                    break;

                case Hitgroup.LeftLeg:
                    result += demo.PlayersHurted.Where(e => steamIdList.Contains(e.AttackerSteamId) && e.HitGroup == Hitgroup.LeftLeg &&
                                                       roundNumberList.Contains(e.RoundNumber)).Sum(e => e.HealthDamage);
                    break;

                case Hitgroup.RightLeg:
                    result += demo.PlayersHurted.Where(e => steamIdList.Contains(e.AttackerSteamId) && e.HitGroup == Hitgroup.RightLeg &&
                                                       roundNumberList.Contains(e.RoundNumber)).Sum(e => e.HealthDamage);
                    break;

                case Hitgroup.Stomach:
                    result += demo.PlayersHurted.Where(e => steamIdList.Contains(e.AttackerSteamId) && e.HitGroup == Hitgroup.Stomach &&
                                                       roundNumberList.Contains(e.RoundNumber)).Sum(e => e.HealthDamage);
                    break;
                }
            });

            return(result);
        }
コード例 #3
0
		public async Task<double> GetHitGroupDamageAsync(Demo demo, Hitgroup hitGroup, List<long> steamIdList, List<int> roundNumberList)
		{
			double result = 0;
			await Task.Factory.StartNew(() =>
			{
				// get the total damage made at the specific hitgroup
				switch (hitGroup)
				{
					case Hitgroup.Chest:
						result += demo.PlayersHurted.Where(e => steamIdList.Contains(e.AttackerSteamId) && e.HitGroup == Hitgroup.Chest
						&& roundNumberList.Contains(e.RoundNumber)).Sum(e => e.HealthDamage);
						break;
					case Hitgroup.Head:
						result += demo.PlayersHurted.Where(e => steamIdList.Contains(e.AttackerSteamId) && e.HitGroup == Hitgroup.Head
						&& roundNumberList.Contains(e.RoundNumber)).Sum(e => e.HealthDamage);
						break;
					case Hitgroup.LeftArm:
						result += demo.PlayersHurted.Where(e => steamIdList.Contains(e.AttackerSteamId) && e.HitGroup == Hitgroup.LeftArm
						&& roundNumberList.Contains(e.RoundNumber)).Sum(e => e.HealthDamage);
						break;
					case Hitgroup.RightArm:
						result += demo.PlayersHurted.Where(e => steamIdList.Contains(e.AttackerSteamId) && e.HitGroup == Hitgroup.RightArm
						&& roundNumberList.Contains(e.RoundNumber)).Sum(e => e.HealthDamage);
						break;
					case Hitgroup.LeftLeg:
						result += demo.PlayersHurted.Where(e => steamIdList.Contains(e.AttackerSteamId) && e.HitGroup == Hitgroup.LeftLeg
						&& roundNumberList.Contains(e.RoundNumber)).Sum(e => e.HealthDamage);
						break;
					case Hitgroup.RightLeg:
						result += demo.PlayersHurted.Where(e => steamIdList.Contains(e.AttackerSteamId) && e.HitGroup == Hitgroup.RightLeg
						&& roundNumberList.Contains(e.RoundNumber)).Sum(e => e.HealthDamage);
						break;
					case Hitgroup.Stomach:
						result += demo.PlayersHurted.Where(e => steamIdList.Contains(e.AttackerSteamId) && e.HitGroup == Hitgroup.Stomach
						&& roundNumberList.Contains(e.RoundNumber)).Sum(e => e.HealthDamage);
						break;
				}
			});

			return result;
		}
コード例 #4
0
        public Task <double> GetHitGroupDamageAsync(Demo demo, Hitgroup hitGroup, List <long> steamIdList, List <int> roundNumberList)
        {
            double result = 0;

            switch (hitGroup)
            {
            case Hitgroup.Chest:
                result = 110;
                break;

            case Hitgroup.LeftArm:
                result = 20;
                break;

            case Hitgroup.RightArm:
                result = 30;
                break;

            case Hitgroup.Head:
                result = 40;
                break;

            case Hitgroup.LeftLeg:
                result = 50;
                break;

            case Hitgroup.RightLeg:
                result = 60;
                break;

            case Hitgroup.Stomach:
                result = 70;
                break;
            }

            return(Task.FromResult(result));
        }
コード例 #5
0
        /// <summary>
        /// Get damage formatted string => % (damage)
        /// </summary>
        /// <param name="hitGroup"></param>
        /// <param name="players"></param>
        /// <param name="rounds"></param>
        /// <returns></returns>
        public async Task <string> GetDamageAsync(Hitgroup hitGroup, List <PlayerExtended> players, List <Round> rounds)
        {
            string result           = "0";
            int    damageAreaCount  = 0;
            int    totalDamageCount = 0;

            await Task.Factory.StartNew(() =>
            {
                // get the total damage made at specific round(s) and player(s)
                totalDamageCount += (
                    from round
                    in rounds
                    from playerHurtedEvent
                    in round.PlayersHurted
                    where playerHurtedEvent.Attacker != null && players.Contains(playerHurtedEvent.Attacker)
                    select playerHurtedEvent.HealthDamage).Sum();

                // get the total damage made at the specific hitgroup
                switch (hitGroup)
                {
                case Hitgroup.Chest:
                    damageAreaCount += (
                        from round
                        in rounds
                        from playerHurtedEvent
                        in round.PlayersHurted
                        where players.Contains(playerHurtedEvent.Attacker)
                        where playerHurtedEvent.HitGroup == Hitgroup.Chest
                        select playerHurtedEvent.HealthDamage).Sum();
                    break;

                case Hitgroup.Head:
                    damageAreaCount += (
                        from round
                        in rounds
                        from playerHurtedEvent
                        in round.PlayersHurted
                        where players.Contains(playerHurtedEvent.Attacker)
                        where playerHurtedEvent.HitGroup == Hitgroup.Head
                        select playerHurtedEvent.HealthDamage).Sum();
                    break;

                case Hitgroup.LeftArm:
                    damageAreaCount += (
                        from round
                        in rounds
                        from playerHurtedEvent
                        in round.PlayersHurted
                        where players.Contains(playerHurtedEvent.Attacker)
                        where playerHurtedEvent.HitGroup == Hitgroup.LeftArm
                        select playerHurtedEvent.HealthDamage).Sum();
                    break;

                case Hitgroup.RightArm:
                    damageAreaCount += (
                        from round
                        in rounds
                        from playerHurtedEvent
                        in round.PlayersHurted
                        where players.Contains(playerHurtedEvent.Attacker)
                        where playerHurtedEvent.HitGroup == Hitgroup.RightArm
                        select playerHurtedEvent.HealthDamage).Sum();
                    break;

                case Hitgroup.LeftLeg:
                    damageAreaCount += (
                        from round
                        in rounds
                        from playerHurtedEvent
                        in round.PlayersHurted
                        where players.Contains(playerHurtedEvent.Attacker)
                        where playerHurtedEvent.HitGroup == Hitgroup.LeftLeg
                        select playerHurtedEvent.HealthDamage).Sum();
                    break;

                case Hitgroup.RightLeg:
                    damageAreaCount += (
                        from round
                        in rounds
                        from playerHurtedEvent
                        in round.PlayersHurted
                        where players.Contains(playerHurtedEvent.Attacker)
                        where playerHurtedEvent.HitGroup == Hitgroup.RightLeg
                        select playerHurtedEvent.HealthDamage).Sum();
                    break;

                case Hitgroup.Stomach:
                    damageAreaCount += (
                        from round
                        in rounds
                        from playerHurtedEvent
                        in round.PlayersHurted
                        where players.Contains(playerHurtedEvent.Attacker)
                        where playerHurtedEvent.HitGroup == Hitgroup.Stomach
                        select playerHurtedEvent.HealthDamage).Sum();
                    break;
                }
            });

            if (damageAreaCount != 0)
            {
                result = Math.Round((double)damageAreaCount * 100 / totalDamageCount, 2).ToString(CultureInfo.InvariantCulture);
            }
            result += "% (" + damageAreaCount + ")";
            return(result);
        }
コード例 #6
0
ファイル: Demo.cs プロジェクト: Calak/CSGO-Demos-Manager
		/// <summary>
		/// Get damage formatted string => % (damage)
		/// </summary>
		/// <param name="hitGroup"></param>
		/// <param name="players"></param>
		/// <param name="rounds"></param>
		/// <returns></returns>
		public async Task<string> GetDamageAsync(Hitgroup hitGroup, List<PlayerExtended> players, List<Round> rounds)
		{
			string result = "0";
			int damageAreaCount = 0;
			int totalDamageCount = 0;

			await Task.Factory.StartNew(() =>
			{
				// get the total damage made at specific round(s) and player(s)
				totalDamageCount += (
				from round
				in rounds
				from playerHurtedEvent
				in round.PlayersHurted
				where playerHurtedEvent.Attacker != null && players.Contains(playerHurtedEvent.Attacker)
				select playerHurtedEvent.HealthDamage).Sum();

				// get the total damage made at the specific hitgroup
				switch (hitGroup)
				{
					case Hitgroup.Chest:
						damageAreaCount += (
						from round
						in rounds
						from playerHurtedEvent
						in round.PlayersHurted
						where players.Contains(playerHurtedEvent.Attacker)
						where playerHurtedEvent.HitGroup == Hitgroup.Chest
						select playerHurtedEvent.HealthDamage).Sum();
						break;
					case Hitgroup.Head:
						damageAreaCount += (
						from round
						in rounds
						from playerHurtedEvent
						in round.PlayersHurted
						where players.Contains(playerHurtedEvent.Attacker)
						where playerHurtedEvent.HitGroup == Hitgroup.Head
						select playerHurtedEvent.HealthDamage).Sum();
						break;
					case Hitgroup.LeftArm:
						damageAreaCount += (
						from round
						in rounds
						from playerHurtedEvent
						in round.PlayersHurted
						where players.Contains(playerHurtedEvent.Attacker)
						where playerHurtedEvent.HitGroup == Hitgroup.LeftArm
						select playerHurtedEvent.HealthDamage).Sum();
						break;
					case Hitgroup.RightArm:
						damageAreaCount += (
						from round
						in rounds
						from playerHurtedEvent
						in round.PlayersHurted
						where players.Contains(playerHurtedEvent.Attacker)
						where playerHurtedEvent.HitGroup == Hitgroup.RightArm
						select playerHurtedEvent.HealthDamage).Sum();
						break;
					case Hitgroup.LeftLeg:
						damageAreaCount += (
						from round
						in rounds
						from playerHurtedEvent
						in round.PlayersHurted
						where players.Contains(playerHurtedEvent.Attacker)
						where playerHurtedEvent.HitGroup == Hitgroup.LeftLeg
						select playerHurtedEvent.HealthDamage).Sum();
						break;
					case Hitgroup.RightLeg:
						damageAreaCount += (
						from round
						in rounds
						from playerHurtedEvent
						in round.PlayersHurted
						where players.Contains(playerHurtedEvent.Attacker)
						where playerHurtedEvent.HitGroup == Hitgroup.RightLeg
						select playerHurtedEvent.HealthDamage).Sum();
						break;
					case Hitgroup.Stomach:
						damageAreaCount += (
						from round
						in rounds
						from playerHurtedEvent
						in round.PlayersHurted
						where players.Contains(playerHurtedEvent.Attacker)
						where playerHurtedEvent.HitGroup == Hitgroup.Stomach
						select playerHurtedEvent.HealthDamage).Sum();
						break;
				}
			});

			if(damageAreaCount != 0) result = Math.Round((double)damageAreaCount * 100 / totalDamageCount, 2).ToString(CultureInfo.InvariantCulture);
			result += "% (" + damageAreaCount + ")";
			return result;
		}