Merge

8 files changed, 575 insertions, 0 deletions

diff --git a/DiscoBot/DSA_Game/Characters/Character.cs b/DiscoBot/DSA_Game/Characters/Character.cs
new file mode 100644
index 0000000..2f994f0
--- /dev/null
+++ b/DiscoBot/DSA_Game/Characters/Character.cs
@@ -0,0 +1,275 @@
+namespace DiscoBot.DSA_Game.Characters
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Text;
+    using System.Xml;
+
+    using DiscoBot.Audio;
+    using DiscoBot.Auxiliary;
+
+    public class Character : ICharacter
+    {
+        public Character()
+        {
+            this.PropTable.Add("MU", "Mut");             // routing
+            this.PropTable.Add("KL", "Klugheit");
+            this.PropTable.Add("IN", "Intuition");
+            this.PropTable.Add("CH", "Charisma");
+            this.PropTable.Add("FF", "Fingerfertigkeit");
+            this.PropTable.Add("GE", "Gewandtheit");
+            this.PropTable.Add("KO", "Konstitution");
+            this.PropTable.Add("KK", "Körperkraft");
+
+        }
+
+        public Character(string path) : this()
+        {
+            this.Load(path); // load
+            this.Post_process(); // calculate derived values
+        }
+
+        public Character(Character c, string name, int stDv = 2) : this()
+        {
+            this.Name = name;
+            foreach (var i in c.Eigenschaften)
+            {
+                this.Eigenschaften.Add(i.Key, i.Value + (int)Math.Round(RandomMisc.Random(stDv)));
+            }
+
+            foreach (var i in c.Vorteile)
+            {
+                this.Vorteile.Add(new Vorteil(i.Name, i.Value + (int)Math.Round(RandomMisc.Random(stDv))));
+            }
+
+            foreach (var i in c.Talente)
+            {
+                this.Talente.Add(new Talent(i.Name, i.Probe, i.Value + (int)Math.Round(RandomMisc.Random(stDv))));
+            }
+
+            foreach (var i in c.Zauber)
+            {
+                this.Zauber.Add(new Zauber(i.Name, i.Probe, i.Value + (int)Math.Round(RandomMisc.Random(stDv)), i.Complexity, i.Representation));
+            }
+
+            foreach (var i in c.Kampftalente)
+            {
+                this.Kampftalente.Add(new KampfTalent(i.Name, i.At + (int)Math.Round(RandomMisc.Random(stDv)), i.Pa + (int)Math.Round(RandomMisc.Random(stDv))));
+            }
+
+            this.Post_process(); // calculate derived values
+        }
+
+        public string Name { get; set; } // char name
+
+        public int Lebenspunkte { get; set; }
+
+        public int Astralpunkte { get; set; }
+
+        public Dictionary<string, int> Eigenschaften { get; set; } = new Dictionary<string, int>();   // char properties
+
+        public List<Talent> Talente { get; set; } = new List<Talent>();       // list of talent objects (talents)
+
+        public List<Zauber> Zauber { get; set; } = new List<Zauber>();       // list of spell objects 
+
+        public List<KampfTalent> Kampftalente { get; set; } = new List<KampfTalent>();    // list of combat objects
+
+        public List<Vorteil> Vorteile { get; set; } = new List<Vorteil>();
+
+        public Dictionary<string, string> PropTable { get; set; } = new Dictionary<string, string>(); // -> Körperkraft
+        
+        public string TestTalent(string talent, int erschwernis = 0)     // Talentprobe
+        {
+            return this.Talente.ProbenTest(this, talent, erschwernis);
+        }
+
+        public string TestZauber(string zauber, int erschwernis = 0)     // Talentprobe
+        {
+            return this.Zauber.ProbenTest(this, zauber, erschwernis);
+        }
+
+        public string TestEigenschaft(string eigenschaft, int erschwernis = 0)
+        {
+            var output = new StringBuilder();
+            var prop = this.PropTable[eigenschaft.ToUpper()];
+            int tap = this.Eigenschaften[prop];
+            output.AppendFormat(
+                "{0}-Eigenschaftsprobe ew:{1} {2} \n", 
+                prop, 
+                tap,
+                erschwernis.Equals(0) ? string.Empty : "Erschwernis: " + erschwernis);
+            int roll = Dice.Roll();
+            output.Append($"Gewürfelt: {roll} übrig: {tap - roll - erschwernis}");
+            return output.ToString();
+        }
+
+        public string Angriff(string talent, int erschwernis = 0)    // pretty self explanatory
+        {
+            var output = new StringBuilder();
+            var sc = new SpellCorrect();
+            var attack = this.Kampftalente.OrderBy(x => sc.Compare(talent, x.Name)).First();
+            if (sc.Compare(talent, attack.Name) > SpellCorrect.ErrorThreshold)
+            {
+                SoundEffects.Play(Sound.Wrong).Wait();
+                return $"{this.Name} kann nicht mit der Waffenart {talent} umgehen...";
+            }
+
+            int tap = attack.At;
+            output.AppendFormat(
+                "{0}-Angriff taw:{1} {2} \n",
+                attack.Name,
+                tap,
+                erschwernis.Equals(0) ? string.Empty : "Erschwernis: " + erschwernis);
+
+            int temp = Dice.Roll();
+            output.Append(temp - erschwernis);
+            return output.ToString();
+        }
+
+        public string Parade(string talent, int erschwernis = 0)
+        {
+            var output = new StringBuilder();
+            var sc = new SpellCorrect();
+            var attack = this.Kampftalente.OrderBy(x => sc.Compare(talent, x.Name)).First();
+
+            if (sc.Compare(talent, attack.Name) > SpellCorrect.ErrorThreshold)
+            {
+                SoundEffects.Play(Sound.Wrong).Wait();
+                return $"{this.Name} kann nicht mit der Waffenart {talent} umgehen...";
+            }
+
+            int tap = attack.Pa;
+            output.AppendFormat(
+                "{0}-Parade taw:{1} {2}\n", 
+                attack.Name, 
+                tap, 
+                erschwernis.Equals(0) ? string.Empty : "Erschwernis: " + erschwernis);
+
+            int temp = Dice.Roll();
+            output.Append(temp - erschwernis);
+            return output.ToString();
+        }
+
+        public string Fernkampf(string talent, int erschwernis = 0)
+        {
+            var output = new StringBuilder();
+            var sc = new SpellCorrect();
+            int fk = this.Eigenschaften["fk"];
+            var attack = this.Talente.OrderBy(x => sc.Compare(talent, x.Name)).First();
+            if (sc.Compare(talent, attack.Name) > SpellCorrect.ErrorThreshold)
+            {
+                SoundEffects.Play(Sound.Wrong).Wait();
+                return $"{this.Name} kann nicht mit der Waffenart {talent} umgehen...";
+            }
+
+            int tap = attack.Value;
+            output.AppendFormat(
+                "{0} taw:{1} {2} \n", 
+                attack.Name, 
+                tap,
+                erschwernis.Equals(0) ? string.Empty : "Erschwernis: " + erschwernis);
+            tap -= erschwernis;
+            int temp = Dice.Roll();
+            tap -= temp > fk ? temp - fk : 0;
+            output.Append($"W20: {temp} tap: {tap}");
+            return output.ToString();
+        }
+
+        private void Post_process()
+        {
+            var LE_Wert = this.Eigenschaften["Lebensenergie"];
+            var KK_Wert = this.Eigenschaften["Körperkraft"];
+            var KO__Wert = this.Eigenschaften["Konstitution"];
+
+            this.Lebenspunkte = LE_Wert + (int)(KO__Wert + (KK_Wert/2.0) + 0.5);
+
+            // ToDo: Astralpunkte berrechnen
+            
+        }
+
+            private void Load(string path)
+        {
+            var reader = new XmlTextReader(path);
+            while (reader.Read())
+            {
+                // read until he hits keywords
+                if (reader.NodeType != XmlNodeType.Element)
+                {
+                    continue;
+                }
+
+                switch (reader.Name)
+                {
+                    case "Wesen":
+                        reader.Skip();
+                        break;
+                    case "held":
+                        this.Name = reader.GetAttribute("name"); // name
+                        break;
+                    case "eigenschaft":
+                        this.Eigenschaften.Add(
+                            reader.GetAttribute("name") ?? throw new InvalidOperationException(),
+                            Convert.ToInt32(reader.GetAttribute("value")) + Convert.ToInt32(reader.GetAttribute("mod")));
+                        break;
+                    case "vt":
+                        reader.Read();
+                        while (reader.Name.Equals("vorteil"))
+                        {
+                            try
+                            {
+                                this.Vorteile.Add(new Vorteil(
+                                    reader.GetAttribute("name"),
+                                  //  Convert.ToInt32(reader.GetAttribute("value"))));
+                                reader.GetAttribute("value")));
+                            }
+                            catch
+                            {
+                                this.Vorteile.Add(new Vorteil(reader.GetAttribute("name")));
+                            }
+
+                            reader.Read();
+                        }
+
+                        break;
+                    case "talentliste":
+                        reader.Read();
+                        while (reader.Name.Equals("talent"))
+                        {
+                            this.Talente.Add(
+                                new Talent(
+                                    reader.GetAttribute("name"),
+                                    reader.GetAttribute("probe")?.Remove(0, 2).Trim(')'),
+                                    Convert.ToInt32(reader.GetAttribute("value"))));
+                            reader.Read();
+                        }
+
+                        break;
+                    case "zauberliste":
+                        reader.Read();
+                        while (reader.Name.Equals("zauber"))
+                        {
+                            this.Zauber.Add(
+                                new Zauber(
+                                    reader.GetAttribute("name"),
+                                    reader.GetAttribute("probe")?.Remove(0, 2).Trim(')'),
+                                    Convert.ToInt32(reader.GetAttribute("value")),
+                                    reader.GetAttribute("k").ToCharArray()[0],
+                                    reader.GetAttribute("repraesentation")));
+                            reader.Read();
+                        }
+
+                        break;
+                    case "kampfwerte":
+                        string atName = reader.GetAttribute("name");
+                        reader.Read();
+                        int at = Convert.ToInt32(reader.GetAttribute("value"));
+                        reader.Read();
+                        int pa = Convert.ToInt32(reader.GetAttribute("value"));
+                        this.Kampftalente.Add(new KampfTalent(atName, at, pa));
+                        break;
+                }
+            }
+        }
+    }
+}
diff --git a/DiscoBot/DSA_Game/Characters/ICharacter.cs b/DiscoBot/DSA_Game/Characters/ICharacter.cs
new file mode 100644
index 0000000..1dae15d
--- /dev/null
+++ b/DiscoBot/DSA_Game/Characters/ICharacter.cs
@@ -0,0 +1,27 @@
+namespace DiscoBot.DSA_Game.Characters
+{
+    public interface ICharacter
+    {
+        string Name { get; set; }
+
+        int Lebenspunkte { get; set; }
+
+        //int Ausdauer { get; set; }
+
+        int Astralpunkte { get; set; }
+
+        //int Karmapunkte { get; set; }
+
+        string TestTalent(string talent, int erschwernis = 0);
+
+        string TestEigenschaft(string eigenschaft, int erschwernis = 0);
+
+        string Angriff(string talent, int erschwernis = 0);
+
+        string Parade(string talent, int erschwernis = 0);
+
+        string Fernkampf(string talent, int erschwernis = 0);
+
+        string TestZauber(string waffe, int erschwernis);
+    }
+}
diff --git a/DiscoBot/DSA_Game/Characters/NPC.cs b/DiscoBot/DSA_Game/Characters/NPC.cs
new file mode 100644
index 0000000..45ff6b0
--- /dev/null
+++ b/DiscoBot/DSA_Game/Characters/NPC.cs
@@ -0,0 +1,117 @@
+namespace DiscoBot.Characters
+{
+    using System;
+
+    using DiscoBot.Auxiliary;
+    using DiscoBot.DSA_Game.Characters;
+
+    public class Npc : ICharacter
+    {
+        private readonly int mean, stDv;
+
+        public Npc(string name, int mean, int stDv)
+        {
+            this.mean = mean;
+            this.stDv = stDv;
+            this.Name = name;
+        }
+
+        public string Name { get; set; }
+
+        public int Lebenspunkte { get; set; }
+
+        public int Astralpunkte { get; set; }
+
+        public string TestTalent(string talent, int tap = 3)
+        {
+            for (int i = 0; i <= 2; i++)
+            {
+                // foreach property, dice and tap 
+                int temp = Dice.Roll();
+                int eigenschaft = (int)Math.Round(RandomMisc.Random(this.stDv, this.mean));
+
+                if (eigenschaft < temp)
+                {
+                    tap -= temp - eigenschaft;
+                }
+            }
+
+            if (tap >= 0)
+            {
+                return $"{this.Name} vollführt {talent} erfolgreich";
+            }
+
+
+            return $"{this.Name} scheitert an {talent}";
+        }
+
+        public string TestEigenschaft(string eigenschaft, int erschwernis = 0)
+        {
+            int temp = Dice.Roll();
+            int prop = (int)Math.Round(RandomMisc.Random(this.stDv, this.stDv));
+            
+            if (temp + erschwernis < prop)
+            {
+                return $"{this.Name} vollführt {eigenschaft} erfolgreich";
+            }
+
+            return $"{this.Name} scheitert an {eigenschaft}";
+        }
+
+        public string Angriff(string waffe, int erschwernis = 0)
+        {
+            int temp = Dice.Roll();
+
+            if (temp == 1)
+            {
+                return $"{this.Name} greift kritisch mit {waffe} an";
+            }
+
+            if (temp < erschwernis)
+            {
+                return $"{this.Name} greift mit {waffe} an";
+            }
+
+            return $"{this.Name} haut mit {waffe} daneben";
+        }
+
+        public string Parade(string waffe, int erschwernis = 0)
+        {
+            int temp = Dice.Roll();
+
+            if (temp == 1)
+            {
+                return $"{this.Name} pariert mit {waffe} meisterlich";
+            }
+
+            if (temp < erschwernis)
+            {
+                return $"{this.Name} pariert mit {waffe} an";
+            }
+
+            return $"{this.Name} schafft es nicht mit {waffe} zu parieren";
+        }
+
+        public string Fernkampf(string waffe, int erschwernis = 0)
+        {
+            int temp = Dice.Roll();
+
+            if (temp == 1)
+            {
+                return $"{this.Name} trifft kritisch mit {waffe}";
+            }
+
+            if (temp < erschwernis)
+            {
+                return $"{this.Name} greift mit {waffe} an";
+            }
+
+            return $"{this.Name} schießt mit {waffe} daneben";
+        }
+
+        public string TestZauber(string zauber, int erschwernis)
+        {
+            return TestTalent(zauber, erschwernis);
+        }
+    }
+}
diff --git a/DiscoBot/DSA_Game/Dsa.cs b/DiscoBot/DSA_Game/Dsa.cs
new file mode 100644
index 0000000..c645eb7
--- /dev/null
+++ b/DiscoBot/DSA_Game/Dsa.cs
@@ -0,0 +1,59 @@
+namespace DiscoBot.DSA_Game
+{
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Linq;
+
+    using DiscoBot.Audio;
+    using DiscoBot.Auxiliary;
+    using DiscoBot.DSA_Game.Characters;
+
+    using Discord.Commands;
+
+    public static class Dsa
+    {
+        public static ICommandContext GeneralContext { get; set; }
+
+        public static AudioService Service { get; set; }
+
+        public static Dictionary<string, string> Relation { get; set; } = new Dictionary<string, string>(); // dictionary to match the char
+
+        public static List<ICharacter> Chars { get; set; } = new List<ICharacter>();  // list of all characters
+
+        public static List<Talent> Talente { get; set; } = new List<Talent>();
+        
+        public static void Startup()
+        {
+            Relation.Add("The Doctor", "Numeri Illuminus"); // Relation
+            Relation.Add("Tardis", "Helga von Drachenei, Tausendsasserin"); // "Numeri Illuminus");
+            Relation.Add("DSA Bot", "Morla"); // "Felis Exodus Schattenwald");
+            Relation.Add("Morla", "Morla");
+            Relation.Add("Rhoktar", "Rhoktar4");
+            Relation.Add("MagicBro5", "Krenko");
+            Relation.Add("Nicolas", "Hartmut Reiher");
+            Relation.Add("TrueKuehli", "Ledur Torfinson");
+
+             relation.Add("Papo","Gwendelson");
+            //Relation.Add("Papo", "Pump aus der Gosse");
+
+            //Nachteile für LE, AE, MR
+            // Relation.Add("Papo", "Angilbert Arres");
+
+            //Vorteile für LE, AE, MR
+            //Relation.Add("Papo", "Beef");
+            //Relation.Add("Papo", "Astrallos");
+
+            Relation.Add("Potus", "Potus");
+            
+            // relation.Add("Papo", "Pump aus der Gosse");
+            foreach (var filename in Directory.GetFiles("helden", "*.xml"))
+            {
+                Chars.Add(new Character(filename));
+                (Chars.Last() as Character)?.Talente.Select(x => new Talent(x.Name, x.Probe, 0))
+                    .Where(c => !Talente.Exists(v => v.Name.Equals(c.Name))).ToList().ForEach(v => Talente.Add(v));
+            }
+
+            Talente = Talente.OrderBy(x => x.Name).ToList();
+        }
+    }
+}
\ No newline at end of file
diff --git a/DiscoBot/DSA_Game/KampfTalent.cs b/DiscoBot/DSA_Game/KampfTalent.cs
new file mode 100644
index 0000000..79703d5
--- /dev/null
+++ b/DiscoBot/DSA_Game/KampfTalent.cs
@@ -0,0 +1,18 @@
+namespace DiscoBot.DSA_Game
+{
+    public class KampfTalent
+    {
+        public KampfTalent(string name, int at, int pa)
+        {
+            this.Name = name;
+            this.At = at;
+            this.Pa = pa;
+        }
+
+        public string Name { get; set; }
+
+        public int At { get; set; }
+
+        public int Pa { get; set; }
+    }
+}
diff --git a/DiscoBot/DSA_Game/Talent.cs b/DiscoBot/DSA_Game/Talent.cs
new file mode 100644
index 0000000..fe097fa
--- /dev/null
+++ b/DiscoBot/DSA_Game/Talent.cs
@@ -0,0 +1,39 @@
+namespace DiscoBot.DSA_Game
+{
+    using System;
+
+    using DiscoBot.Auxiliary;
+
+    public class Talent // talent objekt
+    {
+        public Talent(string name, string probe, int value)
+        {
+            this.Name = name;
+            this.Probe = probe;
+            this.Value = value;
+        }
+
+        public string Name { get; set; }
+
+        public string Probe { get; set; }
+
+        public int Value { get; set; }
+        
+        public string[] GetEigenschaften() // turn XX/XX/XX into string[]{XX,XX,XX}
+        {
+            var temp = this.Probe.Split('/');
+            for (var index = 0; index < temp.Length; index++)
+            {
+                temp[index] = temp[index].Replace("/", string.Empty);
+            }
+
+            return temp;
+        }
+
+        public int CheckName(string quarry)
+        {
+            var sc = (StringComparer)new SpellCorrect();
+            return sc.Compare(quarry, this.Name);
+        }
+    }
+}
diff --git a/DiscoBot/DSA_Game/Vorteil.cs b/DiscoBot/DSA_Game/Vorteil.cs
new file mode 100644
index 0000000..493c4d1
--- /dev/null
+++ b/DiscoBot/DSA_Game/Vorteil.cs
@@ -0,0 +1,18 @@
+namespace DiscoBot.DSA_Game
+{
+    public class Vorteil // talent objekt
+    {
+        public Vorteil(string name, string value = "")
+        {
+            this.Name = name;
+            this.Value = value;
+           // this.Choice = choice;
+        }
+
+        public string Name { get; set; }
+
+        public string Value { get; set; }
+
+        //public string Choice { get; set; }
+    }
+}
diff --git a/DiscoBot/DSA_Game/Zauber.cs b/DiscoBot/DSA_Game/Zauber.cs
new file mode 100644
index 0000000..bf49a2e
--- /dev/null
+++ b/DiscoBot/DSA_Game/Zauber.cs
@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DiscoBot.DSA_Game
+{
+    public class Zauber : Talent
+    {
+        public Zauber(string name, string probe, int value, char complexity = 'A', string representation = "Magier")
+            : base(name, probe, value)
+        {
+            this.Complexity = complexity;
+            this.Representation = this.Representation;
+        }
+
+        public char Complexity { get; }
+
+        public string Representation { get; }
+    }
+}