Damage Module Update (#12)

Changes:
-Folder Interfaces:
  • Created interfaces IDamage and IDamageSegment
-Folder base:
  • Created classes Damage and DamageSegment
-Interface IDamage:
  • Added fields (string) Target and (int) AmountDamage
-Interface IDamageSegment:
  • Added fields (int) ID, (Damage Array) Taken and (Damage Array) Given
-Class Damage:
  • Inherit IDamage
-Class DamageSegments:
  • Inherit IDamageSegments
-Class LogRegex:
  • Added Regex StartSegmentDamage
-Class Variables:
  • Added const MessageDamaeUserMinusSeparator
  • Added MessageDamageUserInSeparator
  • Update MessageDamageGiven
-Class Flags:
  • Created enumerator DamageFlag with Taken, Given, NoOne Items
-Folder Damage:
  • Created classes:
    • ExtractDamage.
    • CreateDamageSegment,
    • GetDamageSegment,
    • DamageType,
    • DamageGiven,
    • DamageTaken,
    • DamageFactory
-Class ExtractDamage:
  • Added public method ExtractCurrentMatchDamageFromLogFile to get List of all damage logs,
  • Added a few helper private methods
-Class CreateDamageSegment:
  • Added public method CreateDamageSegments that returns List of DamageSegment from provided List of all damage logs calculated in ExtractCurrentMatchDamageFromLogFile method.
  • Added helper private method CheckLineForDamageType
-Class GetDamageSegment: (Method that call all damage methods)
  • Added public method GetActualGameAllDamageSegment to return Array of DamageSegment
  • Added private helper methods TryGetDamage and IsNewMatch
-Class DamageType:
 • Abstact class applied for implamentation of Factory dessign pattern
- Class DamageTaken and DamageGiven
  • Inherit from DamageType
  • Override AddDamageObjectToColection method.
- Class DamageFactory:
  • A Factory dessign pattern class to improvement clean code.
  • Added public method CreateDamageType that assign a right DamageType to provided log line.
  • Added private helper method IsDamage
Class LogReader:
  • Added public method GetDamageSegmentOfCurrentMatch to return all damage of actual played match saved in DamageSegment objects.

ConsoleLogReaderCSGO/Base/Damage.cs

@@ -0,0 +1,15 @@
+using ConsoleLogReaderCSGO.Base.Interfaces;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace ConsoleLogReaderCSGO.Base
+{
+    public struct Damage : IDamage
+    {
+        #region Fields
+        public string Target { get; set; }
+        public int AmountDamage { get; set; }
+        #endregion
+    }
+}

ConsoleLogReaderCSGO/Base/DamageSegment.cs

@@ -0,0 +1,19 @@
+using ConsoleLogReaderCSGO.Base.Interfaces;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace ConsoleLogReaderCSGO.Base
+{
+    public class DamageSegment : IDamageSegment
+    {
+        #region Fields
+        public int ID { get; set; }
+        public Damage[] Taken { get; set; }
+        public Damage[] Given { get; set; }
+        #endregion
+        #region Constructor
+        public DamageSegment() { }
+        #endregion
+    }
+}

ConsoleLogReaderCSGO/Base/Interfaces/IDamage.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace ConsoleLogReaderCSGO.Base.Interfaces
+{
+    public interface IDamage
+    {
+        string Target { get; set; }
+        int AmountDamage { get; set; }
+    }
+}

ConsoleLogReaderCSGO/Base/Interfaces/IDamageSegment.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace ConsoleLogReaderCSGO.Base.Interfaces
+{
+    interface IDamageSegment
+    {
+        int ID { get; set; }
+        Damage[] Taken { get; set; }
+        Damage[] Given { get; set; }
+    }
+}

ConsoleLogReaderCSGO/ConsoleLogReaderCSGO.csproj

@@ -11,9 +11,23 @@
     <PackageIcon>template.png</PackageIcon>
     <PackageIconUrl />
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
-    <Version>1.1.0.1</Version>
-    <PackageReleaseNotes>1.1.0.1 Update: Added GetChat method and readme.md</PackageReleaseNotes>
+    <Version>1.2.0</Version>
+    <PackageReleaseNotes>1.2.0 
+Update: 
+ • Added internal method to calculate match start/end basic information.
+1.1.0.1 
+Update: 
+ • Added readme.md
+1.1.0 
+Update: 
+ • Added GetChat method
+1.0.1
+Update: 
+ • Little performance of UpdateLog methods.
+1.0.0 
+ • Base program.</PackageReleaseNotes>
 	<PackageReadmeFile>readme.md</PackageReadmeFile>
+	<PackageProjectUrl>https://github.com/pear95/ConsoleLogReaderCSGO</PackageProjectUrl>
   </PropertyGroup>
 
   <ItemGroup>
@@ -24,8 +38,4 @@
 	<None Include="docs\readme.md" Pack="true" PackagePath="\" />
   </ItemGroup>
 
-  <ItemGroup>
-    <Folder Include="Operations\Damage\" />
-  </ItemGroup>
-
 </Project>

ConsoleLogReaderCSGO/Data/LogRegex.cs

@@ -26,5 +26,6 @@ internal static class LogRegex
         public static Regex MatchDisconnect { get; private set; } = new Regex($@"^({Variables.MessageDisconnectFromGame})");
         public static Regex MatchLoadingScreen { get; private set; } = new Regex($@"^({Variables.MessageGameStartConfirm})");
         public static Regex MatchPngReadMessage { get; private set; } = new Regex($@"^({Variables.MessageGameEndConfirmPNG})");
+        public static Regex StartSegmentDamage { get; private set; } = new Regex(@"^(Player: (.*)- Damage Given)");
     }
 }

ConsoleLogReaderCSGO/Data/Variables.cs

@@ -36,9 +36,11 @@ internal static class Variables
         public const string MessageUserTextSeparator = " : ";
         public const string MessageMapSpotSeparator = " @ ";
         public const string MessageIDSeperator = "id:";
+        public const string MessageDamageUserMinusSeparator = "\" - ";
+        public const string MessageDamageUserInSeparator = " in ";
 
         public const string MessageDamageTaken = "Damage Taken from";
-        public const string MessageDamageGiven = "Damage Given to ";
+        public const string MessageDamageGiven = "Damage Given to";
 
         public const string MessageDmg1 = "Damage Given to";
         public const string MessageDmg2 = "Damage Taken from";

ConsoleLogReaderCSGO/Flags.cs

@@ -70,6 +70,13 @@ public enum MatchStatus
         PngReadMessage = 5,
     }
 
+    public enum DamageFlag
+    {
+        Taken = 1,
+        Given = 2,
+        NoOne = 3,
+    }
+
     #endregion
 
 

ConsoleLogReaderCSGO/LogReader.cs

@@ -117,6 +117,22 @@ public List<object> GetChat(bool getAllChat)
             return new List<object> { };
         }
 
+        /// <summary>
+        /// Method returns a Array that contain all damage from actual match.
+        /// </summary>
+        /// <returns>
+        /// <para>Object Array where every object contains:</para>
+        /// <br>1) (int) ID of segment</br>
+        /// <br>2) (Damage Array) a array of object Damage Taken</br>
+        /// <br>3) (Damage Array) a array of object Damage Given</br>
+        /// </returns>
+        public object[] GetDamageSegmentOfCurrentMatch()
+        {
+            var damage = Operations.Damage.GetDamageSegment.GetActualGameAllDamageSegment(Data.Variables.ConsoleLines);
+            if(damage != null) { return damage.ToArray(); }
+            return new object[] { };
+        }
+
         /// <summary>
         /// Method that remove all logs from instance.
         /// </summary>

ConsoleLogReaderCSGO/Operations/Damage/CreateDamageSegment.cs

@@ -0,0 +1,63 @@
+using ConsoleLogReaderCSGO.Data;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ConsoleLogReaderCSGO.Operations.Damage
+{
+    internal static class CreateDamageSegment
+    {
+        #region Field
+
+        private static List<Base.Damage> _taken;
+        private static List<Base.Damage> _given;
+        private static List<Base.DamageSegment> _segments;
+
+        #endregion
+
+        #region public method
+        /// <summary>
+        /// Method that create List of Damage from provided segments (List of List of strings)
+        /// </summary>
+        /// <param name="segments">Segments</param>
+        /// <returns></returns>
+        public static List<Base.DamageSegment> CreateDamageSegments(List<List<string>> segments)
+        {
+            _segments = new List<Base.DamageSegment>();
+            foreach (var i1 in segments.Select((Value, Index) => (Value, Index)).Where(x => x.Index >= 0))
+            {
+                _taken = new List<Base.Damage>();
+                _given = new List<Base.Damage>();
+
+                foreach (var line in i1.Value)
+                {
+                    CheckLineForDamageType(line);
+                }
+
+                _segments.Add(new Base.DamageSegment()
+                {
+                    ID = i1.Index,
+                    Taken = _taken.ToArray(),
+                    Given = _given.ToArray(),
+                }) ;
+            }
+            return _segments;
+        }
+
+        #endregion
+
+        #region Private method
+        /// <summary>
+        /// <br>Method that checking what type of damage is damage line.</br>
+        /// <br>If log type is not null then log line data is added to right collection.</br>
+        /// </summary>
+        /// <param name="line"></param>
+        private static void CheckLineForDamageType(string line)
+        {
+            var factory = DamageFactory.CreateDamageType(line);
+            if(factory != null) { factory.AddDamageObjectToColection(line); }
+        }
+        #endregion
+    }
+}

ConsoleLogReaderCSGO/Operations/Damage/DamageFactory.cs

@@ -0,0 +1,36 @@
+using ConsoleLogReaderCSGO.Data;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace ConsoleLogReaderCSGO.Operations.Damage
+{
+    internal static class DamageFactory
+    {
+        #region Public Method
+        /// <summary>
+        /// Method that returns apporpriate DamageType from provided damage log line.
+        /// </summary>
+        /// <param name="line"></param>
+        /// <returns></returns>
+        public static DamageType CreateDamageType(string line)
+        {
+            if(IsDamage(line, Variables.MessageDamageTaken)) { return new DamageTaken(); }
+            if(IsDamage(line, Variables.MessageDamageGiven)) { return new DamageGiven(); }
+            return null;
+        }
+        #endregion
+        #region Private Method
+        /// <summary>
+        /// Method that returns true if provided log line starts with comparison parameter.
+        /// </summary>
+        /// <param name="line"></param>
+        /// <param name="comparison"></param>
+        /// <returns></returns>
+        private static bool IsDamage(string line, string comparison)
+        {
+            return line.StartsWith(comparison);
+        }
+        #endregion
+    }
+}

ConsoleLogReaderCSGO/Operations/Damage/DamageGiven.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace ConsoleLogReaderCSGO.Operations.Damage
+{
+    internal class DamageGiven : DamageType
+    {
+        #region Public Method
+        internal override Base.Damage AddDamageObjectToColection(string line)
+        {
+            return new Base.Damage()
+            {
+                AmountDamage = CalculateAlmount(line),
+                Target = CalculateTarget(line, DamageFlag.Given)
+            };
+        }
+        #endregion
+    }
+}

ConsoleLogReaderCSGO/Operations/Damage/DamageTaken.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace ConsoleLogReaderCSGO.Operations.Damage
+{
+    internal class DamageTaken : DamageType
+    {
+        #region Public Method
+        internal override Base.Damage AddDamageObjectToColection(string line)
+        {
+            return new Base.Damage()
+            {
+                AmountDamage = CalculateAlmount(line),
+                Target = CalculateTarget(line, DamageFlag.Taken)
+            };
+        }
+        #endregion
+    }
+}

ConsoleLogReaderCSGO/Operations/Damage/DamageType.cs

@@ -0,0 +1,68 @@
+using ConsoleLogReaderCSGO.Data;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace ConsoleLogReaderCSGO.Operations.Damage
+{
+    internal abstract class DamageType
+    {
+        #region Public Method
+        /// <summary>
+        /// Method that returns a right Damage object from provided log line.
+        /// </summary>
+        /// <param name="line"></param>
+        /// <returns></returns>
+        internal abstract Base.Damage AddDamageObjectToColection(string line);
+        #endregion
+
+        #region Protected Methods
+        /// <summary>
+        /// Method that returns right Amount data from provided log line.
+        /// </summary>
+        /// <param name="line"></param>
+        /// <returns></returns>
+        internal protected int CalculateAlmount(string line)
+        {
+            return int.TryParse(SubstringAmount(line), out int result) ? result : 0;
+        }
+
+        /// <summary>
+        /// Method that returns a Target data from provided log line and DamageType.
+        /// </summary>
+        /// <param name="line"></param>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        internal protected string CalculateTarget(string line, DamageFlag type)
+        {
+            return SubstringTarget(line, type);
+        }
+        #endregion
+
+        #region Private Methods
+        /// <summary>
+        /// Method returns a Amount data from provided log damage line.
+        /// </summary>
+        /// <param name="line"></param>
+        /// <returns></returns>
+        private string SubstringAmount(string line)
+        {
+            return line[(line.IndexOf(Variables.MessageDamageUserMinusSeparator) + 4)..line.IndexOf(Variables.MessageDamageUserInSeparator)];
+        }
+
+        /// <summary>
+        /// Method returns a Target data from provided log damage line and type of damage.
+        /// </summary>
+        /// <param name="line"></param>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        private string SubstringTarget(string line, DamageFlag type)
+        {
+            string damageType = type == DamageFlag.Taken ? Variables.MessageDamageTaken 
+                : type == DamageFlag.Given ? Variables.MessageDamageGiven
+                : string.Empty;
+            return line[(line.IndexOf(damageType) + damageType.Length + 2)..line.IndexOf(Variables.MessageDamageUserMinusSeparator)];
+        }
+        #endregion
+    }
+}