Added object oriented dice resolving

6 files changed, 356 insertions, 0 deletions

diff --git a/DiscoBot/Auxiliary/Calculator/Argument.cs b/DiscoBot/Auxiliary/Calculator/Argument.cs
new file mode 100644
index 0000000..2379bfe
--- /dev/null
+++ b/DiscoBot/Auxiliary/Calculator/Argument.cs
@@ -0,0 +1,38 @@
+namespace DiscoBot.Auxiliary.Calculator
+{
+    using System;
+    
+    /// <summary>
+    /// Provides an ISolvable class to save numbers. The class handles Argument checking and conversion from string to int. 
+    /// </summary>
+    public class Argument : ISolvable
+    {
+        private readonly int value;
+
+        public Argument(string value)
+        {
+            // check whether the value given is an empty string
+            if (string.IsNullOrEmpty(value)) 
+            {
+                throw new ArgumentException("Argument kann nicht mit einem leeren string instanziert werden. ", nameof(value));
+            }
+
+            if (!int.TryParse(value, out int result))
+            {
+                throw new ArgumentException($"Kann {value} nicht in Integer konvertieren");
+            }
+
+            this.value = result;
+        }
+
+        public int Solve()
+        {
+            return this.value;
+        }
+
+        public override string ToString()
+        {
+            return this.value.ToString();
+        }
+    }
+}
\ No newline at end of file
diff --git a/DiscoBot/Auxiliary/Calculator/ISolvable.cs b/DiscoBot/Auxiliary/Calculator/ISolvable.cs
new file mode 100644
index 0000000..a869bdb
--- /dev/null
+++ b/DiscoBot/Auxiliary/Calculator/ISolvable.cs
@@ -0,0 +1,10 @@
+namespace DiscoBot.Auxiliary.Calculator
+{
+    /// <summary>
+    /// Object has to be able to return an integer as it's value
+    /// </summary>
+    public interface ISolvable
+    {
+        int Solve();
+    }
+}
diff --git a/DiscoBot/Auxiliary/Calculator/Operator.cs b/DiscoBot/Auxiliary/Calculator/Operator.cs
new file mode 100644
index 0000000..0928ec2
--- /dev/null
+++ b/DiscoBot/Auxiliary/Calculator/Operator.cs
@@ -0,0 +1,50 @@
+using System;
+
+namespace DiscoBot.Auxiliary.Calculator
+{
+    /// <summary>
+    /// The Operator Class represents a binary operator with tow Arguments and an Operation type
+    /// </summary>
+    public class Operator : ISolvable
+    {
+        private readonly ISolvable arg1, arg2;
+
+        public Operator(ISolvable arg1, ISolvable arg2, Ops operatorType)
+        {
+            this.arg1 = arg1;
+            this.arg2 = arg2;
+            this.OperatorType = operatorType;
+        }
+
+        public Ops OperatorType { get; set; }
+
+        public int Solve()
+        {
+            int result;
+            switch (this.OperatorType)
+            {
+                case Ops.Dice:
+                    result = Dice.Roll(this.arg1.Solve(), this.arg2.Solve());
+                    break;
+                case Ops.Multiply:
+                    result = this.arg1.Solve() * this.arg2.Solve();
+                    break;
+                case Ops.Add:
+                    result = this.arg1.Solve() + this.arg2.Solve();
+                    break;
+                case Ops.Subtract:
+                    result = this.arg1.Solve() - this.arg2.Solve();
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+
+            return result;
+        }
+
+        public override string ToString()
+        {
+            return $"({this.arg1} {this.OperatorType} {this.arg2})";
+        }
+    }
+}
diff --git a/DiscoBot/Auxiliary/Calculator/Ops.cs b/DiscoBot/Auxiliary/Calculator/Ops.cs
new file mode 100644
index 0000000..62c1309
--- /dev/null
+++ b/DiscoBot/Auxiliary/Calculator/Ops.cs
@@ -0,0 +1,13 @@
+namespace DiscoBot.Auxiliary.Calculator
+{
+    /// <summary>
+    /// The Different Operations, witch can be performed in execution-order
+    /// </summary>
+    public enum Ops
+    {
+        Dice,
+        Multiply,
+        Subtract,
+        Add
+    }
+}
diff --git a/DiscoBot/Auxiliary/Calculator/StringSolver.cs b/DiscoBot/Auxiliary/Calculator/StringSolver.cs
new file mode 100644
index 0000000..30c2134
--- /dev/null
+++ b/DiscoBot/Auxiliary/Calculator/StringSolver.cs
@@ -0,0 +1,207 @@
+namespace DiscoBot.Auxiliary.Calculator
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+
+    /// <summary>
+    /// The StringSolver divides the calculation string into operations and SubStringSolvers if the string contains parentheses 
+    /// </summary>
+    public class StringSolver : ISolvable
+    {
+        private readonly string input;
+        private readonly List<object> arguments = new List<object>();
+
+        public StringSolver(string input)
+        {
+            this.input = input;
+        }
+
+        public override string ToString()
+        {
+            return "(0+" + this.input.Replace(" ", string.Empty).ToLower() + ")";
+        }
+
+        public int Solve()
+        {
+            string workInput = "0+" + this.input.Replace(" ", string.Empty).ToLower();
+            workInput = ExpandParentheses(workInput);
+            
+            // Create a List of the different parts of the calculation, e.g.:{"0", "+", "(5+6)", "d", "3"}.
+            this.AtomizeOperations(workInput);
+
+            // traverse the List in order of Operation to Create the binary operation tree .
+            this.NestOperations();
+
+            // the List now contains only the top operation node, witch can be solved recursively,
+            return ((ISolvable)this.arguments.First()).Solve();
+        }
+
+        private static string GetInner(ref string input) // extract the inner bracket an remove the section from the input string
+        {
+            int depth = 0;
+            for (var index = 1; index < input.Length; index++)
+            {
+                char c = input[index];
+                switch (c)
+                {
+                    case '(':
+                        depth++;
+                        break;
+                    case ')':
+                        if (depth == 0)
+                        {
+                            var split = input.Substring(1, index - 1);
+                            input = input.Substring(index + 1);
+                            return split.Equals(string.Empty) ? "0" : split;
+                        }
+                        else
+                        {
+                            depth--;
+                        }
+
+                        break;
+                }
+            }
+
+            return string.Empty;
+        }
+
+        private static Ops GetOps(char c)
+        {
+            switch (c)
+            {
+                case 'd':
+                case 'w':
+                    return Ops.Dice;
+                case '+':
+                    return Ops.Add;
+                case '-':
+                    return Ops.Subtract;
+                case '*':
+                    return Ops.Multiply;
+                default:
+                    return Ops.Multiply;
+            }
+        }
+
+        private static string ExpandParentheses(string input) // insert * between Parentheses and digits
+        {
+            for (int i = 0; i < input.Length - 1; i++)
+            {
+                if (input[i + 1] == '(' && char.IsNumber(input[i]))
+                {
+                    input = input.Insert(i + 1, "*");
+                }
+            }
+
+            for (int i = 1; i < input.Length; i++)
+            {
+                if (input[i - 1] == ')' && char.IsNumber(input[i]))
+                {
+                    input = input.Insert(i, "*");
+                }
+            }
+
+            return input;
+        }
+
+        private void AtomizeOperations(string workInput)
+        {
+            for (var index = 0; index < workInput.Length; index++)
+            {
+                char c = workInput[index];
+
+                if (char.IsNumber(c))
+                {
+                    // if char number, check if at end of string, else continue looping
+                    if (index == workInput.Length - 1)
+                    {
+                        // if at end of string; add remaining number to arguments
+                        this.arguments.Add(new Argument(workInput.Substring(0, index + 1)));
+                    }
+
+                    continue;
+                }
+
+                switch (c)
+                {
+                    case ')':
+                        throw new ArgumentException($"Unmögliche Anordnung von Klammern");
+                    case '(':
+                        this.arguments.Add(new StringSolver(GetInner(ref workInput)));
+                        index = -1;
+                        break;
+                    default:
+                        if (index > 0)
+                        {
+                            this.arguments.Add(new Argument(workInput.Substring(0, index)));
+                        }
+
+                        this.arguments.Add(GetOps(c));
+                        workInput = workInput.Remove(0, index + 1);
+                        index = -1;
+                        break;
+                }
+            }
+        }
+
+        private void NestOperations()
+        {
+            foreach (Ops currentOp in Enum.GetValues(typeof(Ops)))
+            {
+                // cycle through operators in operational order
+                for (var index = 0; index < this.arguments.Count; index++)
+                {
+                    var arg = this.arguments[index];
+
+                    if (arg.GetType() != typeof(Ops))
+                    {
+                        continue;
+                    }
+
+                    // arg is of type Ops
+                    var op = (Ops)arg;
+
+                    if (op != currentOp)
+                    {
+                        continue;
+                    }
+
+                    // arg describes the current operation
+                    this.HandleSpecialFormatting(ref index, op); // Deal with special needs...
+
+                    // replace the previous current and next Element in the List with one Operation object
+                    var temp = new Operator((ISolvable)this.arguments[index - 1], (ISolvable)this.arguments[index + 1], op); 
+                    this.arguments[index - 1] = temp;
+                    this.arguments.RemoveRange(index, 2);
+                    index--;
+                }
+            }
+        }
+
+        private void HandleSpecialFormatting(ref int index, Ops op)
+        {
+            var arg1 = this.arguments[index - 1];
+            if (arg1.GetType() == typeof(Ops))
+            {
+                if (op == Ops.Dice)
+                {
+                    this.arguments.Insert(index++, new Argument("1")); // w6 -> 1w6
+                }
+
+                if (op == Ops.Subtract)
+                {
+                    this.arguments.Insert(index++, new Argument("0")); // +-3 -> +0-3
+                }
+            }
+
+            var arg2 = this.arguments[index + 1]; // 3+-5 -> 3+(0-5)
+            if (arg2.GetType() == typeof(Ops))
+            {
+                this.arguments[index + 1] = new Operator(new Argument("0"), (ISolvable)this.arguments[index + 2], (Ops)arg2);
+                this.arguments.RemoveAt(index + 2);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/DiscoBot/Auxiliary/Dice.cs b/DiscoBot/Auxiliary/Dice.cs
index 16a8a77..0cd9656 100644
--- a/DiscoBot/Auxiliary/Dice.cs
+++ b/DiscoBot/Auxiliary/Dice.cs
@@ -1,5 +1,10 @@
 namespace DiscoBot.Auxiliary
 {
+    using System;
+    using System.Linq;
+
+    using Discord.Commands;
+
     public static class Dice // roll it!
     {
         private static readonly System.Random Rnd = new System.Random();
@@ -8,5 +13,38 @@
         {
             return Rnd.Next(d) + 1;
         }
+
+        public static int Roll(string input)
+        {
+            var strings = input.ToLower().Split(new[] { 'w', 'd' }, 2, StringSplitOptions.RemoveEmptyEntries).ToList();
+            int count = Convert.ToInt32(strings[0]);
+            int d = Convert.ToInt32(strings[0]);
+
+            if (strings.Count != 2)
+            {
+                throw new ArgumentException($"{input}: erfüllt nicht die Formatvogaben( Anzahl d Augenzahl)");
+            }
+
+            return Roll(count, d);
+        }
+
+        public static int Roll(int count, int d)
+        {
+            if (d <= 0)
+            {
+                return 0;
+            }
+
+            int sum = 0;
+            for (int i = 0; i < Math.Abs(count); i++)
+            {
+                var roll = Dice.Roll(d);
+                sum += roll;
+            }
+
+            sum *= Math.Abs(count) / count;
+
+            return sum;
+        }
     }
 }