Merge branch 'JDAv5'

# Conflicts:
#	src/main/java/AtlasGruppe/groupchange.java
#	src/main/java/core/Main.java

build.gradle

@@ -4,9 +4,10 @@ plugins {
 }
 
 
-version '0.2'
+version '0.10'
 
-def jdaVersion = '3.8.1_447'
+//def jdaVersion = '3.8.3_460'
+def jdaVersion = '5.0.0-alpha.20'
 
 
 apply plugin: 'java'
@@ -24,7 +25,9 @@ repositories {
 
 dependencies {
     compile "net.dv8tion:JDA:$jdaVersion"
-    compile "org.slf4j:slf4j-simple:1.6.1"
+    compile "org.slf4j:slf4j-simple:1.7.36"
+    compile group: 'mysql', name: 'mysql-connector-java', version: '5.1.6'
+    compile "org.json:json:20141113"
 }
 
 repositories {

shadowrun.cfg

@@ -0,0 +1,25 @@
+#Sun Feb 24 19:48:19 CET 2019
+de.error=\ Irgend was dummes ist passiert beim Verstehen von %command%
+de.resultText=\ %numberOfDice%w%diceart% %EdgeDice%\:\tErfolge\: %hits%\tMisserfolge\: %oneHits%
+de.resultTextExtent=\ %numberOfDice%w%diceart% %EdgeDice%\:\tErfolge\: %hits%\tMisserfolge\: %oneHits%
+de.dice=w
+de.error2=\ Irgendwas dummes ist passiert beim Verstehen von %command%
+de.noNegativ=\ es darf kein Negativen Wurf geben
+de.language= Ich schreibe nun Deutsch
+de.emptyCommand=\ der %command% befehl ben\u00F6tigt einen Wert
+
+en.error=\ I don't understanding %command%
+en.resultText=\ %numberOfDice%d%diceart% %EdgeDice%\:\tHit\: %hits%\tOnes\: %oneHits%
+en.dice=d
+en.error2=\ I don't understanding %command%
+en.noNegativ=\ there must not be a negative throw
+en.language= I write now English, maybe
+en.emptyCommand=\ The %command% command need a Value
+
+db.on=true
+db.typ=mysql
+db.host=localhost
+db.port=3306
+db.database=shadowrun_log
+db.name=root
+db.pw=

src/main/java/AtlasGruppe/groupchange.java

@@ -1,120 +0,0 @@
-package AtlasGruppe;
-
-import core.Config;
-import net.dv8tion.jda.core.entities.ChannelType;
-import net.dv8tion.jda.core.entities.Member;
-import net.dv8tion.jda.core.entities.Role;
-import net.dv8tion.jda.core.entities.User;
-import net.dv8tion.jda.core.entities.impl.RoleImpl;
-import net.dv8tion.jda.core.events.message.MessageReceivedEvent;
-import net.dv8tion.jda.core.hooks.ListenerAdapter;
-import net.dv8tion.jda.core.exceptions.InsufficientPermissionException;
-
-
-public class groupchange extends ListenerAdapter {
-
-    private String prefixPromote;
-    private String prefixDegradation;
-    private Config config;
-
-
-    public groupchange(Config config) {
-        this.prefixPromote = "!befördern";
-        this.prefixDegradation = "!degradieren";
-        this.config = config;
-    }
-
-    @Override
-    public void onMessageReceived(MessageReceivedEvent event) {
-        if ((!event.getMessage().getContentRaw().startsWith(this.prefixPromote) && !event.getMessage().getContentRaw().startsWith(this.prefixDegradation)) || event.getChannelType() != ChannelType.TEXT) {
-            return;
-        }
-
-        User author = event.getAuthor();
-        if (!author.isBot()) {
-            if (event.getMessage().getContentRaw().startsWith(this.prefixPromote + " ")) {
-                this.changeGroup(event, true);
-            } else if (event.getMessage().getContentRaw().startsWith(this.prefixDegradation + " ")) {
-                this.changeGroup(event, false);
-            }
-        }
-    }
-
-    private void changeGroup(MessageReceivedEvent event, Boolean promote) {
-
-        Member MentionedMember;
-        User MentionedUser;
-        boolean roleCheck;
-
-        try {
-
-            Role targetRole = event.getGuild().getRolesByName(config.targetRole, true).get(0);
-            Role authorizedRole = event.getGuild().getRolesByName(config.authorizedRole, true).get(0);
-
-            if (event.getMessage().getMentionedUsers().isEmpty()) {
-                event.getChannel().sendMessage(event.getMember().getAsMention() + " " +config.userNotFound).queue();
-                return;
-            }
-
-            MentionedUser = event.getMessage().getMentionedUsers().get(0);
-
-            if (MentionedUser.isBot()) { // Ziel darf kein Bot sein
-                event.getChannel().sendMessage(event.getMember().getAsMention() + " Finger weg von den Bots!").queue();
-                return;
-            }
-
-            MentionedMember = event.getGuild().getMemberById(MentionedUser.getId());
-
-            roleCheck = false;
-            for (Object x : event.getMember().getRoles().toArray()) {
-                if (((RoleImpl) x).getId().equals(authorizedRole.getId())) { // hat Absender die Notwendig Gruppe
-                    roleCheck = true;
-                    break;
-                }
-            }
-            if (!roleCheck) {
-                event.getChannel().sendMessage(event.getMember().getAsMention() + " " + config.noPrivilegs).queue();
-                return;
-            }
-
-            if (promote) {
-                roleCheck = false;
-                for (Object x : MentionedMember.getRoles().toArray()) {
-                    if (((RoleImpl) x).getId().equals(targetRole.getId())) { // hat Ziel bereits die Gruppe?
-                        roleCheck = true;
-                        break;
-                    }
-                }
-                if (roleCheck) {
-
-                    event.getChannel().sendMessage(event.getMember().getAsMention() + " " + config.hasGroup.replace("%Member%", MentionedMember.getEffectiveName()).replace("%Group%", targetRole.getName())).queue();
-                    return;
-                }
-                event.getGuild().getController().addSingleRoleToMember(MentionedMember, targetRole).queue();
-                event.getChannel().sendMessage(event.getMember().getAsMention() + " " + config.becameGroup.replace("%Member%", MentionedMember.getEffectiveName()).replace("%Group%", targetRole.getName())).queue();
-            } else {
-                roleCheck = false;
-                for (Object x : MentionedMember.getRoles().toArray()) {
-                    if (((RoleImpl) x).getId().equals(targetRole.getId())) { // hat Ziel bereits die Gruppe?
-                        roleCheck = true;
-                        break;
-                    }
-                }
-                if (!roleCheck) {
-                    event.getChannel().sendMessage(event.getMember().getAsMention() + " " + config.notInGroup.replace("%Member%", MentionedMember.getEffectiveName()).replace("%Group%", targetRole.getName())).queue();
-                    return;
-                }
-                event.getGuild().getController().removeSingleRoleFromMember(MentionedMember, targetRole).queue();
-                event.getChannel().sendMessage(event.getMember().getAsMention() + " " + config.removeGroup.replace("%Member%", MentionedMember.getEffectiveName()).replace("%Group%", targetRole.getName())).queue();
-            }
-
-        } catch (InsufficientPermissionException e) {
-            event.getChannel().sendMessage(event.getMember().getAsMention() + " " + e.getMessage()).queue();
-        } catch (Exception e) {
-            //System.out.println("problem: "+e.getMessage());
-        }
-
-    }
-
-
-}

src/main/java/DB/base.java

@@ -0,0 +1,96 @@
+package DB;
+
+import net.dv8tion.jda.api.JDA;
+
+import javax.security.auth.login.LoginException;
+import java.io.FileInputStream;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.Properties;
+
+public  class base {
+
+
+    private Connection conn;
+    private String typ;
+    private String host;
+    private String port;
+    private String database;
+    private String name;
+    private String pw;
+
+
+
+
+    private boolean active;
+
+    protected base() {
+        FileInputStream input = null;
+        Properties config = new Properties();
+        active = true;
+
+        try {
+            input = new FileInputStream("shadowrun.cfg");
+            config.load(input);
+            if(!config.containsKey("db.typ") || (config.containsKey("db.on") && !config.getProperty("db.on").equals("true"))) {
+                active = false;
+            }
+
+            typ = config.getProperty("db.typ");
+            host = config.getProperty("db.host");
+            port = config.getProperty("db.port");
+            database = config.getProperty("db.database");
+            name = config.getProperty("db.name");
+            pw = config.getProperty("db.pw");
+
+            open();
+            close();
+            //rs.fetchSize;
+        }
+        catch (Exception e) {
+            active = false;
+        }
+    }
+
+    protected void open() {
+        if(!active)
+            return;
+        try {
+
+                conn = DriverManager.getConnection("jdbc:" + typ + "://" + host + ":" + port + "?useUnicode=true&characterEncoding=utf-8", name, pw);
+                ResultSet rs = conn.prepareStatement("SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = '" + database + "'").executeQuery();
+                rs.last();
+                if(rs.getRow() == 1) {
+                    conn.prepareStatement("use "+ database).executeQuery();
+                }
+        }
+        catch (SQLException e) {
+            active = false;
+            //e.printStackTrace();
+        }
+    }
+
+    protected void close() {
+        if(!active)
+            return;
+        try {
+            if (!conn.isClosed())
+                conn.close();
+        }
+        catch (SQLException e) {
+            active = false;
+            e.printStackTrace();
+        }
+    }
+
+    protected boolean isActive() {
+        return active;
+    }
+
+    protected Connection getConn() {
+        return conn;
+    }
+}
+

src/main/java/Earthdawn/dice.java

@@ -0,0 +1,479 @@
+package Earthdawn;
+
+import Shadowrun.db_connect;
+import Shadowrun.help;
+import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.entities.User;
+import net.dv8tion.jda.api.entities.channel.ChannelType;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import net.dv8tion.jda.api.events.message.react.MessageReactionAddEvent;
+import net.dv8tion.jda.api.hooks.ListenerAdapter;
+
+import java.awt.*;
+import java.lang.reflect.Array;
+import java.security.SecureRandom;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Random;
+import java.util.concurrent.ThreadLocalRandom;
+
+public class dice extends ListenerAdapter {
+
+    private String prefixSr;
+    private String prefixIni;
+
+
+    private language langDe = new language("de");
+    private language langEn = new language("en");
+
+    private help helpDe = new help("de");
+    private help helpEn = new help("En");
+
+    private language activLang;
+    private help activHelp;
+
+    private db_connect db;
+
+    private Map<String, String> channelList = new HashMap<>();
+
+    private step dieRoll = new step();
+
+
+    public dice() {
+        this.prefixSr = "/ed";
+        //this.prefixIni = "/ini";
+
+
+        helpDe.add("Alle Befehle können in einen Channel geschrieben werden oder per Direkt Nachricht gesendet");
+        helpDe.add(this.prefixSr + "Zahl", "Würfelt Zahl x W6. Gewürfelte 5. und 6. Werden als Erfolge gezählt, 1. als Misserfolge.\n" +
+                "Erreicht oder übersteigt die Anzhal der 1. die hälfte der gewürfelten Würfel, zählt dies als ein Patzer. Gibt es mind. 1 Erfolg wird die Markierung der Ausgabe Gelb." +
+                "wird aber kein Erfolg gewürfelt zählt dies als Kritischer Patzer und die Markierung wird Rot **Wichtig: Vor- und Nachteile die Einfluss auf die Patzer Changse haben werden nicht berücksichtigt");
+
+        helpDe.add(this.prefixSr + "+ Zahl", "Gleich wie bei " + this.prefixSr + "Zahl. Mit dem Unterschied dass alle gewürfelten 6. ein zuzätlichen Würfel generien.");
+
+        helpDe.add(this.prefixSr + " Zahl_1 + Zahl_2", "Würfelt Zahl_2 x W6 und addiert Zahl_1 hinzu, um die Initative zu bestimmen");
+
+        //helpDe.add(this.prefixIni + " Zahl_1 + Zahl_2", "Synonym für " + this.prefixSr + " Zahl_1 + Zahl_2");
+
+
+        this.db = new db_connect();
+    }
+
+    @Override
+    public void onMessageReceived(MessageReceivedEvent event) {
+        if ((!event.getMessage().getContentRaw().startsWith(this.prefixSr))
+                || (event.getChannelType() != ChannelType.TEXT && event.getChannelType() != ChannelType.PRIVATE)) {
+            return;
+        }
+
+        if(!channelList.containsKey(event.getChannel().getId())) {
+            Map<String, String> Einstellungen = db.getChannelSettings(event.getChannel().getId());
+            channelList.put(event.getChannel().getId(), Einstellungen.get("lang").toString());
+        }
+        switch (channelList.get(event.getChannel().getId())) {
+            case "de":
+                activLang = langDe;
+                break;
+            case "en":
+                activLang = langEn;
+                break;
+            default:
+                activLang = langDe;
+
+        }
+        User author = event.getAuthor();
+        if (!author.isBot() || true) {
+            if (event.getMessage().getContentRaw().startsWith(this.prefixSr))
+                this.srroll(event);
+        }
+    }
+
+
+    /**
+     * rolltest
+     *
+     * @param event JDA Event
+     */
+    private void rollTest(MessageReceivedEvent event) {
+
+        EmbedBuilder test = new EmbedBuilder();
+        test.setTitle("Das ist ein Test");
+        test.setColor(Color.red);
+        test.setDescription("Text " + getAsMention(event));
+
+
+
+
+        int[] verteilung = new int[6];
+        int[] verteilung2 = new int[6];
+        int[] verteilung3 = new int[6];
+        int dice1, dice2, dice3;
+
+        try {
+            String[] MsgParts_exl_Mention = event.getMessage().getContentRaw().split(" ");
+            int rounds = Integer.parseInt(MsgParts_exl_Mention[1]);
+            if(rounds <= 0) {
+                event.getChannel().sendMessage("Nope").queue();
+                return;
+            }
+            for(int i = 0; i < rounds; i++) {
+                dice1 = new Random().nextInt(6);
+                dice2 = new SecureRandom().nextInt(6);
+                //dice3 = new ThreadLocalRandom().current().nextInt(6);
+                dice3 = ThreadLocalRandom.current().nextInt(0, 6);
+                verteilung[dice1]++;
+                verteilung2[dice2]++;
+                verteilung3[dice3]++;
+            }
+            for(int i = 0; i < 6; i++) {
+                float pro = verteilung[i]*100f/rounds;
+                test.addField(Integer.toString(i+1), Integer.toString(verteilung[i]) + " - " + String.format("%.2f", pro) + "%", true);
+            }
+            test.addBlankField(false);
+            for(int i = 0; i < 6; i++) {
+                float pro = verteilung2[i]*100f/rounds;
+                test.addField(Integer.toString(i+1), Integer.toString(verteilung2[i]) + " - " + String.format("%.2f", pro) + "%", true);
+            }
+            test.addBlankField(false);
+            for(int i = 0; i < 6; i++) {
+                float pro = verteilung3[i]*100f/rounds;
+                test.addField(Integer.toString(i+1), Integer.toString(verteilung3[i]) + " - " + String.format("%.2f", pro) + "%", true);
+            }
+            event.getChannel().sendMessage(test.build().toString()).queue();
+
+        }
+        catch (NumberFormatException e) {
+            event.getChannel().sendMessage("Nope").queue();
+        }
+        catch (Exception e) {
+            System.out.println("problem: " + e.getMessage());
+        }
+
+    }
+    /**
+     * rolltest
+     *
+     * @param event JDA Event
+     */
+    private void srroll(MessageReceivedEvent event) {
+
+        EmbedBuilder outputBox = new EmbedBuilder();
+
+        int[] verteilung = new int[6];
+        int dice1;
+        int numberOfDice = 1;
+        int diceart = 6;
+        StringBuilder result = new StringBuilder("");
+
+        int hits = 0;
+        boolean glitches = false;
+
+        boolean karma = false;
+        boolean doppelkarma = false;
+        boolean weiheJunger = false;
+        boolean doppelweiheJunger = false;
+        boolean weiheAnheanger = false;
+        boolean doppelweiheAnheanger = false;
+        boolean weiheVorbild = false;
+        boolean doppelweiheVorbild = false;
+
+        int stufe = 0;
+        int modifier = 1;
+
+        try {
+            dieRoll.reset();
+           // Alte Erkennung für Karma ect
+                // Prüfen ob Karma wurf
+            if(event.getMessage().getContentRaw().startsWith(this.prefixSr+"+") || event.getMessage().getContentRaw().startsWith(this.prefixSr+" +")) {
+                karma = true;
+            }
+
+            if(event.getMessage().getContentRaw().startsWith(this.prefixSr+"++") || event.getMessage().getContentRaw().startsWith(this.prefixSr+" ++")) {
+                doppelkarma = true;
+            }
+            // Prüfen ob weihepunkte wurf
+            if(event.getMessage().getContentRaw().startsWith(this.prefixSr+"j") || event.getMessage().getContentRaw().startsWith(this.prefixSr+" j")) {
+                weiheJunger = true;
+            }
+
+            if(event.getMessage().getContentRaw().startsWith(this.prefixSr+"jj") || event.getMessage().getContentRaw().startsWith(this.prefixSr+" jj")) {
+                doppelweiheJunger = true;
+            }
+
+            if(event.getMessage().getContentRaw().startsWith(this.prefixSr+"a") || event.getMessage().getContentRaw().startsWith(this.prefixSr+" a")) {
+                weiheAnheanger = true;
+            }
+
+            if(event.getMessage().getContentRaw().startsWith(this.prefixSr+"aa") || event.getMessage().getContentRaw().startsWith(this.prefixSr+" aa")) {
+                doppelweiheAnheanger = true;
+            }
+
+            if(event.getMessage().getContentRaw().startsWith(this.prefixSr+"v") || event.getMessage().getContentRaw().startsWith(this.prefixSr+" v")) {
+                weiheVorbild = true;
+            }
+
+            if(event.getMessage().getContentRaw().startsWith(this.prefixSr+"vv") || event.getMessage().getContentRaw().startsWith(this.prefixSr+" vv")) {
+                doppelweiheVorbild = true;
+            }
+
+            // korrikiert Karama eingabe von /ed + zu  /ed+
+            String ContentRaw = event.getMessage().getContentRaw();
+            if(event.getMessage().getContentRaw().startsWith(this.prefixSr+" +")) {
+                ContentRaw = ContentRaw.replace(this.prefixSr+" +", this.prefixSr+"+ ").replace("  ", " ");
+            }
+
+            if(event.getMessage().getContentRaw().startsWith(this.prefixSr+" j")) {
+                ContentRaw = ContentRaw.replace(this.prefixSr+" j", this.prefixSr+"j ").replace("  ", " ");
+            }
+
+            if(event.getMessage().getContentRaw().startsWith(this.prefixSr+" a")) {
+                ContentRaw = ContentRaw.replace(this.prefixSr+" a", this.prefixSr+"a ").replace("  ", " ");
+            }
+
+            if(event.getMessage().getContentRaw().startsWith(this.prefixSr+" v")) {
+                ContentRaw = ContentRaw.replace(this.prefixSr+" v", this.prefixSr+"v ").replace("  ", " ");
+            }
+            String[] MsgParts = ContentRaw.split(" ", 2);
+            if(MsgParts.length < 2) { // Leerer Befehl
+                String message = activLang.emptyCommand;
+                message = message.replace("%command%", this.prefixSr);
+                event.getChannel().sendMessage(getAsMention(event) + message).queue();
+                return;
+            }
+            String DicePart = MsgParts[1].trim().toLowerCase();
+            if(MsgParts[1].trim().matches(".*[^0-9].*")) { // es wurden andere zeichen als Zahlen gefunden
+
+                if(DicePart.equals("de")) {
+                    activLang = langDe;
+                    channelList.put(event.getChannel().getId(), "de");
+                    event.getChannel().sendMessage(getAsMention(event) + activLang.language).queue();
+                    return;
+                }
+                else if(DicePart.equals("en")) {
+                    activLang = langEn;
+                    channelList.put(event.getChannel().getId(), "en");
+                    event.getChannel().sendMessage(getAsMention(event) + activLang.language).queue();
+                    return;
+                }
+
+
+                for (int i = 0; i < DicePart.length(); i++) {
+                    if (DicePart.charAt(i) == 'k') {
+                        dieRoll.addKarma(1);
+                    }
+                    else if (DicePart.charAt(i) == 'j') {
+                        dieRoll.addWeiheA(1);
+                    }
+                    else if (DicePart.charAt(i) == 'a') {
+                        dieRoll.addWeiheJ(1);
+                    }
+                    else if (DicePart.charAt(i) == 'v') {
+                        dieRoll.addWeiheV(1);
+                    }
+                }
+                DicePart = DicePart.replace("k", "");
+                DicePart = DicePart.replace("j", "");
+                DicePart = DicePart.replace("a", "");
+                DicePart = DicePart.replace("v", "");
+
+                String[] iniParts = DicePart.split("[\\+\\-]", 2);
+                messageInterpreter mI = new messageInterpreter(event, activLang);
+                rollStufe(Integer.parseInt(iniParts[0].replaceAll("[^0-9]", "")));
+                if(iniParts.length > 1) { // Nachricht hat kein + Zeichen
+
+                    rollStufe(Integer.parseInt(iniParts[0].replaceAll("[^0-9]", "")));
+                    if(DicePart.matches("\\-")) // Prüft auf Negativen Modifizier wenn Ja
+                        modifier = -1;
+                    dieRoll.addModifier(Integer.parseInt(iniParts[1].trim())*modifier);
+                }
+            }
+            else {
+                try {
+                    rollStufe(Integer.parseInt(DicePart));
+                }
+                catch (NumberFormatException e) {
+                    String message = activLang.error;
+                    message = message.replace("%command%", MsgParts[1].trim());
+                    event.getChannel().sendMessage(getAsMention(event) + message).queue();
+                    return;
+                }
+            }
+
+            if(karma)
+                dieRoll.addKarma(1);
+            if(doppelkarma)
+                dieRoll.addKarma(1);
+
+            if(weiheAnheanger)
+                dieRoll.addWeiheA(1);
+            if(doppelweiheAnheanger)
+                dieRoll.addWeiheA(1);
+
+            if(weiheJunger)
+                dieRoll.addWeiheJ(1);
+            if(doppelweiheJunger)
+                dieRoll.addWeiheJ(1);
+
+            if(weiheVorbild)
+                dieRoll.addWeiheV(1);
+            if(doppelweiheVorbild)
+                dieRoll.addWeiheV(1);
+
+            dieRoll.roll();
+
+            if(dieRoll.isGlitches()) { // Patzer
+                outputBox.setColor(Color.red);
+            }
+            else { // Erfolg
+                outputBox.setColor(Color.green);
+            }
+
+            String message = activLang.resultText;
+            message = "%rolls%: %hits%";
+            message = message.replace("%rolls%", dieRoll.getDiceStructur()).replace("%hits%", String.valueOf(dieRoll.getResultInt()));
+
+            outputBox.setTitle(getEffectiveName(event) + message);
+            outputBox.setDescription("(" +  dieRoll.getResultStructur() + ")");
+
+            event.getChannel().sendMessageEmbeds(outputBox.build()).queue();
+
+        }
+        catch (NumberFormatException e) {
+            event.getChannel().sendMessage("Nope").queue();
+        }
+        catch (Exception e) {
+            System.out.println("problem: " + e.getMessage());
+        }
+
+    }
+
+
+
+    private String getEffectiveName(MessageReceivedEvent event) {
+        if(event.getMember() == null) {
+            return "";
+        }
+        return event.getMember().getEffectiveName() + " ";
+    }
+
+    private String getAsMention(MessageReceivedEvent event) {
+        if(event.getMember() == null) {
+            return "";
+        }
+        return event.getMember().getAsMention() + " ";
+    }
+
+    private void rollStufe(int stufe) {
+
+        switch (stufe) {
+            case 1:
+                dieRoll.setW4(1).setModifier(-2);
+                break;
+            case 2:
+                dieRoll.setW4(1).setModifier(-1);
+                break;
+            case 3:
+                dieRoll.setW4(1);
+                break;
+            case 4:
+                dieRoll.setW6(1);
+                break;
+            case 5:
+                dieRoll.setW8(1);
+                break;
+            case 6:
+                dieRoll.setW10(1);
+                break;
+            case 7:
+                dieRoll.setW12(1);
+                break;
+            case 8:
+                dieRoll.setW6(2);
+                break;
+            case 9:
+                dieRoll.setW8(1).setW6(1);
+                break;
+            case 10:
+                dieRoll.setW8(2);
+                break;
+            case 11:
+                dieRoll.setW10(1).setW8(1);
+                break;
+            case 12:
+                dieRoll.setW10(2);
+            case 13:
+                dieRoll.setW12(1).setW10(1);
+                break;
+            case 14:
+                dieRoll.setW12(2);
+                break;
+            case 15:
+                dieRoll.setW12(1).setW6(2);
+                break;
+            case 16:
+                dieRoll.setW12(1).setW8(1).setW6(1);
+                break;
+            case 17:
+                dieRoll.setW12(1).setW8(2);
+                break;
+            case 18:
+                dieRoll.setW12(1).setW10(1).setW8(1);
+                break;
+            default:
+                int w20 = 0;
+                w20 = (int) ((stufe-8)/11);
+                switch ((stufe-8)%11) {
+                    case 0:
+                        dieRoll.setW20(w20).setW6(2);
+                        break;
+                    case 1:
+                        dieRoll.setW20(w20).setW8(1).setW6(1);
+                        break;
+                    case 2:
+                        dieRoll.setW20(w20).setW8(2);
+                        break;
+                    case 3:
+                        dieRoll.setW20(w20).setW10(1).setW8(1);
+                        break;
+                    case 4:
+                        dieRoll.setW20(w20).setW10(2);
+                        break;
+                    case 5:
+                        dieRoll.setW20(w20).setW12(1).setW10(1);
+                        break;
+                    case 6:
+                        dieRoll.setW20(w20).setW12(2);
+                        break;
+                    case 7:
+                        dieRoll.setW20(w20).setW12(1).setW6(2);
+                        break;
+                    case 8:
+                        dieRoll.setW20(w20).setW12(1).setW8(1).setW6(1);
+                        break;
+                    case 9:
+                        dieRoll.setW20(w20).setW12(1).setW8(2);
+                        break;
+                    case 10:
+                        dieRoll.setW20(w20).setW12(1).setW10(1).setW8(1);
+                        break;
+                }
+
+        }
+
+
+        /*
+        diceList[30] = "2W20+2W6";
+        diceList[31] = "2W20+W8+W6";
+        diceList[32] = "2W20+2W8";
+        diceList[33] = "2W20+W10+W8";
+        diceList[34] = "2W20+2W10";
+        diceList[35] = "2W20+W12+W10";
+        diceList[36] = "2W20+2W12";
+        diceList[37] = "2W20+W12+2W6";
+        diceList[38] = "2W20+W12+W8+W6";
+        diceList[39] = "2W20+W12+2W8";
+        diceList[40] = "2W20+W12+W10+W8";
+        */
+
+    }
+}

src/main/java/Earthdawn/language.java

@@ -0,0 +1,89 @@
+package Earthdawn;
+
+import java.io.*;
+import java.util.Properties;
+
+
+public class language {
+
+    public String language = "Deutsch";
+    public String emptyCommand = " der %command% befehl benötigt einen Wert";
+    public String error = " Irgend was dummes ist passiert beim Verstehen von %command%";
+    public String error2 = " Irgend was dummes ist passiert beim Verstehen von %command%";
+    public String noNegativ = " es darf kein Negativen Wurf geben";
+    public String dice = "w";
+    public String resultText = " %numberOfDice%w%diceart% %EdgeDice%:\tErfolge: %hits%\tMisserfolge: %oneHits%";
+    public String basisresultText = " %numberOfDice%w%diceart%:";
+
+    public language() {
+        this.readConfig();
+    }
+
+    /**
+     *
+     * @param lang Srache
+     */
+    public language(String lang) {
+        this.readConfig(lang);
+    }
+
+    public void readConfig() {
+        this.readConfig("de");
+    }
+    public void readConfig(String lang) {
+        FileInputStream input = null;
+        OutputStream output = null;
+        Properties config = new Properties();
+        try {
+            File f = new File("shadowrun.cfg");
+            if (f.isFile() && f.canRead()) {
+
+                input = new FileInputStream("shadowrun.cfg");
+                config.load(input);
+                if(config.containsKey(lang + ".language"))
+                    this.language = config.getProperty(lang + ".language");
+
+                if(config.containsKey(lang + ".emptyCommand"))
+                    this.emptyCommand = config.getProperty(lang + ".emptyCommand");
+                if(config.containsKey(lang + ".error"))
+                    this.error = config.getProperty(lang + ".error");
+                if(config.containsKey(lang + ".error2"))
+                    this.error2 = config.getProperty(lang + ".error2");
+                if(config.containsKey(lang + ".noNegativ"))
+                    this.noNegativ = config.getProperty(lang + ".noNegativ");
+                if(config.containsKey(lang + ".dice"))
+                    this.dice = config.getProperty(lang + ".dice");
+                if(config.containsKey(lang + ".resultText"))
+                    this.resultText = config.getProperty(lang + ".resultText");
+                if(config.containsKey(lang + ".basisresultText"))
+                    this.resultText = config.getProperty(lang + ".basisresultText");
+
+            }
+            else {
+                output = new FileOutputStream("shadowrun.cfg");
+                config.setProperty(lang + ".language", this.language);
+                config.setProperty(lang + ".emptyCommand", this.emptyCommand);
+                config.setProperty(lang + ".error", this.error);
+                config.setProperty(lang + ".error2", this.error2);
+                config.setProperty(lang + ".noNegativ", this.noNegativ);
+                config.setProperty(lang + ".dice", this.dice);
+                config.setProperty(lang + ".resultText", this.resultText);
+                config.setProperty(lang + ".basisresultText", this.basisresultText);
+                config.store(output, null);
+
+            }
+        } catch (Exception e) {
+
+        }
+        finally {
+            if (input != null) {
+                try {
+                    input.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
+

src/main/java/Earthdawn/messageInterpreter.java

@@ -0,0 +1,124 @@
+package Earthdawn;
+
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+
+import java.util.Random;
+import java.util.Scanner;
+
+public class messageInterpreter {
+
+    private Integer diceart = 6;
+    private Integer numberOfDice = 1;
+    private Integer typ = 0;
+    private Integer intResult = 0;
+
+    private language activLang;
+    private MessageReceivedEvent event;
+    boolean glitches = true;
+
+    public Integer getDiceart() {
+        return diceart;
+    }
+
+    public Integer getNumberOfDice() {
+        return numberOfDice;
+    }
+
+    public Integer getIntResult() {
+        return intResult;
+    }
+
+
+
+    public boolean isNum() {
+        if(typ == 1) {
+            return  true;
+        }
+        return false;
+    }
+
+    public boolean isDice() {
+        if(typ == 2) {
+            return  true;
+        }
+        return false;
+    }
+    /**
+     *
+     * @param event JDA Event
+     * @param activLang Aktive Sprache
+     */
+    public messageInterpreter(MessageReceivedEvent event, language activLang) {
+        this.event = event;
+        this.activLang = activLang;
+    }
+    private void reset() {
+        diceart = 6;
+        numberOfDice = 1;
+        typ = 0;
+        intResult = 0;
+    }
+    public void inputInterpreter(String Input) {
+        reset();
+        Scanner sc = new Scanner(Input.trim());
+
+        StringBuilder resultString = new StringBuilder("");
+
+        Integer PartValue = 0;
+
+
+        int dice1;
+
+        if(sc.hasNextInt()) { // ist eine Zahl
+            typ = 1;
+            intResult = Integer.parseInt(Input.trim());
+            return;
+        }
+        else {
+            String[] MalusParts= Input.trim().toLowerCase().replace(" ", "").split("\\-");
+            for (String MalusPart : MalusParts) {
+                String[] Parts = MalusPart.split("\\+");
+                for (String Part : Parts ) {
+                    PartValue = 0;
+                    sc = new Scanner(Part);
+                    if(sc.hasNextInt()) {
+                        PartValue += Integer.parseInt(Part);
+                    }
+                    else {
+                        if (Part.matches("([0-9]*)[dw]([0-9].*)")) { // format besteh aus (Zahlen)d(Zahlen) oder (Zahlen)w(Zahlen)
+                            String[] diceInterpreter = Part.split("[wd]");
+                            try {
+                                diceart = Integer.parseInt(diceInterpreter[1]);
+                                numberOfDice = Integer.parseInt(diceInterpreter[0]);
+                                for(int i = 0; i < numberOfDice; i++) {
+                                    dice1 = new Random().nextInt(diceart);
+                                    resultString.append(dice1+1);
+                                    resultString.append(" ");
+                                    PartValue += dice1+1;
+                                    if(dice1 > 0)
+                                        glitches = false;
+                                }
+
+                            } catch (NumberFormatException e) {
+                                String message = activLang.error;
+                                message = message.replace("%command%", Input.trim().toLowerCase());
+                                typ = -1;
+                                throw new IllegalArgumentException( message );
+                            }
+                        }
+                        else {
+                            String message = activLang.error;
+                            message = message.replace("%command%", Input.trim().toLowerCase());
+                            typ = -1;
+                            throw new IllegalArgumentException( message );
+                        }
+                    }
+                }
+                if(intResult == 0)
+                    intResult = PartValue;
+                else
+                    intResult -= PartValue;
+            }
+        }
+    }
+}

src/main/java/Earthdawn/step.java

@@ -0,0 +1,292 @@
+package Earthdawn;
+
+import java.util.Random;
+
+public class step {
+
+    private int w4;
+    private int w6;
+    private int w8;
+    private int w10;
+    private int w12;
+    private int w20;
+    private int karma;
+    private int weiheA;
+    private int weiheJ;
+    private int weiheV;
+
+    private boolean glitches = true;
+    private String diceStructur = "";
+    private String diceResult = "";
+    private int resultInt = 0;
+
+    private int modifier = 0;
+
+    StringBuilder resultStructur = new StringBuilder("");
+
+
+    public int getW4() {
+        return w4;
+    }
+
+    public step setW4(int w4) {
+        this.w4 = w4;
+        return this;
+    }
+
+    public int getW6() {
+        return w6;
+    }
+
+    public step setW6(int w6) {
+        this.w6 = w6;
+        return this;
+    }
+
+    public int getW8() {
+        return w8;
+    }
+
+    public step setW8(int w8) {
+        this.w8 = w8;
+        return this;
+    }
+
+    public int getW10() {
+        return w10;
+    }
+
+    public step setW10(int w10) {
+        this.w10 = w10;
+        return this;
+    }
+
+    public int getW12() {
+        return w12;
+    }
+
+    public step setW12(int w12) {
+        this.w12 = w12;
+        return this;
+    }
+
+    public int getW20() {
+        return w20;
+    }
+
+    public step setW20(int w20) {
+        this.w20 = w20;
+        return this;
+    }
+
+    public void addW4(int w4) {
+        this.w4 += w4;
+    }
+
+    public void addW6(int w6) {
+        this.w6 += w6;
+    }
+
+    public void addW8(int w8) {
+        this.w8 += w8;
+    }
+
+    public void addW10(int w10) {
+        this.w10 += w10;
+    }
+
+    public void addW12(int w12) {
+        this.w12 += w12;
+    }
+
+    public void addW20(int w20) {
+        this.w20 += w20;
+    }
+
+    public int getModifier() {
+        return modifier;
+    }
+
+    public int getKarma() {
+        return karma;
+    }
+
+    public step setKarma(int karma) {
+        this.karma = karma;
+        return this;
+    }
+
+    public step addKarma(int karma) {
+        this.karma += karma;
+        return this;
+    }
+
+    public step addWeiheJ(int weiheJ) {
+        this.weiheJ += weiheJ;
+        return this;
+    }
+
+    public step addWeiheA(int weiheA) {
+        this.weiheA += weiheA;
+        return this;
+    }
+    public step addWeiheV(int weiheV) {
+        this.weiheV += weiheV;
+        return this;
+    }
+
+    public step setModifier(int modifier) {
+        this.modifier = modifier;
+        return this;
+    }
+
+    public step addModifier(int modifier) {
+        this.modifier += modifier;
+        return this;
+    }
+
+    public boolean isGlitches() {
+        return glitches;
+    }
+
+    public String getDiceStructur() {
+        return diceStructur;
+    }
+
+    public String getDiceResult() {
+        return diceResult;
+    }
+
+    public int getResultInt() {
+        return resultInt;
+    }
+
+
+    public String getResultStructur() {
+        return resultStructur.toString();
+    }
+
+    public step reset() {
+        w4 = 0;
+        w6 = 0;
+        w8 = 0;
+        w10 = 0;
+        w12 = 0;
+        w20 = 0;
+        karma = 0;
+        weiheJ = 0;
+        weiheA = 0;
+        weiheV = 0;
+
+        modifier = 0;
+
+        glitches = true;
+        diceStructur = "";
+        diceResult = "";
+        resultInt = 0;
+        resultStructur = new StringBuilder("");
+        return this;
+    }
+
+    public void roll() {
+
+        StringBuilder resultConstruction = new StringBuilder("");
+
+        if(w4 > 0) {
+            rollDice(w4, 4);
+            if(resultConstruction.length() > 0)
+                resultConstruction.append("+");
+            resultConstruction.append(w4).append("w4");
+        }
+        if(w6 > 0) {
+            rollDice(w6, 6);
+            if(resultConstruction.length() > 0)
+                resultConstruction.append("+");
+            resultConstruction.append(w6).append("w6");
+        }
+        if(w8 > 0) {
+            rollDice(w8, 8);
+            if(resultConstruction.length() > 0)
+                resultConstruction.append("+");
+            resultConstruction.append(w8).append("w8");
+        }
+        if(w10 > 0) {
+            rollDice(w10, 10);
+            if(resultConstruction.length() > 0)
+                resultConstruction.append("+");
+            resultConstruction.append(w10).append("w10");
+        }
+        if(w12 > 0) {
+            rollDice(w12, 12);
+            if(resultConstruction.length() > 0)
+                resultConstruction.append("+");
+            resultConstruction.append(w12).append("w12");
+        }
+        if(w20 > 0) {
+            rollDice(w20, 20);
+            if(resultConstruction.length() > 0)
+                resultConstruction.append(" + ");
+            resultConstruction.append(w20).append("w20");
+        }
+
+        if(karma > 0) {
+            rollDice(karma, 6);
+            if(resultConstruction.length() > 0)
+                resultConstruction.append(" + ");
+            resultConstruction.append(karma).append("w6");
+        }
+
+        if(weiheJ > 0) {
+            rollDice(weiheJ, 4);
+            if(resultConstruction.length() > 0)
+                resultConstruction.append(" + ");
+            resultConstruction.append(weiheJ).append("w4");
+        }
+
+        if(weiheA > 0) {
+            rollDice(weiheA, 6);
+            if(resultConstruction.length() > 0)
+                resultConstruction.append(" + ");
+            resultConstruction.append(weiheA).append("w6");
+        }
+
+        if(weiheV > 0) {
+            rollDice(weiheV, 8);
+            if(resultConstruction.length() > 0)
+                resultConstruction.append(" + ");
+            resultConstruction.append(weiheV).append("w8");
+        }
+
+        if(modifier != 0) {
+            resultInt += modifier;
+            if(modifier > 0)
+                resultConstruction.append(" + ");
+
+
+            resultConstruction.append(modifier);
+        }
+
+        diceStructur = resultConstruction.toString();
+
+        if(resultInt <= 0)
+            resultInt = 1;
+    }
+
+    private void rollDice(int numberOfDice, int diceart) {
+        int dice;
+        for(int i = 0; i < numberOfDice; i++) {
+            dice = new Random().nextInt(diceart);
+            if(resultStructur.length() > 0) {
+                resultStructur.append(" ");
+            }
+            resultStructur.append(dice+1);
+            resultStructur.append("/");
+            resultStructur.append(diceart);
+            resultInt += dice+1;
+            if(dice+1 == diceart)
+                i--;
+            if(dice > 0)
+                glitches = false;
+        }
+    }
+}

src/main/java/Engel/arcana.java

@@ -0,0 +1,65 @@
+package Engel;
+
+public class arcana {
+    private String name;
+    private String upsideMeaning;
+    private String upsideExplain;
+    private String upsideText;
+    private String downSideMeaning;
+    private String downSideExplain;
+    private String downsideText;
+
+
+
+    private String upsideNumber;
+    private String downsideNumber;
+
+
+    public arcana(String name, String upsideMeaning, String upsideExplain, String upsideText, String upsideNumber, String downSideMeaning, String downSideExplain, String downsideText, String downsideNumber) {
+        this.name = name;
+        this.upsideMeaning = upsideMeaning;
+        this.upsideExplain = upsideExplain;
+        this.upsideText = upsideText;
+        this.downSideMeaning = downSideMeaning;
+        this.downSideExplain = downSideExplain;
+        this.downsideText = downsideText;
+        this.upsideNumber = upsideNumber;
+        this.downsideNumber = downsideNumber;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getUpsideMeaning() {
+        return upsideMeaning;
+    }
+
+    public String getUpsideExplain() {
+        return upsideExplain;
+    }
+
+    public String getUpsideText() {
+        return upsideText;
+    }
+
+    public String getDownSideMeaning() {
+        return downSideMeaning;
+    }
+
+    public String getDownSideExplain() {
+        return downSideExplain;
+    }
+
+    public String getDownsideText() {
+        return downsideText;
+    }
+
+    public String getUpsideNumber() {
+        return upsideNumber;
+    }
+
+    public String getDownsideNumber() {
+        return downsideNumber;
+    }
+}

src/main/java/Engel/arcanaList.java

@@ -0,0 +1,206 @@
+package Engel;
+
+import net.dv8tion.jda.api.EmbedBuilder;
+
+import java.awt.*;
+import java.util.Random;
+
+public class arcanaList {
+
+    private arcana[] arcanas;
+
+    public boolean isSide() {
+        return side;
+    }
+
+    private boolean side;
+    private int stack;
+    private boolean[] usedCard;
+    private int activArcana;
+
+    public boolean isLoF() {
+        return LoF;
+    }
+
+    private boolean LoF;
+
+    public arcanaList() {
+        usedCard = new boolean[22];
+        for(int i = 0; i < 22; i++)
+            usedCard[i] = false;
+        reset();
+        initAranas();
+    }
+
+    public void reset() {
+        stack = 22;
+        activArcana = -1;
+        for(int i = 0; i < 22; i++)
+            usedCard[i] = false;
+        LoF = false;
+        side = false;
+    }
+
+    public void draw() {
+        EmbedBuilder outputBox = new EmbedBuilder();
+        StringBuilder resultConstruction = new StringBuilder("");
+
+        if(stack < 1) {
+            reset();
+        }
+        int draw = new Random().nextInt(stack);
+        int j = 0;
+        for(int i = 0; i < draw; i++, j++) { // hochzählen von Zieh coutner und Kartennummer
+            if (usedCard[j] == true) { // wenn die Karte schon benutzt wurde wird der counter um eines reduziert um die nächste frei Karte zu finden
+                i--;
+            }
+        }
+        stack--;
+        int UpDown = new Random().nextInt(100);
+        if(UpDown % 2 == 0)
+            side = false;
+        else
+            side = true;
+
+        activArcana = j;
+        if(j == 15) {
+            LoF = true;
+        }
+        else {
+            LoF = false;
+        }
+    }
+
+    public String getName() {
+        if(activArcana == -1)
+            return "";
+        else {
+            return arcanas[activArcana].getName();
+        }
+    }
+
+    public String getMeaning() {
+        if(activArcana == -1)
+            return "";
+        else {
+            if (!side)
+                return arcanas[activArcana].getUpsideMeaning();
+            else
+                return arcanas[activArcana].getDownSideMeaning();
+        }
+    }
+    public String getExplain() {
+        if(activArcana == -1)
+            return "";
+        else {
+            if (!side)
+                return arcanas[activArcana].getUpsideExplain();
+            else
+                return arcanas[activArcana].getDownSideExplain();
+        }
+    }
+
+    public String getImage() {
+        String baseURL = "http://ocame.de/engelcards/";
+        if(activArcana == -1)
+            return "";
+        else {
+            if (!side)
+                return baseURL + arcanas[activArcana].getUpsideNumber() + ".jpg";
+            else
+                return baseURL + arcanas[activArcana].getDownsideNumber() + ".jpg";
+        }
+    }
+
+    private void initAranas() {
+        arcanas = new arcana[22];
+        arcanas[0] = new arcana("Das 0. Arkanum: der Ketzer",
+                "Entscheidungsfreiheit", "Neue Möglichkeiten, Mut, Ekstase, Kreativität, Risikobereitschaft, Vertrauen, Wahlfreiheit, Abenteuer", "upsideExplain", "19",
+                "Isolation", "Stagnation, Exzentrizität, Narretei, Gedankenlosigkeit, Indiskretion", "downsideExplain", "40"
+                );
+
+        arcanas[1] = new arcana("Das 1. Arkanum: die Kirche",
+                "Nachsicht", "Willenskraft, Kommunikation, wundersame Fähigkeiten, Erinnerung, klares Denken und Fühlen, Organisation, Entschlußkraft, Verständigung", "upsideExplain", "11",
+                "Strenge", "Schwäche, Unentschiedenheit", "downsideExplain", "32");
+
+        arcanas[2] = new arcana("Das 2. Arkanum: die Begine",
+                "Erleuchtung", "Intuition, Einfallsreichtum, Meditation, Eingebung, Wachstum, Entwicklung, Bewußtsein, Geheimnis, Innenschau", "upsideExplain", "5",
+                "Irrtum", "Irrglaube, Oberflächlichkeit, Einbildung", "downsideExplain", "26");
+
+        arcanas[3] = new arcana("Das 3. Arkanum: Roma Aeterna",
+                "Wachstum", "Fruchtbarkeit, Weisheit, Machtzentrum, Prophezeiung, Nächstenliebe, spirituelle Essenz, Heilung, Speisung, Gefühl, Schöpfung, Gleichgewicht, Heimat", "upsideExplain", "10",
+                "Verfall", "Unfruchtbarkeit, Armut, Untätigkeit, Störung, Zerstörung", "downsideExplain", "31");
+
+        arcanas[4] = new arcana("Das 4. Arkanum: die Schrottbaronin",
+                "Herrschaft", "Führung, Regierung, Macht, Entscheidungen, Taten, Verhandlungen, Führungsqualitäten, Stärke, Respekt, Unerschütterlichkeit, Selbstsicherheit, Väterlichkeit, Vernunft", "upsideExplain", "14",
+                "Tyrannei", "Unreife, Fesseln, Diktatur, Gewalt", "downsideExplain", "35");
+
+        arcanas[5] = new arcana("Das 5. Arkanum: der Kardinal",
+                "Moral", "Neue Möglichkeiten, Mut, Ekstase, Kreativität, Risikobereitschaft, Vertrauen, Wahlfreiheit, Abenteuer", "upsideExplain", "6",
+                "Dekadenz", "Leichtgläubigkeit, Verschlagenheit, Machtgier, Hinterlist, Arglist, Intrigen", "downsideExplain", "27");
+
+        arcanas[6] = new arcana("Das 6. Arkanum: die Erzengel",
+                "Reinheit", "Anziehungskraft, Beziehungen, Neugier, Loyalität, Hingabe, Leidenschaft, Verbundenheit, Dualität, Attraktion, Ernsthaftigkeit, Offenheit, Sensibilität, Integration, Gleichheit, Romantik, Harmonie", "upsideExplain", "9",
+                "Versuchung", "Abstoßung, Makel, Unvollkommenheit, Minderwertigkeit", "downsideExplain", "30");
+
+        arcanas[7] = new arcana("Das 7. Arkanum: der Schöpfer",
+                "Triumph", "Wandel, Bewegung, Wachstum, Evolution, Fortschritt, Gelegenheit, Erforschung, Reise, Stimulation, Aktivität, Beförderung, Eroberung, Bollwerk gegen die Versuchung", "upsideExplain", "4",
+                "Niederlage", "Mißerfolg, Zusammenbruch, Rache", "downsideExplain", "25");
+
+        arcanas[8] = new arcana("Das 8. Arkanum: der Komtur",
+                "Stärke", "Leidenschaft, Kreativität, Risikobereitschaft, Charisma, Glanz, Erholung, Ausdruckskraft, Gaben, Beherrschung, Überwindung von Angst, Lust, Glaubensstärke, Selbstvertrauen, Bauen auf eigene Fähigkeiten, Bedingungslosigkeit, Intuition, Herrschaft, Harmonie", "upsideExplain", "16",
+                "Schwäche", "Mißbrauch, Zwietracht, Verderbtheit, Zorn", "downsideExplain", "37");
+
+        arcanas[9] = new arcana("Das 9. Arkanum: der Monach",
+                "Weisheit", "Weisheit Vervollkommnung, Innenschau, Kontemplation, Erfahrung, Einzelheiten, Offenbarung, Integrität, Respekt, Führungsqualitäten, Übergänge, Entdeckung, Weisheit, Anleitung, Offenheit, Mut, Suche", "upsideExplain", "12",
+                "Torheit", "Unreife, Narretei", "downsideExplain", "33");
+
+        arcanas[10] = new arcana("Das 10. Arkanum: Das Schicksal",
+                "Glück", "Gelegenheit, Durchbruch, Wohlstand, Überfluß, Ausdehnung, Flexibilität", "upsideExplain", "2",
+                "Unglück", "Stagnation, Exzentrizität, Narretei, Gedankenlosigkeit, Indiskretion", "downsideExplain", "23");
+
+        arcanas[11] = new arcana("Das 11. Arkanum: der Templer",
+                "Pflicht", "Gute Gesinnung, Gleichgewicht, Neuorientierung, Wahrheit, Klarheit, Vereinfachung, Ordnung, Authentizität, Sichtbarmachung, Durchschauen von Täuschungen und Trugbildern, Harmonie", "upsideExplain", "21",
+                "Verrat", "Ungerechtigkeit, Vorurteile, Ungleichheit, Voreingenommenheit", "downsideExplain", "42");
+
+        arcanas[12] = new arcana("Das 12. Arkanum: die Beutereiter",
+                "Strukturwandel", "Bruch mit alten Strukturen, Entschlossenheit, Freiheit, Lebensenergie, neue Haltungen und Perspektiven, Erwachen, tiefe spirituelle Weisheit, Kreativität, Intelligenz, Prophetie", "upsideExplain", "17",
+                "Verwüstung", "Aufgabe, Vorurteile, Arroganz, Kapitulation, Unentschlossenheit", "downsideExplain", "38");
+
+        arcanas[13] = new arcana("Das 13. Arkanum: der Tod",
+                "Veränderung", "Erlösung, Loslassen, Verwandlung, Spiritualität, Bewußtseinserweiterung, Entpuppung, Geburtshilfe, Umstrukturierung, Zyklen, Wiedergeburt, Wandel", "upsideExplain", "18",
+                "Stillstand", "Trägheit, Mutation, Verwandlung", "downsideExplain", "39");
+
+        arcanas[14] = new arcana("Das 14. Arkanum: die Traumsaat",
+                "Einheit", "Anpassung, Integration, Synergie, Gleichgewicht, Einigkeit, Erfahrung, Konfliktlösung, Symmetrie, Kombinationen, Abstimmung, Koordination, Selbstbeherrschung", "upsideExplain", "13",
+                "Mutation", "Wettkampf, Ungleichgewicht, Groteskes", "downsideExplain", "34");
+
+        arcanas[15] = new arcana("Das 15. Arkanum: der Herr der Fliegen",
+                "?", "", "upsideExplain", "1",
+                "?", "", "downsideExplain", "1");
+
+        arcanas[16] = new arcana("Das 16. Arkanum: der Himmel",
+                "Zuflucht", "Läuterung, Ehrgeiz, Wiederherstellung, Erneuerung, Wandel, Umstrukturierung, Erwachen, Heilung, Ausdehnung, Echtheit, Aufbau, Entwurf, Orientierung", "upsideExplain", "15",
+                "Gefangenschaft", "Freiheitsentzug, Konflikt, Katastrophe, Störung, Aufruhr", "downsideExplain", "36");
+
+        arcanas[17] = new arcana("Das 17. Arkanum: die Inspiration",
+                "Kreativität", "Zuversicht, Selbstwertgefühl, Talent, Anleitung, Ausdrucksstärke, Innovation, Einfallsreichtum, Ausstrahlung, Manifestation, Charisma, Anziehungskraft, Instinkt, Vollendung, Inneres Gleichgewicht, Spontaneität, Lebendigkeit, Natur, Hoffnung, Erkenntnis, Bedeutung", "upsideExplain", "3",
+                "Einfallslosigkeit", "Sturheit, Pessimismus, Zweifel, Überanstrengung", "downsideExplain", "24");
+
+        arcanas[18] = new arcana("Das 18. Arkanum: Das Buch der Bücher",
+                "Enthüllung", "Intuition, Bekenntnis, Empfänglichkeit, Denken, Geheimnis, Rätsel, Romantik, Offenbarung", "upsideExplain", "20",
+                "Geheimnis", "Wahnsinn, Täuschung, Gefahr, Irrsinn, Illusion, Sinnestäuschung", "downsideExplain", "41");
+
+        arcanas[19] = new arcana("Das 19. Arkanum: die Schar",
+                "Zusammenhalt", "Befreiung, Zusammenarbeit, Gemeinsamkeit, Partnerschaft, Kooperation, Energie, Lebenskraft, Entstehung, Motivation, Stimulation, Jubel, Organisation, gemeinsame Visionen, Erforschung, Wiederbelebung, Schöpfung, Neuerung, Erfolg, Gelingen, Errungenschaften", "upsideExplain", "7",
+                "Abkehr", "Rückschritt, Erschöpfung, Ausgelaugtheit, Enervierung, Energieverlust", "downsideExplain", "28");
+
+        arcanas[20] = new arcana("Das 20. Arkanum: Das Fegefeuer",
+                "Zerstörung", "Tod, Desillusionierung, Verlust, Kritik, Voreingenommenheit", "upsideExplain", "22",
+                "Wiedergeburt", "Wiedervereinigung, Erwachen, Bewußtsein, Unterscheidungsfähigkeit, Urteilsfähigkeit, Wahrnehmung, Erkenntnis, Einschätzung, Integration, Manifestation", "downsideExplain", "43");
+
+        arcanas[21] = new arcana("Das 21. Arkanum: die Welt",
+                "Vitalität", "Erfüllung, Belohnung, Freiheit, Ganzheit, Vollkommenheit, Ganzheitlichkeit, Vollendung, Integration, Einung, Bewußtsein, Vision, Umwelt", "upsideExplain", "8",
+                "Trägheit", "Faulheit, Unvollständigkeit, Beschränkung, Restriktion, Verneinung", "downsideExplain", "29");
+    }
+}

src/main/java/Engel/dice.java

@@ -0,0 +1,140 @@
+package Engel;
+
+import Shadowrun.db_connect;
+import Simpleroll.help;
+import Simpleroll.language;
+import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.entities.channel.ChannelType;
+import net.dv8tion.jda.api.entities.User;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import net.dv8tion.jda.api.hooks.ListenerAdapter;
+
+import java.awt.*;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Random;
+
+public class dice extends ListenerAdapter {
+
+    private String prefixEngel;
+    private String prefixEngelShort;
+
+    private language langDe = new language("de");
+    private language langEn = new language("en");
+
+    private help helpDe = new help("de");
+    private help helpEn = new help("En");
+
+    private language activLang;
+    private help activHelp;
+
+    private arcanaList activArcanaList;
+
+    private db_connect db;
+
+    private Map<String, String> channelList = new HashMap<>();
+    private Map<String, arcanaList> arcanaList = new HashMap<>();
+
+
+    public dice() {
+        this.prefixEngel = "/engel";
+        this.prefixEngelShort = "/e";
+
+        this.db = new db_connect();
+    }
+
+    @Override
+    public void onMessageReceived(MessageReceivedEvent event) {
+        if ((!event.getMessage().getContentRaw().startsWith(this.prefixEngel)
+                && !event.getMessage().getContentRaw().startsWith(this.prefixEngelShort))
+                || (event.getChannelType() != ChannelType.TEXT && event.getChannelType() != ChannelType.PRIVATE)) {
+            return;
+        }
+
+        if(!channelList.containsKey(event.getChannel().getId())) {
+            Map<String, String> Einstellungen = db.getChannelSettings(event.getChannel().getId());
+            channelList.put(event.getChannel().getId(), Einstellungen.get("lang").toString());
+        }
+        switch (channelList.get(event.getChannel().getId())) {
+            case "de":
+                activLang = langDe;
+                break;
+            case "en":
+                activLang = langEn;
+                break;
+            default:
+                activLang = langDe;
+
+        }
+        if(!arcanaList.containsKey(event.getChannel().getId())) {
+            arcanaList.put(event.getChannel().getId(), new arcanaList());
+        }
+        activArcanaList = arcanaList.get(event.getChannel().getId());
+
+        User author = event.getAuthor();
+        if (event.getMessage().getContentRaw().startsWith(this.prefixEngel) || event.getMessage().getContentRaw().startsWith(this.prefixEngelShort + " "))
+            this.draw(event);
+    }
+
+
+    private String getEffectiveName(MessageReceivedEvent event) {
+        if(event.getMember() == null) {
+            return "";
+        }
+        return event.getMember().getEffectiveName() + " ";
+    }
+
+    private String getAsMention(MessageReceivedEvent event) {
+        if(event.getMember() == null) {
+            return "";
+        }
+        return event.getMember().getAsMention() + " ";
+    }
+
+    /**
+     * draw
+     *
+     * @param event JDA Event
+     */
+    private void draw(MessageReceivedEvent event) {
+
+        EmbedBuilder outputBox = new EmbedBuilder();
+
+        StringBuilder result = new StringBuilder("");
+
+
+        try {
+
+            String ContentRaw = event.getMessage().getContentRaw();
+            String NameAdd = "";
+
+            activArcanaList.draw();
+
+            if(activArcanaList.isLoF()) {
+                outputBox.setColor(Color.red);
+            }
+            else if(!activArcanaList.isSide()) {
+                outputBox.setColor(Color.green);
+            }
+            else {
+                outputBox.setColor(Color.orange);
+                NameAdd = " Umgekehrt ";
+            }
+
+            outputBox.setTitle(getEffectiveName(event) + "du ziehst " + NameAdd + activArcanaList.getName());
+            result.append("**").append(activArcanaList.getMeaning()).append("**");
+            result.append("\n").append(activArcanaList.getExplain());
+            outputBox.setDescription(result.toString().trim());
+            outputBox.setImage(activArcanaList.getImage());
+            event.getChannel().sendMessageEmbeds(outputBox.build()).queue();
+
+        }
+        catch (NumberFormatException e) {
+            event.getChannel().sendMessage("Nope").queue();
+        }
+        catch (Exception e) {
+            System.out.println("problem: " + e.getMessage());
+        }
+
+    }
+}

src/main/java/Engel/language.java

@@ -0,0 +1,89 @@
+package Engel;
+
+import java.io.*;
+import java.util.Properties;
+
+
+public class language {
+
+    public String language = "Deutsch";
+    public String emptyCommand = " der %command% befehl benötigt einen Wert";
+    public String error = " Irgend was dummes ist passiert beim Verstehen von %command%";
+    public String error2 = " Irgend was dummes ist passiert beim Verstehen von %command%";
+    public String noNegativ = " es darf kein Negativen Wurf geben";
+    public String dice = "w";
+    public String resultText = " %numberOfDice%w%diceart% %EdgeDice%:\tErfolge: %hits%\tMisserfolge: %oneHits%";
+    public String basisresultText = " %numberOfDice%w%diceart%:";
+
+    public language() {
+        this.readConfig();
+    }
+
+    /**
+     *
+     * @param lang Srache
+     */
+    public language(String lang) {
+        this.readConfig(lang);
+    }
+
+    public void readConfig() {
+        this.readConfig("de");
+    }
+    public void readConfig(String lang) {
+        FileInputStream input = null;
+        OutputStream output = null;
+        Properties config = new Properties();
+        try {
+            File f = new File("shadowrun.cfg");
+            if (f.isFile() && f.canRead()) {
+
+                input = new FileInputStream("shadowrun.cfg");
+                config.load(input);
+                if(config.containsKey(lang + ".language"))
+                    this.language = config.getProperty(lang + ".language");
+
+                if(config.containsKey(lang + ".emptyCommand"))
+                    this.emptyCommand = config.getProperty(lang + ".emptyCommand");
+                if(config.containsKey(lang + ".error"))
+                    this.error = config.getProperty(lang + ".error");
+                if(config.containsKey(lang + ".error2"))
+                    this.error2 = config.getProperty(lang + ".error2");
+                if(config.containsKey(lang + ".noNegativ"))
+                    this.noNegativ = config.getProperty(lang + ".noNegativ");
+                if(config.containsKey(lang + ".dice"))
+                    this.dice = config.getProperty(lang + ".dice");
+                if(config.containsKey(lang + ".resultText"))
+                    this.resultText = config.getProperty(lang + ".resultText");
+                if(config.containsKey(lang + ".basisresultText"))
+                    this.resultText = config.getProperty(lang + ".basisresultText");
+
+            }
+            else {
+                output = new FileOutputStream("shadowrun.cfg");
+                config.setProperty(lang + ".language", this.language);
+                config.setProperty(lang + ".emptyCommand", this.emptyCommand);
+                config.setProperty(lang + ".error", this.error);
+                config.setProperty(lang + ".error2", this.error2);
+                config.setProperty(lang + ".noNegativ", this.noNegativ);
+                config.setProperty(lang + ".dice", this.dice);
+                config.setProperty(lang + ".resultText", this.resultText);
+                config.setProperty(lang + ".basisresultText", this.basisresultText);
+                config.store(output, null);
+
+            }
+        } catch (Exception e) {
+
+        }
+        finally {
+            if (input != null) {
+                try {
+                    input.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
+

src/main/java/Keeproll/dice.java

@@ -0,0 +1,319 @@
+package Keeproll;
+
+import Shadowrun.db_connect;
+import Simpleroll.help;
+import Simpleroll.language;
+import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.entities.channel.ChannelType;
+import net.dv8tion.jda.api.entities.User;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import net.dv8tion.jda.api.hooks.ListenerAdapter;
+
+import java.awt.*;
+import java.util.*;
+import java.util.regex.MatchResult;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class dice extends ListenerAdapter {
+
+    private String prefixlong;
+    private String prefixShort;
+    private String prefixVeryShort;
+
+    private language langDe = new language("de");
+    private language langEn = new language("en");
+
+    private help helpDe = new help("de");
+    private help helpEn = new help("En");
+
+    private language activLang;
+    private help activHelp;
+
+    private db_connect db;
+
+    private Map<String, String> channelList = new HashMap<>();
+
+
+    public dice() {
+        this.prefixlong = "/l5r";
+        this.prefixShort = "/keep";
+        this.prefixVeryShort = "/k ";
+
+        this.db = new db_connect();
+    }
+
+    @Override
+    public void onMessageReceived(MessageReceivedEvent event) {
+        if ((!event.getMessage().getContentRaw().toLowerCase().startsWith(this.prefixlong)
+                && !event.getMessage().getContentRaw().toLowerCase().startsWith(this.prefixShort)
+                && !event.getMessage().getContentRaw().toLowerCase().startsWith(this.prefixVeryShort))
+                || (event.getChannelType() != ChannelType.TEXT && event.getChannelType() != ChannelType.PRIVATE)) {
+            return;
+        }
+
+        if(!channelList.containsKey(event.getChannel().getId())) {
+            Map<String, String> Einstellungen = db.getChannelSettings(event.getChannel().getId());
+            channelList.put(event.getChannel().getId(), Einstellungen.get("lang").toString());
+        }
+        switch (channelList.get(event.getChannel().getId())) {
+            case "de":
+                activLang = langDe;
+                break;
+            case "en":
+                activLang = langEn;
+                break;
+            default:
+                activLang = langDe;
+
+        }
+        User author = event.getAuthor();
+        if (event.getMessage().getContentRaw().toLowerCase().startsWith(this.prefixlong) || event.getMessage().getContentRaw().toLowerCase().startsWith(this.prefixShort) || event.getMessage().getContentRaw().toLowerCase().startsWith(this.prefixVeryShort))
+            this.roll(event);
+    }
+
+
+    private String getEffectiveName(MessageReceivedEvent event) {
+        if(event.getMember() == null) {
+            return "";
+        }
+        return event.getMember().getEffectiveName() + " ";
+    }
+
+    private String getAsMention(MessageReceivedEvent event) {
+        if(event.getMember() == null) {
+            return "";
+        }
+        return event.getMember().getAsMention() + " ";
+    }
+
+    /**
+     *
+     *
+     * @param event JDA Event
+     */
+    private void roll(MessageReceivedEvent event) {
+
+        EmbedBuilder outputBox = new EmbedBuilder();
+        StringBuilder result = new StringBuilder("");
+        String msgText = "";
+
+        int numberOfDice, diceCount, resultValue, difficult, bonus;
+        numberOfDice = diceCount =  resultValue = difficult = bonus = 0;
+
+        boolean reroll9, reroll1, maxreroll, noreroll;
+        reroll9 = reroll1 = maxreroll = noreroll = false;
+
+        try {
+
+            String ContentRaw = event.getMessage().getContentRaw();
+
+            // Prüfen ob Leerer Command gesendet wird
+            String[] MsgParts = ContentRaw.replace("  ", " ").split(" ", 2);
+
+            if(MsgParts.length < 2) {
+                String message = activLang.emptyCommand;
+                message = message.replace("%command%", this.prefixShort);
+                event.getChannel().sendMessage(getAsMention(event) + message).queue();
+                return;
+            }
+
+            msgText = MsgParts[1].trim();
+            if(msgText.matches(".*[^0-9].*")) { // es wurden andere zeichen als Zahlen gefunden
+                if(msgText.toLowerCase().equals("de")) {
+                    activLang = langDe;
+                    channelList.put(event.getChannel().getId(), "de");
+                    event.getChannel().sendMessage(getAsMention(event) + activLang.language).queue();
+                    db.setChannelSettings(event.getChannel().getId(), "de", event.getGuild().getId(), event.getChannel().getName());
+                    return;
+                }
+                else if(msgText.toLowerCase().equals("en")) {
+                    activLang = langEn;
+                    channelList.put(event.getChannel().getId(), "en");
+                    event.getChannel().sendMessage(getAsMention(event) + activLang.language).queue();
+                    db.setChannelSettings(event.getChannel().getId(), "en", event.getGuild().getId(), event.getChannel().getName());
+                    return;
+                }
+                else if(msgText.toLowerCase().equals("help") || msgText.toLowerCase().equals("hilfe")) {
+                    event.getChannel().sendMessage(getAsMention(event)
+                    + " Die Syntax lautet XkY z.b. 5k4\nEs werden X mal W10 gewürfelt und davon die höhsten Anzahl Y behalten und addiert. Wird eine 10 gewürfelt, wird der Wurf weiter gewürfelt und addiert aber nur als ein Wurf gezählt.\nWird nach dem XkY eine weiter Zahl angeben so ist dies die Schwierigkeit\n"
+                        + "Wird nach dem XkY eine Zahl mit + oder - Angegeben, zählt dies als ein Modifikator für das ergebnis.\n\n"
+                        + "Zudem gibt es folgente sonderzeichen, die an belibiger stelle gesetz werden können:\n"
+                        + "! - auch gewüfelte 9 explodieren\n"
+                        + "e - gewürfelte 1 werden neu gewürfelt\n"
+                        + "# - Würfel explodierente nur einmal\n"
+                        + "n - Würfel explodierente nicht\n"
+                     ).queue();
+
+                    return;
+                }
+                if(msgText.contains("!")) {
+                    reroll9 = true;
+                    msgText = msgText.replace("!", "");
+                }
+                if(msgText.contains("e")) {
+                    reroll1 = true;
+                    msgText = msgText.replace("e", "");
+                }
+                if(msgText.contains("#")) {
+                    maxreroll = true;
+                    msgText = msgText.replace("#", "");
+                }
+                if(msgText.contains("n")) {
+                    noreroll = true;
+                    msgText = msgText.replace("n", "");
+                }
+
+                if(msgText.matches(".*[+-] *[0-9]+.*")) { // Modifikator gefunden
+                    Pattern pattern = Pattern.compile("([+-]) *([0-9]+)");
+                    Matcher matcher = pattern.matcher(msgText.toLowerCase());
+                    matcher.find();
+                    MatchResult elements = matcher.toMatchResult();
+                    bonus = Integer.parseInt(elements.group(2));
+                    if(elements.group(1).equals("-")) {
+                        bonus *= -1;
+                    }
+                    msgText = msgText.replaceFirst("[+-] *[0-9]+", "");
+                }
+
+                if(msgText.toLowerCase().matches(".*([0-9]+)k([0-9]+) +([0-9]+).*")) { // XkY Z Aufbau in der Anfrage
+                    Pattern pattern = Pattern.compile("([0-9]+)k([0-9]+) +([0-9]+)");
+                    Matcher matcher = pattern.matcher(msgText.toLowerCase());
+                    matcher.find();
+                    MatchResult elements = matcher.toMatchResult();
+                    numberOfDice = Integer.parseInt(elements.group(1));
+                    diceCount = Integer.parseInt(elements.group(2));
+                    difficult = Integer.parseInt(elements.group(3));
+                }
+                else if(msgText.toLowerCase().matches(".*([0-9]+)k([0-9]+).*")) { // XkY Aufbau in der Anfrage
+                    Pattern pattern = Pattern.compile("([0-9]+)k([0-9]+)");
+                    Matcher matcher = pattern.matcher(msgText.toLowerCase());
+                    matcher.find();
+                    MatchResult elements = matcher.toMatchResult();
+                    numberOfDice = Integer.parseInt(elements.group(1));
+                    diceCount = Integer.parseInt(elements.group(2));
+                }
+                else {
+                    String message = activLang.error;
+                    message = message.replace("%command%", msgText);
+                    event.getChannel().sendMessage(getAsMention(event) + message).queue();
+                    return;
+                }
+            }
+            else {
+                    String message = activLang.error;
+                    message = message.replace("%command%", msgText);
+                    event.getChannel().sendMessage(getAsMention(event) + message).queue();
+                    return;
+            }
+
+            if(numberOfDice < diceCount && numberOfDice < 10) {
+                numberOfDice = diceCount;
+            }
+
+            if(numberOfDice > 10) {
+                int diceovflow = numberOfDice-10;
+                numberOfDice = 10;
+                if(diceCount >= 10) {
+                    bonus += diceovflow*2;
+                }
+                else {
+                    if(diceCount + Math.floorDiv(diceovflow, 2) <= 10) {
+                        diceCount += Math.floorDiv(diceovflow, 2);
+                    }
+                    else {
+                        diceCount = 10;
+                        bonus += (diceCount + Math.floorDiv(diceovflow, 2) - 10)*2;
+                    }
+                }
+
+            }
+
+            if(diceCount > 10) {
+                bonus += (diceCount-10)*2;
+                diceCount = 10;
+            }
+
+            if(numberOfDice <= 0) {
+                String message = activLang.noNegativ;
+                event.getChannel().sendMessage(getAsMention(event) + message).queue();
+                return;
+            }
+
+
+            result[] rolls = new result[numberOfDice];
+
+            int [][] sortRolls = new int[numberOfDice][2];
+
+            for(int i = 0; i < numberOfDice; i++) {
+                rolls[i] = new result();
+                rolls[i].setMaxReroll(maxreroll).setReroll1(reroll1).setReroll9(reroll9).setNoreroll(noreroll);
+                rolls[i].roll();
+                sortRolls[i][0] = i;
+                sortRolls[i][1] = rolls[i].getValue();
+            }
+
+
+            // sortierung
+            Arrays.sort(sortRolls, Comparator.comparingInt(o -> o[1]));
+            for(int i = numberOfDice; i > numberOfDice-diceCount; i--) {
+                resultValue += sortRolls[i-1][1];
+                rolls[sortRolls[i-1][0]].setMarket();
+            }
+            resultValue += bonus;
+
+            // Border Farbe
+            if(resultValue >= difficult) {
+                outputBox.setColor(Color.green);
+            }
+            else {
+                outputBox.setColor(Color.red);
+            }
+
+            // Ausgabe beginn
+            String addition = "";
+            if(bonus != 0) {
+                if(bonus < 0) {
+                    addition += " - " + (bonus*-1) + " ";;
+                }
+                else {
+                    addition += " + " + bonus + " ";;
+                }
+            }
+            if(difficult > 0) {
+                addition += " Schwierigkeit " + difficult;
+            }
+
+            outputBox.setTitle(getEffectiveName(event) + numberOfDice + "k" + diceCount + addition + ": " + resultValue);
+
+            StringBuilder description = new StringBuilder();
+            for(int i = 0; i < numberOfDice; i++) {
+                if(description.length() > 0) {
+                    description.append(", ");
+                }
+                description.append(rolls[i].getText());
+            }
+            outputBox.setDescription("(" +  description + ")");
+            event.getChannel().sendMessageEmbeds(outputBox.build()).queue();
+        }
+        catch (NumberFormatException e) {
+            event.getChannel().sendMessage("Nope").queue();
+        }
+        catch (Exception e) {
+            System.out.println("problem: " + e.getMessage());
+        }
+
+    }
+
+    private void aprilfool(MessageReceivedEvent event) {
+        EmbedBuilder outputBox = new EmbedBuilder();
+        StringBuilder description = new StringBuilder();
+        outputBox.setTitle("**Helft der Prinzessin und wertet Flauschsupporter!**");
+        description.append("Da Würfel immer sehr schwer sind und Prinzessin Flauschball sehr klein ist.\n" +
+                "Würde sie sich rießig über eine kleine Spende freuen. \n\n" +
+                "Ab nur **1€** pro Monat steigt die Changse, als dank für die Hilfe, um **1%** ein besseres Ergebnis zu bekommen.\n\n");
+        description.append("Für mehr Infos: https://bitly.com/98K8eH");
+        outputBox.setDescription(description);
+        event.getChannel().sendMessageEmbeds(outputBox.build()).queue();
+    }
+}

src/main/java/Keeproll/result.java

@@ -0,0 +1,105 @@
+package Keeproll;
+
+import java.util.Random;
+
+public class result {
+    private StringBuilder text;
+    private int value;
+    private int diceart;
+    private Boolean reroll9;
+    private Boolean reroll1;
+    private Boolean maxReroll;
+    private Boolean noreroll;
+
+    public result() {
+        diceart = 10;
+        text = new StringBuilder();
+        value = 0;
+        reroll9 = false;
+        reroll1 = false;
+        maxReroll = false;
+        noreroll = false;
+    }
+
+    public String getText() {
+        return text.toString();
+    }
+
+    public void setText(String text) {
+        this.text = new StringBuilder();
+        this.text.append(text);
+    }
+
+    public void setMarket() {
+        String tmp = this.text.toString();
+        this.text = new StringBuilder();
+        this.text.append("**").append(tmp).append("**");
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    public void setValue(Integer value) {
+        this.value = value;
+    }
+
+    public result setReroll9(Boolean reroll9) {
+        this.reroll9 = reroll9;
+        return this;
+    }
+
+    public result setReroll1(Boolean reroll1) {
+        this.reroll1 = reroll1;
+        return this;
+    }
+
+    public result setMaxReroll(Boolean maxReroll) {
+        this.maxReroll = maxReroll;
+        return this;
+    }
+
+    public result setNoreroll(Boolean noreroll) {
+        this.noreroll = noreroll;
+        return this;
+    }
+
+    public result roll() {
+        int dice;
+        int rolls = 0;
+        Boolean reroll = false;
+
+        do{
+            reroll = false;
+            dice = new Random().nextInt(diceart);
+            dice++;
+
+            if(text.length() > 0) {
+                text.append("+");
+            }
+            if(reroll1 && dice == 1 && rolls <= 0) {
+                text.append("~~ ").append(dice).append(" ~~ ");
+            }
+            else {
+                text.append(dice);
+            }
+
+            value += dice;
+
+            if(!noreroll) {
+                if (dice == 10) {
+                    reroll = rolls <= 0 || !maxReroll; // wenn maxRolls an und schon einmal gerollt wurde kein reroll
+                    ++rolls;
+                } else if (reroll9 && dice == 9) {
+                    reroll = rolls <= 0 || !maxReroll;
+                } else if (reroll1 && dice == 1 && rolls <= 0) {
+                    reroll = true;
+                    value--;
+                }
+            }
+
+        } while(reroll);
+
+        return this;
+    }
+}

src/main/java/Serenity/balance.java.Deprecated

@@ -0,0 +1,355 @@
+package Serenity;
+
+import net.dv8tion.jda.api.entities.channel.ChannelType;
+import net.dv8tion.jda.api.entities.User;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import net.dv8tion.jda.api.hooks.ListenerAdapter;
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+import java.io.*;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.text.DecimalFormat;
+import java.util.*;
+
+public class balance extends ListenerAdapter {
+
+    private String prefixPromote;
+    private String prefixDegradation;
+    private String prefixDetail;
+    private String prefixCow;
+    private String prefixCow2;
+
+
+    public balance() {
+        this.prefixPromote = "/konto";
+        this.prefixDegradation = "/pay ";
+        this.prefixDetail = "/detail";
+
+        this.prefixCow = "/cow";
+        this.prefixCow2 = "/Cattle";
+
+
+    }
+
+    @Override
+    public void onMessageReceived(MessageReceivedEvent event) {
+        if (event.getMessage().getContentRaw().startsWith("!ende")) { // nur zum Debugen #todo muss wieder raus
+            event.getJDA().shutdown();
+        }
+        if (event.getMessage().getContentRaw().startsWith(this.prefixCow) || event.getMessage().getContentRaw().startsWith(this.prefixCow2)) { // nur zum Debugen #todo muss wieder raus
+            event.getChannel().sendMessage("NO FUCKING COWS AND COW-LIKE ANIMALS ON THE SHIP!").queue();
+        }
+        if ((!event.getMessage().getContentRaw().startsWith(this.prefixPromote) &&
+                !event.getMessage().getContentRaw().startsWith(this.prefixDegradation) &&
+                !event.getMessage().getContentRaw().startsWith(this.prefixDetail)) || event.getChannelType() != ChannelType.TEXT) {
+            return;
+        }
+
+        User author = event.getAuthor();
+        if (!author.isBot()) {
+            if (event.getMessage().getContentRaw().startsWith(this.prefixPromote))
+                this.getInfo(event);
+            else if (event.getMessage().getContentRaw().startsWith(this.prefixDegradation))
+                this.addTransaction(event);
+            else if (event.getMessage().getContentRaw().startsWith(this.prefixDetail))
+                this.getInfo(event, true);
+
+        }
+    }
+
+    private void getInfo(MessageReceivedEvent event) {
+        this.getInfo(event, false);
+    }
+
+    /**
+     * Holt Kontostand ab
+     *
+     * @param event JDA Event
+     * @param detail true = Abrufen der Detail, Chronologich, false = gesammt Kontostand
+     */
+    private void getInfo(MessageReceivedEvent event, Boolean detail) {
+        HttpURLConnection con = null;
+        //String result = "";
+        StringBuilder result_test = new StringBuilder("");
+        DecimalFormat myFormatter = new DecimalFormat();
+
+        Map<String, Integer> IdConvert = new HashMap<>();
+        IdConvert.put("256888865103544321", 2); // Niclos
+        IdConvert.put("495895196685303818", 3); // Birgit
+        IdConvert.put("385865287586545676", 7); // Felix
+        IdConvert.put("493359873480720384", 5); // orko
+        IdConvert.put("339859242917953537", 4); // christian
+        IdConvert.put("397055491488088065", 6); // Filip
+        IdConvert.put(event.getJDA().getSelfUser().getId(), 1); // Schiff
+
+        try {
+            // Zerlgen der Anfrage
+            String parameter = "";
+            if (event.getMessage().getMentions().getUsers() .size() > 0) {
+                if (IdConvert.containsKey(event.getMessage().getMentions().getUsers().get(0).getId()))
+                    parameter = "?id=" + (IdConvert.get(event.getMessage().getMentions().getUsers().get(0).getId()));
+            } else {
+                parameter = "?id=1";
+            }
+            if (detail) {
+                parameter += "&detail=1";
+            }
+
+            // aufbau zum REST
+            URL url = new URL("http://localhost/REST/balance" + parameter);
+            con = (HttpURLConnection) url.openConnection();
+            con.setRequestMethod("GET");
+            con.setConnectTimeout(3600);
+            con.setReadTimeout(360);
+            con.setUseCaches(false);
+            con.connect();
+
+            int status = con.getResponseCode();
+            switch (status) {
+                case 200:
+                case 201: // auswerten der Antwort
+                    BufferedReader in = new BufferedReader(
+                            new InputStreamReader(con.getInputStream()));
+                    String inputLine;
+                    StringBuffer content = new StringBuffer();
+                    while ((inputLine = in.readLine()) != null) {
+                        content.append(inputLine);
+                    }
+                    in.close();
+
+                    JSONObject responseJson = new JSONObject(content.toString());
+                    Iterator<String> keys = responseJson.keys();
+
+                    while (keys.hasNext()) {
+                        String key = keys.next();
+                        if (responseJson.get(key) instanceof JSONObject) {
+                            result_test.append("**").append(((JSONObject) responseJson.get(key)).get("name").toString()).append(":**\n");
+
+                            result_test.append("```");
+                            if (detail) {
+                                JSONArray transaction = (JSONArray) ((JSONObject) responseJson.get(key)).get("transaction");
+                                for (int i = 0; i < transaction.length(); i++) {
+                                    for (int j = 7 - (myFormatter.format(Float.parseFloat(((JSONObject) transaction.get(i)).get("amount").toString()))).length(); j > 0; j--) {
+                                        result_test.append(" ");
+                                    }
+                                    result_test.append( (myFormatter.format(Float.parseFloat(((JSONObject) transaction.get(i)).get("amount").toString()))));
+
+
+                                    result_test.append(" ").append( ((JSONObject) transaction.get(i)).get("currency_name").toString()).append(" ");
+
+                                        result_test.append(" - ").append(((JSONObject) transaction.get(i)).get("reason").toString());
+
+                                    result_test.append( "\n");
+                                }
+                                result_test.append( "\n-------------------------------------\n");
+                            }
+                            JSONArray balance = (JSONArray) ((JSONObject) responseJson.get(key)).get("balance");
+                            for (int i = 0; i < balance.length(); i++) {
+                                for (int j = 7 - (myFormatter.format(Float.parseFloat(((JSONObject) balance.get(i)).get("amount").toString()))).length(); j > 0; j--) {
+                                    result_test.append(" ");
+                                }
+                                result_test.append( (myFormatter.format(Float.parseFloat(((JSONObject) balance.get(i)).get("amount").toString()))));
+
+
+                                result_test.append(" ").append( ((JSONObject) balance.get(i)).get("currency_name").toString()).append(" ");
+                                result_test.append( "\n");
+                            }
+                            result_test.append( "```");
+                        }
+                    }
+                    event.getChannel().sendMessage(event.getMember().getAsMention() + "\n" + result_test.toString()).queue();
+                    break;
+                default:
+                    System.out.println(":(");
+            }
+            con.disconnect();
+
+        } catch (Exception e) {
+            System.out.println("problem: " + e.getMessage());
+        } finally {
+            if (con != null) { // Verbindung schließen wenn noch offen
+                try {
+                    con.disconnect();
+                } catch (Exception ex) {
+                    System.out.println("final fehler");
+                }
+            }
+        }
+
+    }
+
+    /**
+     * Fügt neue Transaktion hinzu
+     *
+     * @param event JDA Event
+     */
+    private void addTransaction(MessageReceivedEvent event) {
+        Map<String, Integer> IdConvert = new HashMap<>();
+        IdConvert.put("256888865103544321", 2); // Niclos
+        IdConvert.put("495895196685303818", 3); // Birgit
+        IdConvert.put("385865287586545676", 7); // Felix
+        IdConvert.put("493359873480720384", 5); // orko
+        IdConvert.put("339859242917953537", 4); // christian
+        IdConvert.put("397055491488088065", 6); // Filip
+        IdConvert.put(event.getJDA().getSelfUser().getId(), 1); // Schiff
+
+
+        Map<String, Integer> currencyConvert = new HashMap<>();
+        currencyConvert.put("credit", 1);
+        currencyConvert.put("c", 1);
+        currencyConvert.put("doller", 2);
+        currencyConvert.put("d", 2);
+        currencyConvert.put("$", 2);
+        currencyConvert.put("platinum", 3);
+        currencyConvert.put("p", 3);
+        currencyConvert.put("gold", 4);
+        currencyConvert.put("g", 4);
+        currencyConvert.put("silver", 5);
+        currencyConvert.put("s", 5);
+
+        Map<Integer, String> currencyConvert2 = new HashMap<>();
+        currencyConvert2.put(1, "Credit");
+        currencyConvert2.put(2, "Doller");
+        currencyConvert2.put(3, "Platinum");
+        currencyConvert2.put(4, "Gold");
+        currencyConvert2.put(5, "Silver");
+
+        int[] ids;
+        StringBuilder result = new StringBuilder("");
+        boolean allfound = true;
+        String[] MsgParts;
+        float ammount;
+
+        HttpURLConnection con = null;
+
+        try {
+            // Aufteilen Nachricht in Bennunungen und Rest
+            String[] MsgParts_exl_Mention = event.getMessage().getContentRaw().split(event.getMessage().getMentionedUsers().get(event.getMessage().getMentionedUsers().size() - 1).getAsMention(), 2);
+            MsgParts = MsgParts_exl_Mention[1].trim().split(" ");
+
+            ids = new int[event.getMessage().getMentionedUsers().size()];
+
+            // Pürfen ob Angebe der Währung bekannt ist
+            if (!currencyConvert.containsKey(MsgParts[1].toLowerCase())) {
+                event.getChannel().sendMessage(event.getMember().getAsMention() + " " + MsgParts[1] + " ist keine bekannte Währung").queue();
+                return;
+            }
+
+            // Prüfen ob Zahl legal ist
+            try {
+
+                ammount = Float.parseFloat(MsgParts[0]);
+            } catch (NumberFormatException e) {
+                event.getChannel().sendMessage(event.getMember().getAsMention() + " " + MsgParts[MsgParts.length - 2] + " ist keine gültige Zahl").queue();
+                return;
+
+            }
+
+
+            // Prüfen ob alle gennanten Personen zur Zahlung gehören
+            for (int i = 0; i < event.getMessage().getMentionedUsers().size(); i++) {
+                if (!IdConvert.containsKey(event.getMessage().getMentionedUsers().get(i).getId())) {
+                    allfound = false;
+                    result.append(" ").append(event.getMessage().getMentionedUsers().get(i).getName());
+                } else {
+                    ids[i] = IdConvert.get(event.getMessage().getMentionedUsers().get(i).getId());
+                }
+            }
+
+            if (!allfound) {
+                event.getChannel().sendMessage(event.getMember().getAsMention() + result.toString() + " wurde(n) nicht gefunden").queue();
+                return;
+            }
+
+            String reason = MsgParts_exl_Mention[1].trim().substring(MsgParts[0].length() + MsgParts[1].length() + 2);
+
+            // Aufbau Payload zur übertragung an REST Schnittstelle
+            JSONObject payload = new JSONObject();
+            payload.put("ammount", ammount);
+            payload.put("currency_id", currencyConvert.get(MsgParts[1].toLowerCase()));
+            payload.put("ids", ids);
+            payload.put("reason", reason);
+
+            URL url = new URL("http://localhost/REST/balance");
+            con = (HttpURLConnection) url.openConnection();
+            con.setRequestMethod("POST");
+            con.setConnectTimeout(3600);
+            con.setReadTimeout(3600);
+            con.setDoInput(true);
+            con.setDoOutput(true);
+            con.setDefaultUseCaches(false);
+
+            // Übertragen der Payload
+            OutputStream os = con.getOutputStream();
+            BufferedWriter writer = new BufferedWriter(
+                    new OutputStreamWriter(os, "UTF-8"));
+            writer.write(payload.toString());
+            writer.flush();
+            writer.close();
+
+            int status = con.getResponseCode();
+
+            switch (status) {
+                case 200:
+                case 201: // Verarbeiten der Antwort
+                    BufferedReader in = new BufferedReader(
+                            new InputStreamReader(con.getInputStream()));
+                    String inputLine;
+                    StringBuffer content = new StringBuffer();
+                    while ((inputLine = in.readLine()) != null) {
+                        content.append(inputLine);
+                    }
+                    in.close();
+                    JSONObject responseJson = new JSONObject(content.toString());
+                    Iterator<String> keys = responseJson.keys();
+
+                    result = new StringBuilder("");
+                    while (keys.hasNext()) {
+                        String key = keys.next();
+                        String id = getKey(IdConvert, Integer.parseInt(key));
+
+                        if (key.equals("1")) {
+                            result.append("Das Schiff bekommt: ").append(responseJson.get(key)).append(" ").append(currencyConvert2.get(currencyConvert.get(MsgParts[1].toLowerCase()))).append(" ");
+                        } else {
+                            result.append(event.getGuild().getMemberById(id).getAsMention()).append(" bekommt ").append(responseJson.get(key)).append(" ").append(currencyConvert2.get(currencyConvert.get(MsgParts[1].toLowerCase()))).append(" ");
+                        }
+                    }
+                    event.getChannel().sendMessage(event.getMember().getAsMention() + " " + result.toString()).queue();
+                    break;
+                default:
+                    System.out.println(":(");
+            }
+            con.disconnect();
+
+        } catch (Exception e) {
+            System.out.println("problem: " + e.getMessage());
+        } finally {
+            if (con != null) { // Verbindung schließen wenn noch offen
+                try {
+                    con.disconnect();
+                } catch (Exception ex) {
+                    System.out.println("final fehler");
+                }
+            }
+        }
+    }
+
+    /**
+     * Sucht in einer Map nach Wert und gibt Schlüßel zurück
+     * @param map Map mit allen Werten
+     * @param value gesuchtet wert
+     * @param <K> erste Typ
+     * @param <V> zweiter typ
+     * @return <K,V>|null
+     */
+    private <K, V> K getKey(Map<K, V> map, V value) {
+        for (Map.Entry<K, V> entry : map.entrySet()) {
+            if (entry.getValue().equals(value)) {
+                return entry.getKey();
+            }
+        }
+        return null;
+    }
+}

src/main/java/Shadowrun/db_connect.java

@@ -0,0 +1,193 @@
+package Shadowrun;
+
+import javax.print.DocFlavor;
+import java.sql.*;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.HashMap;
+import java.util.Map;
+
+public class db_connect extends DB.base {
+
+    Connection conn;
+    public db_connect() {
+        if(!isActive())
+            return;
+        open();
+        try {
+            conn = getConn();
+            ResultSet rs = conn.prepareStatement("show tables like \"shadowrun_log\"").executeQuery();
+            while (rs.next()) {
+                String s = rs.getString(1);
+                System.out.println(s);
+            }
+        }
+        catch (SQLException e) {
+                e.printStackTrace();
+        }
+        close();
+    }
+
+    public void insertDice(String userName, String userId, String command, String result, String kanal, long MsgID, String wurfdaten) {
+        if(!isActive())
+            return;
+
+        open();
+        try {
+            conn = getConn();
+            String SQL_INSERT = "INSERT INTO shadowrun_log (benutzer, benutzerId, wurf, ergebnis, kanal, msgId, wurfdaten) VALUES (?,?,?,?,?,?,?)";
+
+            PreparedStatement preparedStatement = conn.prepareStatement(SQL_INSERT);
+            preparedStatement.setString(1, userName);
+            preparedStatement.setString(2, userId);
+            preparedStatement.setString(3, command);
+            preparedStatement.setString(4, result);
+            preparedStatement.setString(5, kanal);
+            preparedStatement.setLong(6, MsgID);
+            preparedStatement.setString(7, wurfdaten);
+            preparedStatement.executeUpdate();
+
+        }
+        catch (SQLException e) {
+            e.printStackTrace();
+        }
+        close();
+    }
+
+    /**
+     *
+     * @param channelId
+     * @return
+     */
+    public Map<String, String> getChannelSettings(String channelId) {
+        Map<String, String> result = new HashMap<>();
+        result.put("lang", "de");
+
+        if(!isActive()) {
+            result.put("sqlActive", "0");
+            return result;
+        }
+
+        open();
+        try {
+            conn = getConn();
+            String SQL_SELECT = "SELECT * FROM shadowrun_channelSettings where channelId = ?";
+
+            PreparedStatement preparedStatement = conn.prepareStatement(SQL_SELECT);
+            preparedStatement.setString(1, channelId);
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next()) {
+                result.remove("lang");
+                result.put("lang", rs.getString("lang"));
+            }
+
+        }
+        catch (SQLException e) {
+            e.printStackTrace();
+        }
+        close();
+        return result;
+    }
+
+    public void setChannelSettings(String channelId, String Sprache, String ServerId, String Kanalname) {
+
+        if(!isActive()) {
+            return;
+        }
+
+        open();
+        try {
+            conn = getConn();
+            String SQL_SELECT = "SELECT * FROM shadowrun_channelSettings where channelId = ?";
+
+            PreparedStatement preparedStatement = conn.prepareStatement(SQL_SELECT);
+            preparedStatement.setString(1, channelId);
+            ResultSet rs = preparedStatement.executeQuery();
+            if (rs.next()) {
+                String SQL_Update = "UPDATE shadowrun_channelSettings SET lang = ? WHERE channelId = ?";
+                preparedStatement = conn.prepareStatement(SQL_Update);
+                preparedStatement.setString(1, Sprache);
+                preparedStatement.setString(2, channelId);
+                preparedStatement.executeUpdate();
+
+            }
+            else {
+                String SQL_INSERT = "INSERT INTO shadowrun_channelSettings (channelId, lang, serverId, kanalname) VALUES (?,?,?,?)";
+                preparedStatement = conn.prepareStatement(SQL_INSERT);
+                preparedStatement.setString(1, channelId);
+                preparedStatement.setString(2, Sprache);
+                preparedStatement.setString(3, ServerId);
+                preparedStatement.setString(4, Kanalname);
+                preparedStatement.executeUpdate();
+            }
+
+            close();
+            return;
+
+        }
+        catch (SQLException e) {
+            e.printStackTrace();
+        }
+        close();
+        return;
+    }
+
+    public Map<String, String> getMesssage(Long MsgId) {
+        Map<String, String> result = new HashMap<>();
+
+        if(!isActive()) {
+            return result;
+        }
+        result.put("lang", "de");
+
+        open();
+        try {
+            conn = getConn();
+            String SQL_SELECT = "SELECT * FROM shadowrun_log where MsgID = ?";
+
+            PreparedStatement preparedStatement = conn.prepareStatement(SQL_SELECT);
+            preparedStatement.setLong(1, MsgId);
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next()) {
+                result.put("benutzerId", rs.getString("benutzerId"));
+                result.put("wurfdaten", rs.getString("wurfdaten"));
+            }
+
+        }
+        catch (SQLException e) {
+            e.printStackTrace();
+        }
+        close();
+        return result;
+    }
+}
+
+/*
+ CREATE TABLE `shadowrun_log` (
+ `id` INT NOT NULL AUTO_INCREMENT,
+ `zeitstempel` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ `wurf` VARCHAR(255) NOT NULL DEFAULT '0',
+ `ergebnis`  VARCHAR(255) NOT NULL DEFAULT '0',
+ `benutzer` VARCHAR(255) NOT NULL DEFAULT '0',
+ `benutzerId` VARCHAR(255) NOT NULL DEFAULT '0',
+ `kanal` VARCHAR(50) NOT NULL DEFAULT '0',
+ PRIMARY KEY (`id`)
+ )
+ COLLATE='utf8_general_ci'
+ ;
+
+  CREATE TABLE `shadowrun_channelSettings` (
+ `id` INT NOT NULL AUTO_INCREMENT,
+ `zeitstempel` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ `channelId` VARCHAR(50) NOT NULL DEFAULT '0',
+ `lang` VARCHAR(255) NOT NULL DEFAULT 'de',
+ `serverId` VARCHAR(255) NULL,
+ `kanalname` VARCHAR(255) NULL,
+ PRIMARY KEY (`id`)
+ )
+ COLLATE='utf8_general_ci'
+ ;
+ */

src/main/java/Shadowrun/dice.java

@@ -0,0 +1,637 @@
+package Shadowrun;
+
+import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.JDA;
+import net.dv8tion.jda.api.entities.channel.ChannelType;
+import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.api.entities.channel.ChannelType;
+import net.dv8tion.jda.api.entities.User;
+import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import net.dv8tion.jda.api.events.message.react.MessageReactionAddEvent;
+import net.dv8tion.jda.api.hooks.ListenerAdapter;
+import net.dv8tion.jda.api.requests.restaction.*;
+
+
+import java.awt.*;
+
+import java.security.SecureRandom;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Random;
+import java.util.concurrent.ThreadLocalRandom;
+
+public class dice extends ListenerAdapter {
+
+    private String prefixSr;
+    private String prefixIni;
+    private String prefixZitat;
+    private String prefixTest;
+    private String prefixCId;
+
+    private language langDe = new language("de");
+    private language langEn = new language("en");
+
+    private help helpDe = new help("de");
+    private help helpEn = new help("En");
+
+    private language activLang;
+    private help activHelp;
+
+    private db_connect db;
+
+
+    private Map<String, String> channelList = new HashMap<>();
+
+
+    public dice() {
+        this.prefixSr = "/sr";
+        this.prefixIni = "/ini";
+        this.prefixTest = "/rollTest";
+        this.prefixZitat = "/zitat";
+        this.prefixCId = "/cid";
+
+
+        helpDe.add("Alle Befehle können in einen Channel geschrieben werden oder per Direkt Nachricht gesender werden");
+        helpDe.add(this.prefixSr + "Zahl", "Würfelt Zahl x W6. Gewürfelte 5. und 6. Werden als Erfolge gezählt, 1. als Misserfolge.\n" +
+                "Erreicht oder übersteigt die Anzhal der 1. die hälfte der gewürfelten Würfel, zählt dies als ein Patzer. Gibt es mind. 1 Erfolg wird die Markierung der Ausgabe Gelb." +
+                "wird aber kein Erfolg gewürfelt zählt dies als Kritischer Patzer und die Markierung wird Rot **Wichtig: Vor- und Nachteile die Einfluss auf die Patzer Changse haben werden nicht berücksichtigt");
+
+        helpDe.add(this.prefixSr + "+ Zahl", "Gleich wie bei " + this.prefixSr + "Zahl. Mit dem Unterschied dass alle gewürfelten 6. ein zuzätlichen Würfel generien.");
+
+        helpDe.add(this.prefixSr + " Zahl_1 + Zahl_2", "Würfelt Zahl_2 x W6 und addiert Zahl_1 hinzu, um die Initative zu bestimmen");
+
+        helpDe.add(this.prefixIni + " Zahl_1 + Zahl_2", "Synonym für " + this.prefixSr + " Zahl_1 + Zahl_2");
+
+        helpDe.add(this.prefixCId, "Gibt aktuelle Channel ID zurück");
+
+
+        this.db = new db_connect();
+    }
+
+    @Override
+    public void onMessageReceived(MessageReceivedEvent event) {
+        if ((!event.getMessage().getContentRaw().startsWith(this.prefixSr)
+                && !event.getMessage().getContentRaw().startsWith(this.prefixIni)
+                && !event.getMessage().getContentRaw().startsWith(this.prefixZitat)
+                && !event.getMessage().getContentRaw().startsWith(this.prefixTest)
+                && !event.getMessage().getContentRaw().startsWith(this.prefixCId))
+                || (event.getChannelType() != ChannelType.TEXT && event.getChannelType() != ChannelType.PRIVATE)) {
+            return;
+        }
+
+        if(!channelList.containsKey(event.getChannel().getId())) {
+            Map<String, String> Einstellungen = db.getChannelSettings(event.getChannel().getId());
+            channelList.put(event.getChannel().getId(), Einstellungen.get("lang").toString());
+        }
+        switch (channelList.get(event.getChannel().getId())) {
+            case "de":
+                activLang = langDe;
+                break;
+            case "en":
+                activLang = langEn;
+                break;
+            default:
+                activLang = langDe;
+
+        }
+        User author = event.getAuthor();
+
+            if (event.getMessage().getContentRaw().startsWith(this.prefixSr))
+                this.srroll(event);
+            else if (event.getMessage().getContentRaw().startsWith(this.prefixIni))
+                this.ini(event);
+            else if (event.getMessage().getContentRaw().startsWith(this.prefixTest))
+                this.rollTest(event);
+            else if (event.getMessage().getContentRaw().startsWith(this.prefixZitat))
+                this.zitat(event);
+            else if (event.getMessage().getContentRaw().startsWith(this.prefixCId))
+                this.cid(event);
+    }
+
+    /*@Override
+    public void onMessageReactionAdd(MessageReactionAddEvent event) {
+        User user = event.getUser();
+        if(!channelList.containsKey(event.getChannel().getId())) {
+            Map<String, String> Einstellungen = db.getChannelSettings(event.getChannel().getId());
+            channelList.put(event.getChannel().getId(), Einstellungen.get("lang").toString());
+        }
+        switch (channelList.get(event.getChannel().getId())) {
+            case "de":
+                activLang = langDe;
+                break;
+            case "en":
+                activLang = langEn;
+                break;
+            default:
+                activLang = langDe;
+
+        }
+        if (!user.isBot()) {
+            if(event.getReactionEmote().getId().equals("517528156014510111")) { // SR Reaktion - reroll
+                reaktionRerollEdge(event);
+            }
+            else if(event.getReactionEmote().getId().equals("517545127376322596")) { // ausgedehnte probe
+                extensionroll(event);
+            }
+        }
+    }*/
+
+    /**
+     * rolltest
+     *
+     * @param event JDA Event
+     */
+    private void rollTest(MessageReceivedEvent event) {
+
+        EmbedBuilder test = new EmbedBuilder();
+        test.setTitle("Das ist ein Test");
+        test.setColor(Color.red);
+        test.setDescription("Text " + getAsMention(event));
+
+
+
+
+        int[] verteilung = new int[6];
+        int[] verteilung2 = new int[6];
+        int[] verteilung3 = new int[6];
+        int dice1, dice2, dice3;
+
+        try {
+            String[] MsgParts_exl_Mention = event.getMessage().getContentRaw().split(" ");
+            int rounds = Integer.parseInt(MsgParts_exl_Mention[1]);
+            if(rounds <= 0) {
+                event.getChannel().sendMessage("Nope").queue();
+                return;
+            }
+            for(int i = 0; i < rounds; i++) {
+                dice1 = new Random().nextInt(6);
+                dice2 = new SecureRandom().nextInt(6);
+                //dice3 = new ThreadLocalRandom().current().nextInt(6);
+                dice3 = ThreadLocalRandom.current().nextInt(0, 6);
+                verteilung[dice1]++;
+                verteilung2[dice2]++;
+                verteilung3[dice3]++;
+            }
+            for(int i = 0; i < 6; i++) {
+                float pro = verteilung[i]*100f/rounds;
+                test.addField(Integer.toString(i+1), Integer.toString(verteilung[i]) + " - " + String.format("%.2f", pro) + "%", true);
+            }
+            test.addBlankField(false);
+            for(int i = 0; i < 6; i++) {
+                float pro = verteilung2[i]*100f/rounds;
+                test.addField(Integer.toString(i+1), Integer.toString(verteilung2[i]) + " - " + String.format("%.2f", pro) + "%", true);
+            }
+            test.addBlankField(false);
+            for(int i = 0; i < 6; i++) {
+                float pro = verteilung3[i]*100f/rounds;
+                test.addField(Integer.toString(i+1), Integer.toString(verteilung3[i]) + " - " + String.format("%.2f", pro) + "%", true);
+            }
+            event.getChannel().sendMessageEmbeds(test.build()).queue();
+
+        }
+        catch (NumberFormatException e) {
+            event.getChannel().sendMessage("Nope").queue();
+        }
+        catch (Exception e) {
+            System.out.println("problem: " + e.getMessage());
+        }
+
+    }
+
+    /**
+     * rolltest
+     *
+     * @param event JDA Event
+     */
+    private void srroll(MessageReceivedEvent event) {
+
+        int numberOfDice = 1;
+        int diceart = 6;
+
+
+        boolean edge = false;
+
+        try {
+            // Prüfen ob Edge wurf
+            if(event.getMessage().getContentRaw().startsWith(this.prefixSr+"+") || event.getMessage().getContentRaw().startsWith(this.prefixSr+" +")) {
+                edge = true;
+            }
+
+            // korrikiert Edge eingabe von /sr + zu  /sr+
+            String ContentRaw = event.getMessage().getContentRaw();
+            if(event.getMessage().getContentRaw().startsWith(this.prefixSr+" +")) {
+                ContentRaw = ContentRaw.replace(this.prefixSr+" +", this.prefixSr+"+ ").replace("  ", " ");
+            }
+
+            // Prüfen ob Leerer Command gesendet wird
+            String[] MsgParts = ContentRaw.split(" ", 2);
+
+            if(MsgParts.length < 2) {
+                String message = activLang.emptyCommand;
+                message = message.replace("%command%", this.prefixSr);
+                event.getChannel().sendMessage(getAsMention(event) + message).queue();
+                return;
+            }
+
+            if(MsgParts[1].contains("+")) {
+                this.ini(event);
+                return;
+            }
+
+            if(MsgParts[1].trim().matches(".*[^0-9].*")) { // es wurden andere zeichen als Zahlen gefunden
+                if(MsgParts[1].trim().toLowerCase().equals("de")) {
+                    activLang = langDe;
+                    channelList.put(event.getChannel().getId(), "de");
+                    event.getChannel().sendMessage(getAsMention(event) + activLang.language).queue();
+                    db.setChannelSettings(event.getChannel().getId(), "de", event.getGuild().getId(), event.getChannel().getName());
+                    return;
+                }
+                else if(MsgParts[1].trim().toLowerCase().equals("en")) {
+                    activLang = langEn;
+                    channelList.put(event.getChannel().getId(), "en");
+                    event.getChannel().sendMessage(getAsMention(event) + activLang.language).queue();
+                    db.setChannelSettings(event.getChannel().getId(), "en", event.getGuild().getId(), event.getChannel().getName());
+                    return;
+                }
+
+                if(MsgParts[1].trim().toLowerCase().replace(" ", "").matches("([0-9]*)[dw]([0-9].*)")) { // format besteh aus (Zahlen)d(Zahlen) oder (Zahlen)w(Zahlen)
+                    String[] diceInterpreter = MsgParts[1].trim().toLowerCase().replace(" ", "").split("[wd]");
+                    try {
+                        diceart = Integer.parseInt(diceInterpreter[1]);
+                        numberOfDice = Integer.parseInt(diceInterpreter[0]);
+                    }
+                    catch (NumberFormatException e) {
+                        String message = activLang.error;
+                        message = message.replace("%command%", MsgParts[1].trim().toLowerCase());
+                        event.getChannel().sendMessage(getAsMention(event) + message).queue();
+                        return;
+                    }
+                }
+                else {
+                    String message = activLang.error;
+                    message = message.replace("%command%", MsgParts[1].trim());
+                    event.getChannel().sendMessage(getAsMention(event) + message).queue();
+                    return;
+                }
+            }
+            else {
+                try {
+                    numberOfDice = Integer.parseInt(MsgParts[1].trim().replace(" ", ""));
+                }
+                catch (NumberFormatException e) {
+                    String message = activLang.error;
+                    message = message.replace("%command%", MsgParts[1].trim());
+                    event.getChannel().sendMessage(getAsMention(event) + message).queue();
+                    return;
+                }
+            }
+
+            srrollOut(numberOfDice, diceart, edge, event.getChannel(), event.getAuthor(), getEffectiveName(event),  event.getMessage().getContentRaw(), -1, 0, event.getJDA());
+
+        }
+        catch (NumberFormatException e) {
+            event.getChannel().sendMessage("Nope").queue();
+        }
+        catch (Exception e) {
+            System.out.println("problem: " + e.getMessage());
+        }
+
+    }
+
+    /**
+     * srrollOut
+     *
+     * @param numberOfDice
+     * @param diceart
+     * @param edge
+     * @param channel
+     * @param user
+     * @param effectiveName
+     * @param inputMessage
+     * @param hitBasis
+     * @param type
+     */
+    private void srrollOut(int numberOfDice, int diceart, boolean edge, MessageChannel channel, User user, String effectiveName, String inputMessage, int hitBasis, int type, JDA jda) {
+
+        EmbedBuilder outputBox = new EmbedBuilder();
+
+        int[] verteilung = new int[diceart];
+        int dice1;
+        StringBuilder result = new StringBuilder("");
+        StringBuilder rollString = new StringBuilder("");
+
+        int hits = 0;
+        boolean glitches = false;
+
+        try {
+
+            if(numberOfDice <= 0) {
+                String message = activLang.noNegativ;
+                channel.sendMessage(user.getAsMention() + message).queue();
+                return;
+            }
+
+            int bonusEdegeDice = 0;
+            int dicecorrection = hitBasis < 0 ? 0 : hitBasis;
+            for(int i = 0; i < numberOfDice+bonusEdegeDice; i++) {
+                dice1 = new Random().nextInt(diceart);
+                if(edge && dice1 == 5)
+                    bonusEdegeDice++;
+                if(dice1 >= 4) {
+                    hits++;
+                }
+                verteilung[dice1]++;
+                if((dice1 >= 4) || (dice1 == 0))
+                    result.append("**").append(dice1+1).append("**");
+                else
+                    result.append(dice1+1);
+                result.append(" ");
+            }
+            if (verteilung[0] > (numberOfDice+bonusEdegeDice+dicecorrection)/2f) { // Patzer nur bei über er Hälfte an 1er
+                glitches = true;
+            }
+
+
+            if(hits+dicecorrection == 0 && !glitches) { // kein Erfolg, kein Patzer
+                outputBox.setColor(Color.gray);
+            }
+            else if(hits+dicecorrection == 0 && glitches) { // kritischer Patzer
+                outputBox.setColor(Color.red);
+            }
+            else if(glitches) { // Patzer
+                outputBox.setColor(Color.yellow);
+            }
+            else { // Erfolg
+                outputBox.setColor(Color.green);
+            }
+
+            String addition = "";
+            if(bonusEdegeDice > 0) {
+                addition = " + " + bonusEdegeDice + activLang.dice + diceart;
+            }
+            String message = "";
+            if(type == 1) {
+                message = activLang.resultText;
+                //%numberOfDice%%dice%%diceart% %EdgeDice%:\tErfolge: %hits%\tMisserfolge: %oneHits%";
+                message = message.replace("%numberOfDice%", String.valueOf(numberOfDice)).replace("%diceart%", String.valueOf(diceart)).replace("%EdgeDice%", addition).replace("%hits%", String.valueOf(hits) + "\t Gesamt: " + (hits + hitBasis)).replace("%oneHits%", String.valueOf(verteilung[0]));
+                outputBox.setTitle(effectiveName + " Edgereroll " + message);
+            }
+            if(type == 2) {
+                message = activLang.resultTextExtent;
+                //%numberOfDice%%dice%%diceart% %EdgeDice%:\tErfolge: %hits%\tMisserfolge: %oneHits%";
+                message = message.replace("%numberOfDice%", String.valueOf(numberOfDice)).replace("%diceart%", String.valueOf(diceart)).replace("%EdgeDice%", addition).replace("%hits%", String.valueOf(hits) + "\t Gesamt: " + (hits + hitBasis)).replace("%oneHits%", String.valueOf(verteilung[0]));
+                outputBox.setTitle(effectiveName + " Ausgedehnt " + message);
+            }
+            else {
+                message = activLang.resultText;
+                //%numberOfDice%%dice%%diceart% %EdgeDice%:\tErfolge: %hits%\tMisserfolge: %oneHits%";
+                message = message.replace("%numberOfDice%", String.valueOf(numberOfDice)).replace("%diceart%", String.valueOf(diceart)).replace("%EdgeDice%", addition).replace("%hits%", String.valueOf(hits)).replace("%oneHits%", String.valueOf(verteilung[0]));
+                outputBox.setTitle(effectiveName + message);
+            }
+
+
+
+            outputBox.setDescription("(" +  result.toString().trim() + ")");
+            //outputBox.appendDescription("\r" + jda.getEmoteById("517528156014510111").getAsMention() + " Edge reroll");
+            //outputBox.appendDescription("\r" + jda.getEmoteById("517545127376322596").getAsMention() + " Ausgedehnte Probe");
+            //JDA::getEmoteById();
+
+            for(int i = 0; i < diceart; i++) {
+                float pro = verteilung[i]*100f/numberOfDice;
+                //outputBox.addField(Integer.toString(i+1), Integer.toString(verteilung[i]) + " - " + String.format("%.2f", pro) + "%", true);
+            }
+
+            rollString.append(numberOfDice).append("|").append(hits+dicecorrection).append("|").append(verteilung[0]);
+
+            //event.getChannel().sendMessage(outputBox.build()).queue();
+            long[] messageId = new long[1];
+            boolean finalEdge = edge;
+            String finalRollData = rollString.toString();
+            channel.sendMessageEmbeds(outputBox.build()).queue(message1 -> {
+                if(!finalEdge && type == 0) {
+                    //message1.addReaction("sr:517528156014510111").queue();
+                }
+                if(!finalEdge && (type == 0 || type == 2)) {
+                    //message1.addReaction("test:517545127376322596").queue();
+                }
+                messageId[0] = message1.getIdLong();
+                if(channel.getType() == ChannelType.PRIVATE) {
+                    db.insertDice(user.getName(), user.getId(), inputMessage, result.toString().trim(), channel.getId(), messageId[0], finalRollData);
+                }
+                else {
+                    db.insertDice(user.getName(), user.getId(), inputMessage, result.toString().trim(), channel.getId(), messageId[0], finalRollData);
+                }
+            });
+
+
+        }
+        catch (NumberFormatException e) {
+            channel.sendMessage("Nope").queue();
+        }
+        catch (Exception e) {
+            System.out.println("problem: " + e.getMessage());
+        }
+
+    }
+    private void ini(MessageReceivedEvent event) {
+
+        EmbedBuilder outputBox = new EmbedBuilder();
+
+        int dice1;
+        int numberOfDice = 1;
+        int diceart = 6;
+        int iniBase = 0;
+        int ini = 0;
+        StringBuilder result = new StringBuilder("");
+
+        try {
+            String[] MsgParts = event.getMessage().getContentRaw().split(" ", 2);
+            if(MsgParts.length < 2) { // Leerer Befehl
+                String message = activLang.emptyCommand;
+                message = message.replace("%command%", this.prefixIni);
+                event.getChannel().sendMessage(getAsMention(event) + message).queue();
+                return;
+            }
+
+            if(MsgParts[1].trim().matches(".*[^0-9].*")) { // es wurden andere zeichen als Zahlen gefunden
+                if(MsgParts[1].trim().toLowerCase().equals("de")) {
+                    activLang = langDe;
+                    channelList.put(event.getChannel().getId(), "de");
+                    event.getChannel().sendMessage(getAsMention(event) + activLang.language).queue();
+                    return;
+                }
+                else if(MsgParts[1].trim().toLowerCase().equals("en")) {
+                    activLang = langEn;
+                    channelList.put(event.getChannel().getId(), "en");
+                    event.getChannel().sendMessage(getAsMention(event) + activLang.language).queue();
+                    return;
+                }
+
+
+                String[] iniParts = MsgParts[1].trim().toLowerCase().split("\\+", 2);
+                messageInterpreter mI = new messageInterpreter(event, activLang);
+                if(iniParts.length == 1) { // Nachricht hat kein + Zeichen
+                    mI.inputInterpreter(iniParts[0]);
+                    if(mI.isNum()) {
+                        numberOfDice = mI.getIntResult();
+                    }
+                    else if(mI.isDice()) {
+                        diceart = mI.getDiceart();
+                        numberOfDice = mI.getNumberOfDice();
+                    }
+
+                }
+                else {
+                    mI.inputInterpreter(iniParts[0]); // Vor dem +
+                    if(mI.isNum()) {
+                        iniBase = mI.getIntResult();
+                    }
+                    else if(mI.isDice()) {
+                        iniBase = mI.getNumberOfDice();
+                    }
+
+                    mI.inputInterpreter(iniParts[1]); // Nach dem +
+                    if(mI.isNum()) {
+                        numberOfDice = mI.getIntResult();
+                    }
+                    else if(mI.isDice()) {
+                        diceart = mI.getDiceart();
+                        numberOfDice = mI.getNumberOfDice();
+                    }
+
+                }
+
+            }
+            else {
+                try {
+                    numberOfDice = Integer.parseInt(MsgParts[1].trim().replace(" ", ""));
+                }
+                catch (NumberFormatException e) {
+                    String message = activLang.error;
+                    message = message.replace("%command%", MsgParts[1].trim());
+                    event.getChannel().sendMessage(getAsMention(event) + message).queue();
+                    return;
+                }
+            }
+
+            if(numberOfDice <= 0) {
+                String message = activLang.noNegativ;
+                event.getChannel().sendMessage(getAsMention(event) + message).queue();
+                return;
+            }
+
+
+            ini += iniBase;
+            for(int i = 0; i < numberOfDice; i++) {
+                dice1 = new Random().nextInt(diceart);
+                result.append(dice1+1).append(" ");
+                ini += (dice1+1);
+            }
+            outputBox.setColor(new Color(104, 34, 139));
+
+
+            String message = "%iniBase%+%numberOfDice%w%diceart%\tIni: %ini%"; //activLang.resultText;
+            //%numberOfDice%%dice%%diceart% %EdgeDice%:\tErfolge: %hits%\tMisserfolge: %oneHits%";
+            message = message.replace("%numberOfDice%", String.valueOf(numberOfDice)).replace("%diceart%", String.valueOf(diceart))
+                    .replace("%iniBase%", String.valueOf(iniBase)).replace("%ini%", String.valueOf(ini));
+            outputBox.setTitle(getEffectiveName(event)  + message);
+
+
+            outputBox.setDescription(String.valueOf(iniBase) + " + (" +  result.toString().trim().replace(" ", "+") + ")");
+
+            event.getChannel().sendMessageEmbeds(outputBox.build()).queue();
+
+        }
+        catch (NumberFormatException e) {
+            event.getChannel().sendMessage("Nope").queue();
+        }
+        catch (IllegalArgumentException e) {
+            event.getChannel().sendMessage(e.getMessage()).queue();
+        }
+        catch (Exception e) {
+            System.out.println("problem: " + e.getMessage());
+        }
+
+    }
+    private void zitat(MessageReceivedEvent event) {
+        String[] quotes = new String[7];
+
+        quotes[0] = "*quiek quiek quiek*";
+        quotes[1] = "" +
+                "(\\\\______/)\n" +
+                "( ͡ ͡° ͜ ʖ ͡ ͡°)  *snuff snuff*\n" +
+                "\\\\╭☞ \\\\╭☞\n" +
+                "";
+        quotes[2] = "(づ｡◕‿‿◕｡)づ";
+        quotes[3] = "zzzZZZZZzzZZ";
+        quotes[4] = "piiiep";
+        quotes[5] = "grrrrr";
+        //quotes[6] = "ʕᵔᴥᵔʔ =*Auto translator*=> In meiner psychophysischen Konstituton manifestiert sich eine absolute Dominanz positiver Effekte für die Individualität Deiner Person. ";
+
+        int dice = new Random().nextInt(600);
+        event.getChannel().sendMessage(quotes[dice%6]).queue();
+    }
+    private void cid(MessageReceivedEvent event) {
+        event.getChannel().sendMessage(getAsMention(event) + " " + event.getChannel().getId()).queue();
+    }
+
+    private String getEffectiveName(MessageReceivedEvent event) {
+        if(event.getMember() == null) {
+            return "";
+        }
+        return event.getMember().getEffectiveName() + " ";
+    }
+
+    private String getAsMention(MessageReceivedEvent event) {
+        if(event.getMember() == null) {
+            return "";
+        }
+        return event.getMember().getAsMention() + " ";
+    }
+
+    private void reaktionRerollEdge(MessageReactionAddEvent event) {
+        Map<String, String> wurf = db.getMesssage(event.getMessageIdLong());
+        if(!wurf.containsKey("benutzerId")) {
+            return;
+        }
+        else if(!wurf.get("benutzerId").equals(event.getUserId())) {
+            return;
+        }
+        String[] wurfParts = wurf.get("wurfdaten").split("\\|");
+        int dice = Integer.parseInt(wurfParts[0]);
+        int hits = Integer.parseInt(wurfParts[1]);
+        int miss = Integer.parseInt(wurfParts[2]);
+        String effectName = "";
+        if(event.getMember().getEffectiveName() != "") {
+            effectName = event.getMember().getEffectiveName();
+        }
+        srrollOut(dice-hits, 6, false, event.getChannel(), event.getUser(), effectName, "Edege Reroll", hits, 1, event.getJDA());
+
+    }
+
+    private void extensionroll(MessageReactionAddEvent event) {
+        Map<String, String> wurf = db.getMesssage(event.getMessageIdLong());
+        if(!wurf.containsKey("benutzerId")) {
+            return;
+        }
+        else if(!wurf.get("benutzerId").equals(event.getUserId())) {
+            return;
+        }
+        String[] wurfParts = wurf.get("wurfdaten").split("\\|");
+        int dice = Integer.parseInt(wurfParts[0]);
+        int hits = Integer.parseInt(wurfParts[1]);
+        int miss = Integer.parseInt(wurfParts[2]);
+        String effectName = "";
+        if(event.getMember().getEffectiveName() != "") {
+            effectName = event.getMember().getEffectiveName();
+        }
+        if(dice == 1) {
+            event.getChannel().sendMessage(event.getUser().getAsMention() + " mehr geht nicht, du hast **" + hits + "** Erfolge").queue();
+        }
+        else {
+            srrollOut(dice - 1, 6, false, event.getChannel(), event.getUser(), effectName, "Extent Roll", hits, 2, event.getJDA());
+        }
+
+    }
+}

src/main/java/Shadowrun/help.java

@@ -0,0 +1,30 @@
+package Shadowrun;
+
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+
+
+public class help {
+
+    private StringBuilder hilfstext;
+    private String sprache;
+
+    public help(String sprache) {
+        this.sprache = sprache;
+        hilfstext = new StringBuilder("");
+    }
+
+    public void add(String befehl, String hilftext) {
+        if(this.hilfstext.length() > 0)
+            this.hilfstext.append("\n\n");
+        this.add("**" + befehl + "** " + hilftext);
+    }
+
+    public void add(String hilftext) {
+        this.hilfstext.append(hilftext);
+    }
+
+    public void send() {
+        StringBuilder ausgabe = new StringBuilder("");
+
+    }
+}

src/main/java/Shadowrun/language.java

@@ -0,0 +1,93 @@
+package Shadowrun;
+
+import java.io.*;
+import java.util.Properties;
+
+
+public class language {
+
+    public String language = "Deutsch";
+    public String emptyCommand = " der %command% befehl benötigt einen Wert";
+    public String error = " Irgend was dummes ist passiert beim Verstehen von %command%";
+    public String error2 = " Irgend was dummes ist passiert beim Verstehen von %command%";
+    public String noNegativ = " es darf kein Negativen Wurf geben";
+    public String dice = "w";
+    public String resultText = " %numberOfDice%w%diceart% %EdgeDice%:\tErfolge: %hits%\tMisserfolge: %oneHits%";
+    public String resultTextExtent = " %numberOfDice%w%diceart% %EdgeDice%:\tErfolge: %hits%\tMisserfolge: %oneHits%";
+    public String basisresultText = " %numberOfDice%w%diceart%:";
+
+    public language() {
+        this.readConfig();
+    }
+
+    /**
+     *
+     * @param lang Srache
+     */
+    public language(String lang) {
+        this.readConfig(lang);
+    }
+
+    public void readConfig() {
+        this.readConfig("de");
+    }
+    public void readConfig(String lang) {
+        FileInputStream input = null;
+        OutputStream output = null;
+        Properties config = new Properties();
+        try {
+            File f = new File("shadowrun.cfg");
+            if (f.isFile() && f.canRead()) {
+
+                input = new FileInputStream("shadowrun.cfg");
+                config.load(input);
+                if(config.containsKey(lang + ".language"))
+                    this.language = config.getProperty(lang + ".language");
+
+                if(config.containsKey(lang + ".emptyCommand"))
+                    this.emptyCommand = config.getProperty(lang + ".emptyCommand");
+                if(config.containsKey(lang + ".error"))
+                    this.error = config.getProperty(lang + ".error");
+                if(config.containsKey(lang + ".error2"))
+                    this.error2 = config.getProperty(lang + ".error2");
+                if(config.containsKey(lang + ".noNegativ"))
+                    this.noNegativ = config.getProperty(lang + ".noNegativ");
+                if(config.containsKey(lang + ".dice"))
+                    this.dice = config.getProperty(lang + ".dice");
+                if(config.containsKey(lang + ".resultText"))
+                    this.resultText = config.getProperty(lang + ".resultText");
+                if(config.containsKey(lang + ".resultTextExtent"))
+                    this.resultText = config.getProperty(lang + ".resultTextExtent");
+                if(config.containsKey(lang + ".basisresultText"))
+                    this.resultText = config.getProperty(lang + ".basisresultText");
+
+            }
+            else {
+                output = new FileOutputStream("shadowrun.cfg");
+                config.setProperty(lang + ".language", this.language);
+                config.setProperty(lang + ".emptyCommand", this.emptyCommand);
+                config.setProperty(lang + ".error", this.error);
+                config.setProperty(lang + ".error2", this.error2);
+                config.setProperty(lang + ".noNegativ", this.noNegativ);
+                config.setProperty(lang + ".dice", this.dice);
+                config.setProperty(lang + ".resultText", this.resultText);
+                config.setProperty(lang + ".resultTextExtent", this.resultTextExtent);
+                config.setProperty(lang + ".basisresultText", this.basisresultText);
+                config.store(output, null);
+
+            }
+        } catch (Exception e) {
+
+        }
+        finally {
+            if (input != null) {
+                try {
+                    input.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
+

src/main/java/Shadowrun/messageInterpreter.java

@@ -0,0 +1,90 @@
+package Shadowrun;
+
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+
+import java.util.Scanner;
+
+public class messageInterpreter {
+
+    private Integer diceart = 6;
+    private Integer numberOfDice = 1;
+    private Integer typ = 0;
+    private Integer intResult = 0;
+
+    private language activLang;
+    private MessageReceivedEvent event;
+
+
+    public Integer getDiceart() {
+        return diceart;
+    }
+
+    public Integer getNumberOfDice() {
+        return numberOfDice;
+    }
+
+    public Integer getIntResult() {
+        return intResult;
+    }
+
+    public boolean isNum() {
+        if(typ == 1) {
+            return  true;
+        }
+        return false;
+    }
+
+    public boolean isDice() {
+        if(typ == 2) {
+            return  true;
+        }
+        return false;
+    }
+    /**
+     *
+     * @param event JDA Event
+     * @param activLang Aktive Sprache
+     */
+    public messageInterpreter(MessageReceivedEvent event, language activLang) {
+        this.event = event;
+        this.activLang = activLang;
+    }
+    private void reset() {
+        diceart = 6;
+        numberOfDice = 1;
+        typ = 0;
+        intResult = 0;
+    }
+    public void inputInterpreter(String Input) {
+        reset();
+        Scanner sc = new Scanner(Input.trim());
+
+        if(sc.hasNextInt()) { // ist eine Zahl
+            typ = 1;
+            intResult = Integer.parseInt(Input.trim());
+            return;
+        }
+        else {
+            if (Input.trim().toLowerCase().replace(" ", "").matches("([0-9]*)[dw]([0-9].*)")) { // format besteh aus (Zahlen)d(Zahlen) oder (Zahlen)w(Zahlen)
+                String[] diceInterpreter = Input.trim().toLowerCase().replace(" ", "").split("[wd]");
+                try {
+                    diceart = Integer.parseInt(diceInterpreter[1]);
+                    numberOfDice = Integer.parseInt(diceInterpreter[0]);
+                    typ = 2;
+                } catch (NumberFormatException e) {
+                    String message = activLang.error;
+                    message = message.replace("%command%", Input.trim().toLowerCase());
+                    //event.getChannel().sendMessage(event.getMember().getAsMention() + message).queue();
+                    typ = -1;
+                    throw new IllegalArgumentException( message );
+                }
+            }
+            else {
+                String message = activLang.error;
+                message = message.replace("%command%", Input.trim().toLowerCase());
+                typ = -1;
+                throw new IllegalArgumentException( message );
+            }
+        }
+    }
+}

src/main/java/Simpleroll/dice.java

@@ -0,0 +1,174 @@
+package Simpleroll;
+
+import Shadowrun.db_connect;
+import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.entities.User;
+import net.dv8tion.jda.api.entities.channel.ChannelType;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import net.dv8tion.jda.api.hooks.ListenerAdapter;
+
+import java.awt.*;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Random;
+
+public class dice extends ListenerAdapter {
+
+    private String prefixR;
+    private String prefixRoll;
+    private String prefixHelp;
+
+    private language langDe = new language("de");
+    private language langEn = new language("en");
+
+    private help helpDe = new help("de");
+    private help helpEn = new help("En");
+
+    private language activLang;
+    private help activHelp;
+
+    private db_connect db;
+
+    private Map<String, String> channelList = new HashMap<>();
+
+
+    public dice() {
+        this.prefixR = "/roll";
+        this.prefixRoll = "/r ";
+        this.prefixHelp = "/help";
+
+        this.db = new db_connect();
+    }
+
+    @Override
+    public void onMessageReceived(MessageReceivedEvent event) {
+        if ((!event.getMessage().getContentRaw().startsWith(this.prefixR)
+                && !event.getMessage().getContentRaw().startsWith(this.prefixRoll) && !event.getMessage().getContentRaw().startsWith(this.prefixHelp))
+                || (event.getChannelType() != ChannelType.TEXT && event.getChannelType() != ChannelType.PRIVATE)) {
+            return;
+        }
+
+        if(!channelList.containsKey(event.getChannel().getId())) {
+            Map<String, String> Einstellungen = db.getChannelSettings(event.getChannel().getId());
+            channelList.put(event.getChannel().getId(), Einstellungen.get("lang").toString());
+        }
+        switch (channelList.get(event.getChannel().getId())) {
+            case "en":
+                activLang = langEn;
+                break;
+            case "de":
+            default:
+                activLang = langDe;
+
+        }
+        User author = event.getAuthor();
+        if (event.getMessage().getContentRaw().startsWith(this.prefixR) || event.getMessage().getContentRaw().startsWith(this.prefixRoll))
+            this.roll(event);
+        if (event.getMessage().getContentRaw().startsWith(this.prefixHelp))
+            this.help(event);
+    }
+
+
+    private String getEffectiveName(MessageReceivedEvent event) {
+        if(event.getMember() == null) {
+            return "";
+        }
+        return event.getMember().getEffectiveName() + " ";
+    }
+
+    private String getAsMention(MessageReceivedEvent event) {
+        if(event.getMember() == null) {
+            return "";
+        }
+        return event.getMember().getAsMention() + " ";
+    }
+
+    /**
+     * rolltest
+     *
+     * @param event JDA Event
+     */
+    private void roll(MessageReceivedEvent event) {
+
+        EmbedBuilder outputBox = new EmbedBuilder();
+
+        try {
+
+            String ContentRaw = event.getMessage().getContentRaw();
+
+            // Prüfen ob Leerer Command gesendet wird
+            String[] MsgParts = ContentRaw.replace("  ", " ").split(" ", 2);
+
+            if(MsgParts.length < 2) {
+                String message = activLang.emptyCommand;
+                message = message.replace("%command%", this.prefixRoll);
+                event.getChannel().sendMessage(getAsMention(event) + message).queue();
+                return;
+            }
+
+
+            if(MsgParts[1].trim().toLowerCase().equals("de")) {
+                activLang = langDe;
+                channelList.put(event.getChannel().getId(), "de");
+                event.getChannel().sendMessage(getAsMention(event) + activLang.language).queue();
+                db.setChannelSettings(event.getChannel().getId(), "de", event.getGuild().getId(), event.getChannel().getName());
+                return;
+            }
+            else if(MsgParts[1].trim().toLowerCase().equals("en")) {
+                activLang = langEn;
+                channelList.put(event.getChannel().getId(), "en");
+                event.getChannel().sendMessage(getAsMention(event) + activLang.language).queue();
+                db.setChannelSettings(event.getChannel().getId(), "en", event.getGuild().getId(), event.getChannel().getName());
+                return;
+            }
+
+            messageInterpreter mI = new messageInterpreter(activLang, MsgParts[1]);
+
+
+            outputBox.setColor(Color.green);
+
+            outputBox.setTitle(getEffectiveName(event) + " " + mI.getHeaderOutput() + ": " + mI.getResult());
+
+
+            if(mI.isComplex())
+                outputBox.setDescription(mI.getResolveOutput() + "\n" + mI.getBodyOutput());
+            else
+                outputBox.setDescription(mI.getBodyOutput());
+
+
+            event.getChannel().sendMessageEmbeds(outputBox.build()).queue();
+
+            System.runFinalization();
+            System.gc();
+
+        }
+        catch (NumberFormatException e) {
+            event.getChannel().sendMessage("Nope").queue();
+        }
+        catch (Exception e) {
+            System.out.println("problem: " + e.getMessage());
+        }
+
+    }
+
+    private void help(MessageReceivedEvent event) {
+        EmbedBuilder outputBox = new EmbedBuilder();
+        StringBuilder result = new StringBuilder("");
+
+
+        outputBox.setTitle("Hallo ich exestieren aktuell in der Version: 0.10\n");
+
+        result.append("Ich kann aktuell folgent Wüfe:\n");
+        result.append("**/r** bzw. **/roll** für Allgemeine würfe. Ohne eine angabe vom Würfeltyp wird ein W6 benuzt\n\n");
+        result.append("**/sr** für Shadowrun 5\n\n");
+        result.append("**/ed** für Earthdawn 4\n\n");
+        result.append("**/e** bzw **/engel** für die Arcane Version von Engel\n\n");
+        result.append("**/l5r** bzw **/keep** für Legend  of the 5 Rings\n");
+
+        outputBox.setDescription(result);
+        event.getChannel().sendMessageEmbeds(outputBox.build()).queue();
+    }
+
+
+    //7d4+19+1d7
+}

src/main/java/Simpleroll/diceOld.java

@@ -0,0 +1,238 @@
+package Simpleroll;
+
+import Shadowrun.db_connect;
+import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.entities.channel.ChannelType;
+import net.dv8tion.jda.api.entities.User;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import net.dv8tion.jda.api.hooks.ListenerAdapter;
+
+import java.awt.*;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Random;
+
+public class diceOld extends ListenerAdapter {
+
+    private String prefixR;
+    private String prefixRoll;
+    private String prefixHelp;
+
+    private language langDe = new language("de");
+    private language langEn = new language("en");
+
+    private help helpDe = new help("de");
+    private help helpEn = new help("En");
+
+    private language activLang;
+    private help activHelp;
+
+    private db_connect db;
+
+    private Map<String, String> channelList = new HashMap<>();
+
+
+    public diceOld() {
+        this.prefixR = "/roll";
+        this.prefixRoll = "/r ";
+        this.prefixHelp = "/help";
+
+        this.db = new db_connect();
+    }
+
+    @Override
+    public void onMessageReceived(MessageReceivedEvent event) {
+        if ((!event.getMessage().getContentRaw().startsWith(this.prefixR)
+                && !event.getMessage().getContentRaw().startsWith(this.prefixRoll) && !event.getMessage().getContentRaw().startsWith(this.prefixHelp))
+                || (event.getChannelType() != ChannelType.TEXT && event.getChannelType() != ChannelType.PRIVATE)) {
+            return;
+        }
+
+        if(!channelList.containsKey(event.getChannel().getId())) {
+            Map<String, String> Einstellungen = db.getChannelSettings(event.getChannel().getId());
+            channelList.put(event.getChannel().getId(), Einstellungen.get("lang").toString());
+        }
+        switch (channelList.get(event.getChannel().getId())) {
+            case "de":
+                activLang = langDe;
+                break;
+            case "en":
+                activLang = langEn;
+                break;
+            default:
+                activLang = langDe;
+
+        }
+        User author = event.getAuthor();
+        if (event.getMessage().getContentRaw().startsWith(this.prefixR) || event.getMessage().getContentRaw().startsWith(this.prefixRoll))
+            this.roll(event);
+        if (event.getMessage().getContentRaw().startsWith(this.prefixHelp))
+            this.help(event);
+    }
+
+
+    private String getEffectiveName(MessageReceivedEvent event) {
+        if(event.getMember() == null) {
+            return "";
+        }
+        return event.getMember().getEffectiveName() + " ";
+    }
+
+    private String getAsMention(MessageReceivedEvent event) {
+        if(event.getMember() == null) {
+            return "";
+        }
+        return event.getMember().getAsMention() + " ";
+    }
+
+    /**
+     * rolltest
+     *
+     * @param event JDA Event
+     */
+    private void roll(MessageReceivedEvent event) {
+
+        EmbedBuilder outputBox = new EmbedBuilder();
+
+        int[] verteilung = new int[6];
+        int dice1;
+        int numberOfDice = 1;
+        int diceart = 6;
+        StringBuilder result = new StringBuilder("");
+
+        int hits = 0;
+
+
+        try {
+
+            String ContentRaw = event.getMessage().getContentRaw();
+
+            // Prüfen ob Leerer Command gesendet wird
+            String[] MsgParts = ContentRaw.replace("  ", " ").split(" ", 2);
+
+            if(MsgParts.length < 2) {
+                String message = activLang.emptyCommand;
+                message = message.replace("%command%", this.prefixRoll);
+                event.getChannel().sendMessage(getAsMention(event) + message).queue();
+                return;
+            }
+
+
+            if(MsgParts[1].trim().matches(".*[^0-9].*")) { // es wurden andere zeichen als Zahlen gefunden
+                if(MsgParts[1].trim().toLowerCase().equals("de")) {
+                    activLang = langDe;
+                    channelList.put(event.getChannel().getId(), "de");
+                    event.getChannel().sendMessage(getAsMention(event) + activLang.language).queue();
+                    db.setChannelSettings(event.getChannel().getId(), "de", event.getGuild().getId(), event.getChannel().getName());
+                    return;
+                }
+                else if(MsgParts[1].trim().toLowerCase().equals("en")) {
+                    activLang = langEn;
+                    channelList.put(event.getChannel().getId(), "en");
+                    event.getChannel().sendMessage(getAsMention(event) + activLang.language).queue();
+                    db.setChannelSettings(event.getChannel().getId(), "en", event.getGuild().getId(), event.getChannel().getName());
+                    return;
+                }
+
+                if(MsgParts[1].trim().toLowerCase().replace(" ", "").matches("([0-9]*)[dw]([0-9].*)")) { // format besteh aus (Zahlen)d(Zahlen) oder (Zahlen)w(Zahlen)
+                    String[] diceInterpreter = MsgParts[1].trim().toLowerCase().replace(" ", "").split("[wd]");
+                    try {
+                        diceart = Integer.parseInt(diceInterpreter[1]);
+                        numberOfDice = Integer.parseInt(diceInterpreter[0]);
+                        verteilung = new int[diceart];
+                    }
+                    catch (NumberFormatException e) {
+                        String message = activLang.error;
+                        message = message.replace("%command%", MsgParts[1].trim().toLowerCase());
+                        event.getChannel().sendMessage(getAsMention(event) + message).queue();
+                        return;
+                    }
+                }
+                else {
+                    String message = activLang.error;
+                    message = message.replace("%command%", MsgParts[1].trim());
+                    event.getChannel().sendMessage(getAsMention(event) + message).queue();
+                    return;
+                }
+            }
+            else {
+                try {
+                    numberOfDice = Integer.parseInt(MsgParts[1].trim().replace(" ", ""));
+                }
+                catch (NumberFormatException e) {
+                    String message = activLang.error;
+                    message = message.replace("%command%", MsgParts[1].trim());
+                    event.getChannel().sendMessage(getAsMention(event) + message).queue();
+                    return;
+                }
+            }
+
+
+            if(numberOfDice <= 0) {
+                String message = activLang.noNegativ;
+                event.getChannel().sendMessage(getAsMention(event) + message).queue();
+                return;
+            }
+
+            for(int i = 0; i < numberOfDice; i++) {
+                dice1 = new Random().nextInt(diceart);
+                verteilung[dice1]++;
+                result.append(dice1+1);
+                result.append(" ");
+            }
+            outputBox.setColor(Color.green);
+            String addition = "";
+
+            String message = activLang.basisresultText;
+            //%numberOfDice%%dice%%diceart% %EdgeDice%:\tErfolge: %hits%\tMisserfolge: %oneHits%";
+            message = message.replace("%numberOfDice%", String.valueOf(numberOfDice)).replace("%diceart%", String.valueOf(diceart));
+            outputBox.setTitle(getEffectiveName(event) + message);
+
+
+            outputBox.setDescription("(" +  result.toString().trim() + ")");
+
+            for(int i = 0; i < diceart; i++) {
+                float pro = verteilung[i]*100f/numberOfDice;
+                //outputBox.addField(Integer.toString(i+1), Integer.toString(verteilung[i]) + " - " + String.format("%.2f", pro) + "%", true);
+            }
+
+            event.getChannel().sendMessageEmbeds(outputBox.build()).queue();
+            /*event.getChannel().sendMessage(outputBox.build()).queue(message1 -> {
+                message1.addReaction("sr:517528156014510111").queue();
+                message1.addReaction("test:517545127376322596").queue();
+            });*/
+            /*
+            if(event.getChannelType() == ChannelType.PRIVATE) {
+                db.insertDice(event.getAuthor().getName(), event.getAuthor().getId(), event.getMessage().getContentRaw(), result.toString().trim(), event.getChannel().getId());
+            }
+            else {
+                db.insertDice(event.getMember().getEffectiveName(), event.getMember().getUser().getId(), event.getMessage().getContentRaw(), result.toString().trim(), event.getChannel().getId());
+            }*/
+        }
+        catch (NumberFormatException e) {
+            event.getChannel().sendMessage("Nope").queue();
+        }
+        catch (Exception e) {
+            System.out.println("problem: " + e.getMessage());
+        }
+
+    }
+
+    private void help(MessageReceivedEvent event) {
+        EmbedBuilder outputBox = new EmbedBuilder();
+        StringBuilder result = new StringBuilder("");
+
+
+        outputBox.setTitle("Hallo ich exestieren aktuell in der Version: 0.8\n");
+
+        result.append("Ich kann aktuell folgent Wüfe:\n");
+        result.append("**/r** bzw. **/roll** für Allgemeine würfe. Ohne eine angabe vom Würfeltyp wird ein W6 benuzt\n\n");
+        result.append("**/sr** für Shadowrun 5\n\n");
+        result.append("**/ed** für Earthdawn 4\n\n");
+        result.append("**/e** bzw **/engel** für die Arcane Version von Engel\n\n");
+        result.append("**/l5r** bzw **/keep** für Legend  of the 5 Rings\n");
+
+        outputBox.setDescription(result);
+        event.getChannel().sendMessage(outputBox.build().toString()).queue();
+    }
+}

src/main/java/Simpleroll/help.java

@@ -0,0 +1,28 @@
+package Simpleroll;
+
+
+public class help {
+
+    private StringBuilder hilfstext;
+    private String sprache;
+
+    public help(String sprache) {
+        this.sprache = sprache;
+        hilfstext = new StringBuilder("");
+    }
+
+    public void add(String befehl, String hilftext) {
+        if(this.hilfstext.length() > 0)
+            this.hilfstext.append("\n\n");
+        this.add("**" + befehl + "** " + hilftext);
+    }
+
+    public void add(String hilftext) {
+        this.hilfstext.append(hilftext);
+    }
+
+    public void send() {
+        StringBuilder ausgabe = new StringBuilder("");
+
+    }
+}

src/main/java/Simpleroll/language.java

@@ -0,0 +1,89 @@
+package Simpleroll;
+
+import java.io.*;
+import java.util.Properties;
+
+
+public class language {
+
+    public String language = "Deutsch";
+    public String emptyCommand = " der %command% befehl benötigt einen Wert";
+    public String error = " Irgend was dummes ist passiert beim Verstehen von %command%";
+    public String error2 = " Irgend was dummes ist passiert beim Verstehen von %command%";
+    public String noNegativ = " es darf kein Negativen Wurf geben";
+    public String dice = "w";
+    public String resultText = " %numberOfDice%w%diceart% %EdgeDice%:\tErfolge: %hits%\tMisserfolge: %oneHits%";
+    public String basisresultText = " %numberOfDice%w%diceart%:";
+
+    public language() {
+        this.readConfig();
+    }
+
+    /**
+     *
+     * @param lang Srache
+     */
+    public language(String lang) {
+        this.readConfig(lang);
+    }
+
+    public void readConfig() {
+        this.readConfig("de");
+    }
+    public void readConfig(String lang) {
+        FileInputStream input = null;
+        OutputStream output = null;
+        Properties config = new Properties();
+        try {
+            File f = new File("shadowrun.cfg");
+            if (f.isFile() && f.canRead()) {
+
+                input = new FileInputStream("shadowrun.cfg");
+                config.load(input);
+                if(config.containsKey(lang + ".language"))
+                    this.language = config.getProperty(lang + ".language");
+
+                if(config.containsKey(lang + ".emptyCommand"))
+                    this.emptyCommand = config.getProperty(lang + ".emptyCommand");
+                if(config.containsKey(lang + ".error"))
+                    this.error = config.getProperty(lang + ".error");
+                if(config.containsKey(lang + ".error2"))
+                    this.error2 = config.getProperty(lang + ".error2");
+                if(config.containsKey(lang + ".noNegativ"))
+                    this.noNegativ = config.getProperty(lang + ".noNegativ");
+                if(config.containsKey(lang + ".dice"))
+                    this.dice = config.getProperty(lang + ".dice");
+                if(config.containsKey(lang + ".resultText"))
+                    this.resultText = config.getProperty(lang + ".resultText");
+                if(config.containsKey(lang + ".basisresultText"))
+                    this.resultText = config.getProperty(lang + ".basisresultText");
+
+            }
+            else {
+                output = new FileOutputStream("shadowrun.cfg");
+                config.setProperty(lang + ".language", this.language);
+                config.setProperty(lang + ".emptyCommand", this.emptyCommand);
+                config.setProperty(lang + ".error", this.error);
+                config.setProperty(lang + ".error2", this.error2);
+                config.setProperty(lang + ".noNegativ", this.noNegativ);
+                config.setProperty(lang + ".dice", this.dice);
+                config.setProperty(lang + ".resultText", this.resultText);
+                config.setProperty(lang + ".basisresultText", this.basisresultText);
+                config.store(output, null);
+
+            }
+        } catch (Exception e) {
+
+        }
+        finally {
+            if (input != null) {
+                try {
+                    input.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
+

src/main/java/Simpleroll/messageInterpreter.java

@@ -0,0 +1,227 @@
+package Simpleroll;
+
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+
+import java.util.Random;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+
+public class messageInterpreter {
+
+    private Integer intResult = 0;
+
+    private final language activLang;
+
+    private final StringBuilder bodyOutput;
+
+    private final StringBuilder resolveOutput;
+
+    private final StringBuilder headerOutput;
+
+    private boolean isComplex;
+
+    public Integer getIntResult() {
+        return intResult;
+    }
+
+
+    /**
+     *
+     * @param activLang Aktive Sprache
+     */
+    public messageInterpreter(language activLang) {
+        this.activLang = activLang;
+        bodyOutput = new StringBuilder();
+        resolveOutput = new StringBuilder();
+        headerOutput = new StringBuilder();
+        isComplex = false;
+    }
+    public messageInterpreter(language activLang, String Input) {
+        this(activLang);
+        inputInterpreter(Input);
+    }
+
+    public void inputInterpreter(String Input) {
+
+        if(Input.trim().toLowerCase().replace(" ", "").matches("\\d+")) {
+            Input = Input.trim().toLowerCase().replace(" ", "") + "w6";
+        }
+        subpart result = new subpart();
+        result =  subPartAnalyse(Input);
+        resolveOutput.append(result.getResolveOutput());
+        bodyOutput.append(result.getBodyOutput());
+        headerOutput.append(result.getHeaderOutput());
+        intResult = result.getResolve();
+    }
+
+
+    private subpart subPartAnalyse(String part) {
+        subpart result = new subpart();
+        part = part.trim().toLowerCase().replace(" ", "");
+        boolean first = true;
+/*
+        if(part.contains("max(")) {
+            /*
+            1d6 + max(5d5+10,2d4+2) + 15
+
+             * /
+            Pattern pattern = Pattern.compile("(?:.*)max\\((.*?)\\).*");
+            Matcher matcher = pattern.matcher(part);
+            if(matcher.find()) {
+                //String pre = part.substring(0, (matcher.start() - 3));
+                //String operation = part.substring((matcher.start() + 1), (matcher.end()-1));
+                //String after = part.substring(matcher.end());
+                StringBuilder newBody = new StringBuilder("max(");
+                StringBuilder newHeader = new StringBuilder("max(");
+                String[] subParts = matcher.group(1).split(",");
+                subpart[] tempSubparts = new subpart[subParts.length];
+                int i = 0;
+                int highest = 0;
+                for(String subPart : subParts) { // Vergleichen welcher wert der höhste ist
+                    tempSubparts[i] = subPartAnalyse(subPart);
+                    if(i != highest && tempSubparts[i].getResolve() > tempSubparts[highest].getResolve()) {
+                        highest = i;
+                    }
+                    if(i > 0) {
+                        newBody.append("), ");
+                        newHeader.append(", ");
+                    }
+                    newBody.append("(");
+                    newBody.append(tempSubparts[i].getBodyOutput());
+                    newHeader.append(tempSubparts[i].getHeaderOutput());
+                    i++;
+                }
+                newBody.append(")");
+                newHeader.append(")");
+
+                int partmarker = new Random().nextInt(1500);
+                //subPartAnalyse(part.substring(0, (matcher.start() - 3)) + tempSubparts[highest].getResolve() + part.substring(matcher.end()));
+                subpart contAnalyser = subPartAnalyse(part.substring(0, (matcher.start(1) - 4)) + " ###b" + tempSubparts[highest].getResolve() + "##" + partmarker + "e### " + part.substring(matcher.end(1)+1));
+                tempSubparts[highest].getResolve();
+                result.appendBodyOutput(contAnalyser.getBodyOutput().replaceAll("###b" + tempSubparts[highest].getResolve() + "##" + partmarker + "e###", newBody.toString()));
+                result.appendResolveOutput(contAnalyser.getResolveOutput().replaceAll("###b" + tempSubparts[highest].getResolve() + "##" + partmarker + "e###", "max(" + contAnalyser.getResolve().toString() + ")"));
+                result.appendHeaderOutput(contAnalyser.getHeaderOutput().replaceAll("###b" + tempSubparts[highest].getResolve() + "##" + partmarker + "e###", newHeader.toString()));
+                result.addResolve(contAnalyser.getResolve());
+
+            }
+            //part.matches("")
+            return result;
+        }
+        if(part.contains("min(")) {
+
+        }*/
+        if(part.contains("+")) {
+            String[] subParts = part.trim().split("\\+");
+            subpart tempSubpart;
+            for(String subPart : subParts) {
+                tempSubpart = subPartAnalyse(subPart);
+                if(!first) {
+                    result.appendBodyOutput(" + ");
+                    result.appendResolveOutput(" + ");
+                    result.appendHeaderOutput(" + ");
+                }
+                first = false;
+                result.appendBodyOutput(tempSubpart.getBodyOutput());
+                result.appendResolveOutput(tempSubpart.getResolveOutput());
+                result.appendHeaderOutput(tempSubpart.getHeaderOutput());
+                result.addResolve(tempSubpart.getResolve());
+            }
+            isComplex = true;
+            return result;
+        }
+        if(part.contains("-")) {
+            String[] subParts = part.trim().split("\\-");
+            subpart tempSubpart;
+            for(String subPart : subParts) {
+                tempSubpart = subPartAnalyse(subPart);
+                if(!first) {
+                    result.appendBodyOutput(" - ");
+                    result.appendResolveOutput(" - ");
+                    result.appendHeaderOutput(" - ");
+                    result.addResolve(tempSubpart.getResolve()*-1);
+                }
+                else
+                    result.addResolve(tempSubpart.getResolve());
+                first = false;
+                result.appendBodyOutput(tempSubpart.getBodyOutput());
+                result.appendResolveOutput(tempSubpart.getResolveOutput());
+                result.appendHeaderOutput(tempSubpart.getHeaderOutput());
+
+            }
+            isComplex = true;
+            return result;
+        }
+
+        if(part.matches("([0-9]*)[dw]([0-9]*)")) {
+            String[] diceInterpreter = part.split("[wd]");
+            try {
+                int diceart = Integer.parseInt(diceInterpreter[1]);
+                int numberOfDice = 1;
+                if(!diceInterpreter[0].isEmpty())
+                    numberOfDice = Integer.parseInt(diceInterpreter[0]);
+                result = roll(diceart, numberOfDice);
+            } catch (NumberFormatException e) {
+                String message = activLang.error;
+                message = message.replace("%command%", part.trim().toLowerCase());
+                throw new IllegalArgumentException( message );
+            }
+        }
+
+        else if(part.matches("\\d+")) {
+            result.addResolve(Integer.parseInt(part));
+            result.appendBodyOutput(part);
+            result.appendHeaderOutput(part);
+            result.appendResolveOutput(part);
+        }
+        else if(part.matches("###b\\d+##\\d+e###")) {
+            Pattern pattern = Pattern.compile("###b(\\d+)##\\d+e###");
+            Matcher matcher = pattern.matcher(part);
+            matcher.find();
+            result.addResolve(Integer.parseInt(matcher.group(1)));
+            result.appendBodyOutput(part);
+            result.appendHeaderOutput(part);
+            result.appendResolveOutput(part);
+        }
+        return result;
+    }
+
+    subpart roll(Integer diceart, Integer numberOfDice) {
+        int dice = 0;
+        subpart result = new subpart();
+        result.appendHeaderOutput(numberOfDice.toString() + "w" + diceart.toString());
+        result.appendBodyOutput("(");
+        for(int i = 0; i < numberOfDice; i++) {
+            dice = new Random().nextInt(diceart);
+            if(i > 0) {
+                result.appendBodyOutput(", ");
+            }
+            result.appendBodyOutput(dice+1);
+            result.addResolve(dice+1);
+        }
+        result.appendBodyOutput(")");
+        result.appendResolveOutput("(" + result.getResolve() + ")");
+        return result;
+    }
+
+    public String getBodyOutput() {
+        return bodyOutput.toString();
+    }
+
+    public String getResolveOutput() {
+        return resolveOutput.toString();
+    }
+
+    public String getHeaderOutput() {
+        return headerOutput.toString();
+    }
+
+    public Integer getResult() {
+        return intResult;
+    }
+
+    public boolean isComplex() {
+        return isComplex;
+    }
+
+}

src/main/java/Simpleroll/subpart.java

@@ -0,0 +1,69 @@
+package Simpleroll;
+
+public class subpart {
+    private StringBuilder bodyOutput;
+
+    private StringBuilder resolveOutput;
+
+    private StringBuilder headerOutput;
+
+    private Integer resolve;
+
+    public subpart() {
+        bodyOutput = new StringBuilder("");
+        resolveOutput = new StringBuilder("");
+        headerOutput = new StringBuilder("");
+        resolve = 0;
+    }
+
+    public String getBodyOutput() {
+        return bodyOutput.toString();
+    }
+
+    public void appendBodyOutput(String bodyOutput) {
+        this.bodyOutput.append(bodyOutput);
+    }
+    public void appendBodyOutput(Integer bodyOutput) {
+        this.bodyOutput.append(bodyOutput);
+    }
+
+    public String getResolveOutput() {
+        return resolveOutput.toString();
+    }
+
+    public void appendResolveOutput(String resolveOutput) {
+        this.resolveOutput.append(resolveOutput);
+    }
+
+    public String getHeaderOutput() {
+        return headerOutput.toString();
+    }
+
+    public void appendHeaderOutput(String headerOutput) {
+        this.headerOutput.append(headerOutput);
+    }
+
+    public Integer getResolve() {
+        return resolve;
+    }
+
+    public void setResolve(Integer resolve) {
+        this.resolve = resolve;
+    }
+
+    public void setBodyOutput(String bodyOutput) {
+        this.bodyOutput = new StringBuilder(bodyOutput);
+    }
+
+    public void setResolveOutput(String resolveOutput) {
+        this.resolveOutput = new StringBuilder(resolveOutput);
+    }
+
+    public void setHeaderOutput(String headerOutput) {
+        this.headerOutput = new StringBuilder(headerOutput);
+    }
+
+    public void addResolve(Integer i) {
+        this.resolve += i;
+    }
+}

src/main/java/Socket/shadowrun.java

@@ -0,0 +1,172 @@
+package Socket;
+
+import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.JDA;
+
+import java.awt.*;
+import java.io.*;
+import java.net.ServerSocket;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.Scanner;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.net.Socket;
+
+
+public class shadowrun implements Runnable{
+
+    private JDA jda;
+
+    public shadowrun(JDA jda) {
+        this.jda = jda;
+
+    }
+
+    @Override
+    public void run()  {
+        int port = 11112;
+        try (ServerSocket listener = new ServerSocket(port)) {
+            System.out.println("Socket Server laeuft...");
+            ExecutorService pool = Executors.newFixedThreadPool(20);
+            while (true) {
+                pool.execute(new iniEcho(listener.accept(), jda));
+            }
+        }
+        catch (IOException e) {
+            System.err.println("Unable to process client request");
+            e.printStackTrace();
+        }
+
+    }
+
+
+    private static class iniEcho implements Runnable {
+        private Socket socket;
+        private JDA jda;
+
+        private boolean checkin;
+        private Scanner in;
+        private PrintWriter out;
+
+        private String salt;
+
+        iniEcho(Socket socket, JDA jda) {
+            this.socket = socket;
+            this.jda = jda;
+            this.checkin = false;
+            this.salt = "SamIstDerKoenigDerMatrix";
+        }
+
+        @Override
+        public void run() {
+            System.out.println("Connected: " + socket);
+            try {
+                in = new Scanner(socket.getInputStream());
+                out = new PrintWriter(socket.getOutputStream(), true);
+                String message = "";
+                while (in.hasNextLine()) {
+                    if(this.checkin == false) {
+                        chekin();
+                        continue;
+                    }
+                    message = in.nextLine().trim();
+                    switch (message) {
+                        case "get":
+                            break;
+                        case "send":
+                            send();
+                            break;
+                    }
+
+                    //out.println(message.toUpperCase() + "...");
+                    //jda.getGuildById("404979829537243148").getTextChannelById("542202034330271759").sendMessage(message).queue();
+                    //jda.getTextChannelById("542202034330271759").sendMessage(message).queue();
+                    //jda.sen
+                }
+            } catch (Exception e) {
+                System.out.println("Error:" + socket);
+            } finally {
+                try { socket.close(); } catch (IOException e) { e.printStackTrace(); }
+                System.out.println("Closed: " + socket);
+            }
+        }
+
+        /**
+         * bearbeitet Checkin
+         */
+        private void chekin() {
+            System.out.println("checkin");
+            String message = "";
+            message = in.nextLine().trim();
+            System.out.println(message);
+            if(message.startsWith("SRCheckin")) {
+                String[] msgParts = message.split("\\|", 3);
+                String Hash = getHash(msgParts[1] + salt);
+                System.out.println(msgParts[2].trim() + "  --  " + Hash);
+                if(msgParts[2].trim().equals(Hash)) {
+                    checkin = true;
+                    out.println("ACK");
+
+                }
+            }
+        }
+
+        /**
+         * Wandelt String in SHA-1 Hash um
+         * @param Input
+         * @return
+         */
+        private String getHash(String Input) {
+            try {
+                MessageDigest md = MessageDigest.getInstance("SHA-1");
+                md.update(salt.getBytes());
+                byte[] bytes = md.digest(Input.getBytes());
+                StringBuilder sb = new StringBuilder();
+                for(int i=0; i< bytes.length ;i++) {
+                    sb.append(Integer.toString((bytes[i] & 0xff) + 0x100, 16).substring(1));
+                }
+                return sb.toString();
+            }
+            catch (NoSuchAlgorithmException e) {
+                e.printStackTrace();
+            }
+            return "";
+        }
+
+        private void send() {
+            out.println("ACKSend");
+            String message;
+            EmbedBuilder outputBox = new EmbedBuilder();
+            outputBox.setColor(Color.BLACK);
+            outputBox.setTitle("Initiative:");
+            String channelId = "542202034330271759";
+
+            while (in.hasNextLine()) {
+                message = in.nextLine().trim();
+                if(message.trim().equals("FIN")) {
+                    break;
+                }
+                if(message.startsWith("out:")) {
+                    String[] msgParts = message.split(":", 2);
+                    if(!msgParts[1].equals(""))
+                        channelId = msgParts[1];
+                }
+                else {
+
+                    String[] msgParts = message.split("\\|");
+                    //jda.getUserById(msgParts[0]).getName();
+                    StringBuilder iniTicks = new StringBuilder();
+                    iniTicks.append(msgParts[1]);
+                    for(int i = 2; i < msgParts.length; i++) {
+                        iniTicks.append("\t - \t ");
+                        iniTicks.append(msgParts[i]);
+                    }
+                    outputBox.addField(msgParts[0], iniTicks.toString(), false);
+                }
+                out.println("ACKSend");
+            }
+            jda.getTextChannelById(channelId).sendMessage(outputBox.build().toString()).queue();
+        }
+    }
+}

src/main/java/Vampire/dice.java

@@ -0,0 +1,302 @@
+package Vampire;
+
+import Shadowrun.db_connect;
+import Simpleroll.help;
+import Simpleroll.language;
+import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.entities.channel.ChannelType;
+import net.dv8tion.jda.api.entities.User;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import net.dv8tion.jda.api.hooks.ListenerAdapter;
+
+import java.awt.*;
+import java.util.*;
+import java.util.regex.MatchResult;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class dice extends ListenerAdapter {
+
+    private String prefixlong;
+    private String prefixShort;
+    private String prefixVeryShort;
+
+    private language langDe = new language("de");
+    private language langEn = new language("en");
+
+    private help helpDe = new help("de");
+    private help helpEn = new help("En");
+
+    private language activLang;
+    private help activHelp;
+
+    private db_connect db;
+
+    private Map<String, String> channelList = new HashMap<>();
+
+
+    public dice() {
+        this.prefixlong = "/vampire";
+        this.prefixShort = "/v";
+
+        this.db = new db_connect();
+    }
+
+    @Override
+    public void onMessageReceived(MessageReceivedEvent event) {
+        if ((!event.getMessage().getContentRaw().toLowerCase().startsWith(this.prefixlong)
+                && !event.getMessage().getContentRaw().toLowerCase().startsWith(this.prefixShort))
+                || (event.getChannelType() != ChannelType.TEXT && event.getChannelType() != ChannelType.PRIVATE)) {
+            return;
+        }
+
+        if(!channelList.containsKey(event.getChannel().getId())) {
+            Map<String, String> Einstellungen = db.getChannelSettings(event.getChannel().getId());
+            channelList.put(event.getChannel().getId(), Einstellungen.get("lang").toString());
+        }
+        switch (channelList.get(event.getChannel().getId())) {
+            case "de":
+                activLang = langDe;
+                break;
+            case "en":
+                activLang = langEn;
+                break;
+            default:
+                activLang = langDe;
+
+        }
+        User author = event.getAuthor();
+        if (event.getMessage().getContentRaw().toLowerCase().startsWith(this.prefixlong) || event.getMessage().getContentRaw().toLowerCase().startsWith(this.prefixShort))
+            this.roll(event);
+    }
+
+
+    private String getEffectiveName(MessageReceivedEvent event) {
+        if(event.getMember() == null) {
+            return "";
+        }
+        return event.getMember().getEffectiveName() + " ";
+    }
+
+    private String getAsMention(MessageReceivedEvent event) {
+        if(event.getMember() == null) {
+            return "";
+        }
+        return event.getMember().getAsMention() + " ";
+    }
+
+    /**
+     *
+     *
+     * @param event JDA Event
+     */
+    private void roll(MessageReceivedEvent event) {
+
+        EmbedBuilder outputBox = new EmbedBuilder();
+        StringBuilder result = new StringBuilder("");
+        StringBuilder resultDice = new StringBuilder("");
+        StringBuilder resultHungerDice = new StringBuilder("");
+        String msgText = "";
+        String rollState = "";
+
+        int numberOfDice, numberOfHungerDice, successes, difficult, dice1;
+        numberOfDice = numberOfHungerDice =  successes = difficult = 0;
+
+        int[] verteilungGesammt = new int[11];
+        int[] verteilungHunger = new int[11];
+
+        try {
+
+            String ContentRaw = event.getMessage().getContentRaw();
+
+            // Prüfen ob Leerer Command gesendet wird
+            String[] MsgParts = ContentRaw.replace("  ", " ").split(" ", 2);
+
+            if(MsgParts.length < 2) {
+                String message = activLang.emptyCommand;
+                message = message.replace("%command%", this.prefixShort);
+                event.getChannel().sendMessage(getAsMention(event) + message).queue();
+                return;
+            }
+
+            msgText = MsgParts[1].trim();
+            if(msgText.matches(".*[^0-9].*")) { // es wurden andere zeichen als Zahlen gefunden
+                if(msgText.toLowerCase().equals("de")) {
+                    activLang = langDe;
+                    channelList.put(event.getChannel().getId(), "de");
+                    event.getChannel().sendMessage(getAsMention(event) + activLang.language).queue();
+                    db.setChannelSettings(event.getChannel().getId(), "de", event.getGuild().getId(), event.getChannel().getName());
+                    return;
+                }
+                else if(msgText.toLowerCase().equals("en")) {
+                    activLang = langEn;
+                    channelList.put(event.getChannel().getId(), "en");
+                    event.getChannel().sendMessage(getAsMention(event) + activLang.language).queue();
+                    db.setChannelSettings(event.getChannel().getId(), "en", event.getGuild().getId(), event.getChannel().getName());
+                    return;
+                }
+                else if(msgText.toLowerCase().equals("help") || msgText.toLowerCase().equals("hilfe")) {
+                    event.getChannel().sendMessage(getAsMention(event)
+                    + " Die Syntax lautet XkY z.b. 5k4\nEs werden X mal W10 gewürfelt und davon die höhsten Anzahl Y behalten und addiert. Wird eine 10 gewürfelt, wird der Wurf weiter gewürfelt und addiert aber nur als ein Wurf gezählt.\nWird nach dem XkY eine weiter Zahl angeben so ist dies die Schwierigkeit\n"
+                        + "Wird nach dem XkY eine Zahl mit + oder - Angegeben, zählt dies als ein Modifikator für das ergebnis.\n\n"
+                        + "Zudem gibt es folgente sonderzeichen, die an belibiger stelle gesetz werden können:\n"
+                        + "! - auch gewüfelte 9 explodieren\n"
+                        + "e - gewürfelte 1 werden neu gewürfelt\n"
+                        + "# - Würfel explodierente nur einmal\n"
+                        + "n - Würfel explodierente nicht\n"
+                     ).queue();
+
+                    return;
+                }
+
+                if(msgText.toLowerCase().matches(".*([0-9]+) +([0-9]+) +([0-9]+).*")) { // X Y Z Aufbau in der Anfrage
+                    Pattern pattern = Pattern.compile("([0-9]+) +([0-9]+) +([0-9]+)");
+                    Matcher matcher = pattern.matcher(msgText.toLowerCase());
+                    matcher.find();
+                    MatchResult elements = matcher.toMatchResult();
+                    numberOfDice = Integer.parseInt(elements.group(1));
+                    numberOfHungerDice = Integer.parseInt(elements.group(2));
+                    difficult = Integer.parseInt(elements.group(3));
+                }
+                else if(msgText.toLowerCase().matches(".*([0-9]+) +([0-9]+).*")) { // XkY Aufbau in der Anfrage
+                    Pattern pattern = Pattern.compile("([0-9]+) +([0-9]+)");
+                    Matcher matcher = pattern.matcher(msgText.toLowerCase());
+                    matcher.find();
+                    MatchResult elements = matcher.toMatchResult();
+                    numberOfDice = Integer.parseInt(elements.group(1));
+                    numberOfHungerDice = Integer.parseInt(elements.group(2));
+                }
+                else {
+                    String message = activLang.error;
+                    message = message.replace("%command%", msgText);
+                    event.getChannel().sendMessage(getAsMention(event) + message).queue();
+                    return;
+                }
+            }
+            else {
+                    String message = activLang.error;
+                    message = message.replace("%command%", msgText);
+                    event.getChannel().sendMessage(getAsMention(event) + message).queue();
+                    return;
+            }
+
+            if(numberOfDice <= 0) {
+                String message = activLang.noNegativ;
+                event.getChannel().sendMessage(getAsMention(event) + message).queue();
+                return;
+            }
+
+            if(numberOfDice < numberOfHungerDice) {
+                numberOfHungerDice = numberOfDice;
+            }
+
+            for(int i = 0; i < numberOfDice-numberOfHungerDice; i++) {
+                dice1 = new Random().nextInt(10);
+                dice1++;
+                if(dice1 >= 6) {
+                    successes++;
+                }
+                verteilungGesammt[dice1]++;
+                if(resultDice.length() > 0)
+                    resultDice.append(" ");
+                if((dice1 >= 6))
+                    resultDice.append("**").append(dice1).append("**");
+                else
+                    resultDice.append(dice1);
+            }
+            for(int i = 0; i < numberOfHungerDice; i++) {
+                dice1 = new Random().nextInt(10);
+                dice1++;
+                if(dice1 >= 6) {
+                    successes++;
+                }
+                verteilungGesammt[dice1]++;
+                verteilungHunger[dice1]++;
+                if(resultHungerDice.length() > 0)
+                    resultHungerDice.append(" ");
+                if((dice1 >= 6))
+                    resultHungerDice.append("**").append(dice1).append("**");
+                else
+                    resultHungerDice.append(dice1);
+            }
+
+
+            if(verteilungGesammt[10] > 2) {
+                successes += 2;
+            }
+
+            if((difficult > 0 && successes > difficult) || (difficult == 0 && successes > 0)) { // erfolg
+                if(verteilungGesammt[10] > 2) {
+                    if(verteilungHunger[10] > 0) {
+                        rollState = "Krit";
+                        outputBox.setColor(Color.green);
+                    }
+                    else {
+                        rollState = "Schmutziger Triumphe";
+                        outputBox.setColor(Color.red);
+                    }
+                }
+                else {
+                    rollState = "Erfolg";
+                    outputBox.setColor(Color.green);
+                }
+            }
+            else if(difficult > 0 && successes > 0) { // Fehlschlag
+                if(verteilungHunger[1] > 0) {
+                    rollState = "Bestialischer Fehlschlag";
+                    outputBox.setColor(Color.red);
+                }
+                else {
+                    rollState = "Fehlschlag";
+                    outputBox.setColor(Color.darkGray);
+                }
+            }
+            else if(successes == 0) { // Totaler Fehlschlag
+                if(verteilungHunger[1] > 0) {
+                    rollState = "Bestialischer Fehlschlag";
+                    outputBox.setColor(Color.red);
+                }
+                else {
+                    rollState = "Totaler Fehlschlag";
+                    outputBox.setColor(Color.darkGray);
+                }
+            }
+
+
+
+            // Ausgabe beginn
+            String addition = "";
+
+            if(difficult > 0) {
+                addition += " Schwierigkeit " + difficult;
+            }
+
+            String title = getEffectiveName(event) + "Pool " + numberOfDice;
+            if(numberOfHungerDice > 0) {
+                title += " Hunger " + numberOfHungerDice;
+            }
+            if(difficult > 0) {
+                title += " Schwierigkeit " + difficult;
+            }
+            outputBox.setTitle(title);
+/*
+            StringBuilder description = new StringBuilder();
+            for(int i = 0; i < numberOfDice; i++) {
+                if(description.length() > 0) {
+                    description.append(", ");
+                }
+                description.append(rolls[i].getText());
+            }
+            outputBox.setDescription("(" +  description + ")");*/
+            event.getChannel().sendMessage(outputBox.build().toString()).queue();
+        }
+        catch (NumberFormatException e) {
+            event.getChannel().sendMessage("Nope").queue();
+        }
+        catch (Exception e) {
+            System.out.println("problem: " + e.getMessage());
+        }
+
+    }
+
+}

src/main/java/Vampire/result.java

@@ -0,0 +1,105 @@
+package Vampire;
+
+import java.util.Random;
+
+public class result {
+    private StringBuilder text;
+    private int value;
+    private int diceart;
+    private Boolean reroll9;
+    private Boolean reroll1;
+    private Boolean maxReroll;
+    private Boolean noreroll;
+
+    public result() {
+        diceart = 10;
+        text = new StringBuilder();
+        value = 0;
+        reroll9 = false;
+        reroll1 = false;
+        maxReroll = false;
+        noreroll = false;
+    }
+
+    public String getText() {
+        return text.toString();
+    }
+
+    public void setText(String text) {
+        this.text = new StringBuilder();
+        this.text.append(text);
+    }
+
+    public void setMarket() {
+        String tmp = this.text.toString();
+        this.text = new StringBuilder();
+        this.text.append("**").append(tmp).append("**");
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    public void setValue(Integer value) {
+        this.value = value;
+    }
+
+    public result setReroll9(Boolean reroll9) {
+        this.reroll9 = reroll9;
+        return this;
+    }
+
+    public result setReroll1(Boolean reroll1) {
+        this.reroll1 = reroll1;
+        return this;
+    }
+
+    public result setMaxReroll(Boolean maxReroll) {
+        this.maxReroll = maxReroll;
+        return this;
+    }
+
+    public result setNoreroll(Boolean noreroll) {
+        this.noreroll = noreroll;
+        return this;
+    }
+
+    public result roll() {
+        int dice;
+        int rolls = 0;
+        Boolean reroll = false;
+
+        do{
+            reroll = false;
+            dice = new Random().nextInt(diceart);
+            dice++;
+
+            if(text.length() > 0) {
+                text.append("+");
+            }
+            if(reroll1 && dice == 1 && rolls <= 0) {
+                text.append("~~ ").append(dice).append(" ~~ ");
+            }
+            else {
+                text.append(dice);
+            }
+
+            value += dice;
+
+            if(!noreroll) {
+                if (dice == 10) {
+                    reroll = rolls <= 0 || !maxReroll; // wenn maxRolls an und schon einmal gerollt wurde kein reroll
+                    ++rolls;
+                } else if (reroll9 && dice == 9) {
+                    reroll = rolls <= 0 || !maxReroll;
+                } else if (reroll1 && dice == 1 && rolls <= 0) {
+                    reroll = true;
+                    value--;
+                }
+            }
+
+        } while(reroll);
+
+        return this;
+    }
+}

src/main/java/core/Controller.java

@@ -0,0 +1,4 @@
+package core;
+
+public class Controller {
+}

src/main/java/core/Main.java

@@ -1,42 +1,40 @@
 package core;
 
 
-import AtlasGruppe.groupchange;
+//import Serenity.balance;
-import net.dv8tion.jda.core.JDA;
+import net.dv8tion.jda.api.JDA;
-import net.dv8tion.jda.core.JDABuilder;
+import net.dv8tion.jda.api.JDABuilder;
-import net.dv8tion.jda.core.AccountType;
+import net.dv8tion.jda.api.OnlineStatus;
-import net.dv8tion.jda.core.OnlineStatus;
+import net.dv8tion.jda.api.entities.*;
-import net.dv8tion.jda.core.entities.Game;
+import net.dv8tion.jda.api.requests.GatewayIntent;
-
-
-import javax.security.auth.login.LoginException;
 
 public class Main {
 
     public static void main(String[] args) {
 
-        Config conf = new Config();
-        conf.readConfig();
         // Insert your bot's token here
-        //String token = "NTQ3MDc5NzgzNDE1MjgzNzEy.D0xjRw.ydeX_ou_pAqN_DCSwyGHzQUGBBk";
+        String token = "NTQ2ODk5MzYwMDEzODc3MjU4.D0u8wA.VfA2vJzundVhCl1-ibDiBaKuA8w";
-        String token = conf.token;
+        // iro
+        //String token = "NTQ2NzEwODUwOTIxMjk5OTc5.D0sL6A.1fUd5iBr3eo2tbPXofEqyumDm6w";
 
-        JDABuilder builder = new JDABuilder(AccountType.BOT);
+        JDA jda = JDABuilder.createDefault(token)
+                .enableIntents(GatewayIntent.MESSAGE_CONTENT)
+                .setActivity(Activity.playing("mit den Würfeln"))
+                .setStatus(OnlineStatus.ONLINE)
+                //.addEventListeners(new dice())
+                .addEventListeners(new Earthdawn.dice())
+                .addEventListeners(new Simpleroll.dice())
+                .addEventListeners(new Shadowrun.dice())
+                .addEventListeners(new Engel.dice())
+                .addEventListeners(new Keeproll.dice())
+                .setAutoReconnect(true)
+                .build();
 
+            //jda.upsertCommand("sr", "Calculate ping of the bot").queue();
 
+           // Thread thread = new Thread(new shadowrun(jda));
+            //thread.start();
 
-        builder.setToken(token);
-        builder.setAutoReconnect(true);
-        builder.setStatus(OnlineStatus.ONLINE);
-        builder.setGame(Game.watching(conf.GameWatching));
-        builder.addEventListener(new groupchange(conf));
-
-        try {
-            JDA jda = builder.build();
-        }
-        catch (LoginException e) {
-            e.printStackTrace();
-        }
 
 
     }

src/main/java/core/sample.fxml

@@ -0,0 +1,8 @@
+<?import javafx.geometry.Insets?>
+<?import javafx.scene.layout.GridPane?>
+
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.Label?>
+<GridPane fx:controller="core.Controller"
+          xmlns:fx="http://javafx.com/fxml" alignment="center" hgap="10" vgap="10">
+</GridPane>