grundlegente Umstellung + Earthdawn Implemntation

src/main/java/de/ocame/wuerfelbot/DB/base.java

@@ -0,0 +1,93 @@
+package de.ocame.wuerfelbot.DB;
+
+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/de/ocame/wuerfelbot/Earthdawn/EarthdawnCommand.java

@@ -0,0 +1,173 @@
+package de.ocame.wuerfelbot.Earthdawn;
+
+
+import de.ocame.wuerfelbot.commands.ICommand;
+import de.ocame.wuerfelbot.core.LoggerUtil;
+import de.ocame.wuerfelbot.output.DiceOutputFormatter;
+import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import net.dv8tion.jda.api.interactions.commands.OptionType;
+import net.dv8tion.jda.api.interactions.commands.build.CommandData;
+import net.dv8tion.jda.api.interactions.commands.build.Commands;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class EarthdawnCommand implements ICommand {
+
+    private final EarthdawnLogic earthdawnLogic;
+    private final DiceOutputFormatter outputFormatter;
+
+    public EarthdawnCommand() {
+        this.earthdawnLogic = new EarthdawnLogic();
+        this.outputFormatter = new DiceOutputFormatter();
+    }
+
+    @Override
+    public String getName() {
+        return "ed";
+    }
+
+    @Override
+    public String getDescription() {
+        return "Führt eine Earthdawn-Probe durch (Stufe + optional Karma oder Weihewürfel).";
+    }
+
+    @Override
+    public void executeSlash(SlashCommandInteractionEvent event) {
+        Integer stufe = event.getOption("stufe").getAsInt(); // "stufe" ist der Name der Option
+        Integer karma = event.getOption("karma") != null ? event.getOption("karma").getAsInt() : 0; // "karma" ist optional
+        Integer meisterkarma = event.getOption("meisterkarma") != null ? event.getOption("meisterkarma").getAsInt() : 0;
+        Integer weiheJ = event.getOption("weihe-j") != null ? event.getOption("weihe-j").getAsInt() : 0;
+        Integer weiheA = event.getOption("weihe-a") != null ? event.getOption("weihe-a").getAsInt() : 0;
+        Integer weiheV = event.getOption("weihe-v") != null ? event.getOption("weihe-v").getAsInt() : 0;
+
+
+        if (stufe < 1) {
+            event.reply(outputFormatter.formatError("Die Stufe muss mindestens 1 sein.")).setEphemeral(true).queue();
+            return;
+        }
+        if (karma < 0 || meisterkarma < 0 || weiheJ < 0 || weiheA < 0 || weiheV < 0) {
+            event.reply(outputFormatter.formatError("Zusatzwürfel dürfen nicht negativ sein.")).setEphemeral(true).queue();
+            return;
+        }
+
+        try {
+            EarthdawnLogic.EarthdawnResult result = earthdawnLogic.performEarthdawnRoll(stufe, karma, meisterkarma, weiheJ, weiheA, weiheV);
+            EmbedBuilder response = outputFormatter.DCDefaultOutput(getEffectiveName(event) + result.getTitle(), result.getDescription(), result.isGlitch());
+            event.deferReply().queue();
+            //event.reply(response).queue();
+            //event.getChannel().sendMessageEmbeds(response.build()).queue();
+            event.getHook().editOriginalEmbeds(response.build()).queue();
+           // event.replyEmbeds(response.build()).queue();
+        } catch (Exception e) {
+            LoggerUtil.log("error", "EDCommand", "Fehler bei Earthdawn-Probe: " + e.getMessage());
+            event.reply(outputFormatter.formatError("Ein Fehler ist bei der Earthdawn-Probe aufgetreten.")).setEphemeral(true).queue();
+        }
+    }
+
+    @Override
+        public void executeText(MessageReceivedEvent event, String[] args) {
+        if (args.length < 1) {
+            event.getChannel().sendMessage(outputFormatter.formatError("Verwendung: `!ed <stufe> [karma]`")).queue();
+            return;
+        }
+
+        Integer stufe = 0;
+        Integer karma = 0;
+        Integer meisterkarma = 0;
+        Integer weiheJ = 0;
+        Integer weiheA = 0;
+        Integer weiheV = 0;
+
+        boolean stufeParsed = false;
+
+        for (int i = 0; i < args.length; i++) {
+            String currentElement = args[i].trim().toLowerCase(); // Leerzeichen in Elementen entfernen
+
+            if (currentElement.isEmpty()) {
+                continue; // Leere Elemente überspringen
+            }
+
+            // 1. Stufe parsen (nur einmal ganz am Anfang)
+            if (!stufeParsed && currentElement.matches("^\\d+$")) {
+                stufe = Integer.parseInt(currentElement);
+                stufeParsed = true;
+                continue; // Stufe wurde geparst, gehe zum nächsten Element
+            } else if (!stufeParsed && currentElement.matches("^\\d+.*")) {
+                Pattern pattern = Pattern.compile("^(\\d+)");
+                Matcher matcher = pattern.matcher(currentElement);
+                matcher.find();
+                stufe = Integer.parseInt(matcher.group(1));
+                stufeParsed = true;
+
+                currentElement = currentElement.replaceAll("^\\d+", "");
+
+            }
+            karma += parseCharacterStat(currentElement, 'k');
+            meisterkarma += parseCharacterStat(currentElement, 'm');
+            weiheJ += parseCharacterStat(currentElement, 'j');
+            weiheA += parseCharacterStat(currentElement, 'a');
+            weiheV += parseCharacterStat(currentElement, 'v');
+
+
+        }
+
+
+        if (stufe < 1) {
+            event.getChannel().sendMessage(outputFormatter.formatError("Die Stufe muss mindestens 1 sein.")).queue();
+            return;
+        }
+
+
+        try {
+            EarthdawnLogic.EarthdawnResult result = earthdawnLogic.performEarthdawnRoll(stufe, karma, meisterkarma, weiheJ, weiheA, weiheV);
+            EmbedBuilder response = outputFormatter.DCDefaultOutput(getEffectiveName(event) + result.getTitle(), result.getDescription(), result.isGlitch());
+            event.getChannel().sendMessageEmbeds(response.build()).queue();
+        } catch (Exception e) {
+            LoggerUtil.log("error", "EDCommand", "Fehler bei Earthdawn-Probe: " + e.getMessage());
+            event.getChannel().sendMessage(outputFormatter.formatError("Ein Fehler ist bei der Earthdawn-Probe aufgetreten.")).queue();
+        }
+    }
+
+    @Override
+    public CommandData getSlashCommandData() {
+        return Commands.slash(getName(), getDescription())
+                .addOption(OptionType.INTEGER, "stufe", "Stufe der Probe", true)
+                .addOption(OptionType.INTEGER, "karma", "Optionale Anzahl der Karma (W6-Würfel)", false)
+                .addOption(OptionType.INTEGER, "meisterkarma", "Optionale Anzahl der Meister-Karma (W8-Würfel)", false)
+                .addOption(OptionType.INTEGER, "weihe-j", "Optionale Anzahl der Jünger-Weihewürfe (W4-Würfel)", false)
+                .addOption(OptionType.INTEGER, "weihe-a", "Optionale Anzahl der Anhänger-Weihewürfel (W6-Würfel)", false)
+                .addOption(OptionType.INTEGER, "weihe-v", "Optionale Anzahl der Vorbild-Weihewürfel (W8-Würfel)", false);
+    }
+
+    private String getEffectiveName(MessageReceivedEvent event) {
+        if (event.getMember() == null) {
+            return "";
+        }
+        return event.getMember().getEffectiveName() + " ";
+    }
+
+    private String getEffectiveName(SlashCommandInteractionEvent event) {
+        if (event.getMember() == null) {
+            return "";
+        }
+        return event.getMember().getEffectiveName() + " ";
+    }
+
+    private static int parseCharacterStat(String currentElement, char targetChar) {
+        int result = 0;
+        Pattern pattern = Pattern.compile("((" + targetChar + "+) *(\\d*))");
+        Matcher matcher = pattern.matcher(currentElement);
+        if (matcher.find()) {
+            if (matcher.group(2).length() == 1 && !matcher.group(3).isEmpty()) { // nur die K
+                result += Integer.parseInt(matcher.group(3));
+            }
+            else {
+                result += matcher.group(2).length();
+            }
+        }
+        return result;
+    }
+}

src/main/java/de/ocame/wuerfelbot/Earthdawn/EarthdawnLogic.java

@@ -0,0 +1,409 @@
+package de.ocame.wuerfelbot.Earthdawn;
+
+import java.util.*;
+
+public class EarthdawnLogic {
+
+    private final Random random;
+
+    private int w4;
+    private int w6;
+    private int w8;
+    private int w10;
+    private int w12;
+    private int w20;
+    private int karma;
+    private int meisterkarma;
+    private int weiheA;
+    private int weiheJ;
+    private int weiheV;
+
+    private boolean glitches;
+    private int resultInt;
+
+    private int modifier;
+
+    StringBuilder resultStructur;
+
+    public EarthdawnLogic() {
+        this.random = new Random();
+        reset();
+    }
+
+    public EarthdawnLogic reset() {
+        w4 = 0;
+        w6 = 0;
+        w8 = 0;
+        w10 = 0;
+        w12 = 0;
+        w20 = 0;
+        karma = 0;
+        meisterkarma = 0;
+        weiheJ = 0;
+        weiheA = 0;
+        weiheV = 0;
+
+        modifier = 0;
+
+        glitches = true;
+        resultInt = 0;
+
+        resultStructur = new StringBuilder();
+        return this;
+    }
+
+    /**
+     * Führt eine Earthdawn-Würfelprobe durch.
+     * Würfelt eine bestimmte Anzahl an Ws Abhänig von Stufe und optional Würfeln (z.b. Karma).
+     *
+     * @param stufe Die Stufe die Gewürfelt werden soll (Stufe). Muss >= 1 sein.
+     * @param karma  Die Anzahl der W6 (Karma), die gewürfelt werden sollen. Muss >= 0 sein.
+     * @param meisterkarma  Die Anzahl der W8 (Karma), die gewürfelt werden sollen. Muss >= 0 sein.
+     * @param weiheJ  Die Anzahl der W4 (Weihe Juenger), die gewürfelt werden sollen. Muss >= 0 sein.
+     * @param weiheA  Die Anzahl der W6 (Weihe Anheanger), die gewürfelt werden sollen. Muss >= 0 sein.
+     * @param weiheV  Die Anzahl der W8 (Weihe Vorbild), die gewürfelt werden sollen. Muss >= 0 sein.
+     * @return Ein {@link EarthdawnResult}-Objekt mit den einzelnen Würfelergebnissen und Summen.
+     * @throws IllegalArgumentException Wenn stufe < 1 oder optionale < 0 ist.
+     */
+    public EarthdawnResult performEarthdawnRoll(int stufe, int karma, int meisterkarma, int weiheJ, int weiheA, int weiheV) {
+        if (stufe < 1) {
+            throw new IllegalArgumentException("Die Stufe muss mindestens 1 sein.");
+        }
+        if (karma < 0) {
+            throw new IllegalArgumentException("Karma kann nicht negativ sein.");
+        }
+        if (meisterkarma < 0) {
+            throw new IllegalArgumentException("Meister-Karma kann nicht negativ sein");
+        }
+        if (weiheJ < 0) {
+            throw new IllegalArgumentException("Jünger-Weihewürfe kann nicht negativ sein.");
+        }
+        if (weiheA < 0) {
+            throw new IllegalArgumentException("Anhänger-Weihewürfe kann nicht negativ sein.");
+        }
+        if (weiheV < 0) {
+            throw new IllegalArgumentException("Vorbild-Weihewürfe kann nicht negativ sein.");
+        }
+        reset();
+
+        // Parameter in Würfel Konvertieren
+        calcStufe(stufe);
+        this.setKarma(karma);
+        this.setMeisterkarma(meisterkarma);
+        this.setWeiheJ(weiheJ);
+        this.setWeiheA(weiheA);
+        this.setWeiheV(weiheV);
+
+        // Würfelarten durchgehen und Würfeln, Sonderwürfel werden imm am Schluss abgearbeitet
+        StringBuilder resultConstruction = new StringBuilder();
+        List<DiceRollAction> rollsToPerform = new ArrayList<>();
+        if (w4 > 0) rollsToPerform.add(new DiceRollAction(w4, 4, null));
+        if (w6 > 0) rollsToPerform.add(new DiceRollAction(w6, 6, null));
+        if (w8 > 0) rollsToPerform.add(new DiceRollAction(w8, 8, null));
+        if (w10 > 0) rollsToPerform.add(new DiceRollAction(w10, 10, null));
+        if (w12 > 0) rollsToPerform.add(new DiceRollAction(w12, 12, null));
+        if (w20 > 0) rollsToPerform.add(new DiceRollAction(w20, 20, null));
+
+        // Sonderwürfel
+        if (karma > 0) rollsToPerform.add(new DiceRollAction(karma, 6, "Karma"));
+        if (meisterkarma > 0) rollsToPerform.add(new DiceRollAction(meisterkarma, 8, "Meisterkarma"));
+        if (weiheJ > 0) rollsToPerform.add(new DiceRollAction(weiheJ, 4, "Jünger"));
+        if (weiheA > 0) rollsToPerform.add(new DiceRollAction(weiheA, 6, "Anhänger"));
+        if (weiheV > 0) rollsToPerform.add(new DiceRollAction(weiheV, 8, "Vorbild"));
+
+        for (DiceRollAction action : rollsToPerform) {
+            rollDice(action.count, action.sides);
+
+            if (!resultConstruction.isEmpty()) {
+                resultConstruction.append(" + ");
+            }
+
+            if (action.label != null) {
+                resultConstruction.append(action.count).append("w").append(action.sides).append(" (").append(action.label).append(")");
+            } else {
+                resultConstruction.append(action.count).append("w").append(action.sides);
+            }
+        }
+
+        // Modifikator separat behandeln, da er nicht gewürfelt wird
+        if (modifier != 0) {
+            resultInt += modifier; // Addiere den Modifikator zur Gesamtsum
+
+            if (!resultConstruction.isEmpty()) {
+                resultConstruction.append(modifier > 0 ? " + " : " - "); // Füge + oder - hinzu
+            }
+            resultConstruction.append(Math.abs(modifier)); // Zeige den absoluten Wert an
+        }
+
+        return new EarthdawnResult(resultStructur.toString(), resultInt, resultConstruction.toString(), isGlitches());
+    }
+
+    /**
+     * Eine innere Klasse, die das Ergebnis einer Earthdawn-Probe kapselt.
+     * Dies macht die Rückgabe mehrerer Werte einfacher und lesbarer.
+     */
+    public static class EarthdawnResult {
+        private final String  resultStructur;
+        private final String resultInt;
+        private final String resultConstruction;
+        private final boolean glitch;
+
+        public boolean isGlitch() {
+            return glitch;
+        }
+
+        public EarthdawnResult(String  resultStructur, int resultInt, String resultConstruction, boolean glitch) {
+            this.resultStructur = resultStructur;
+            this.resultInt = String.valueOf(resultInt);
+            this.glitch = glitch;
+            this.resultConstruction = resultConstruction;
+        }
+
+        public String getResultStructur() {
+            return resultStructur;
+        }
+
+        public String getResultInt() {
+            return resultInt;
+        }
+
+        public String getDescription() {
+            return "(" +  resultStructur + ")";
+        }
+
+        public String getTitle() {
+            String message =  "%rolls%: %hits%";
+            return message.replace("%rolls%", resultConstruction).replace("%hits%", resultInt);
+        }
+
+    }
+
+
+    /**
+     * Berechnet die benutzten Würfel anhand der Stufe
+     *
+     * @param stufe
+     */
+    private void calcStufe(int stufe) {
+
+        switch (stufe) {
+            case 1:
+                this.setW4(1).setModifier(-2);
+                break;
+            case 2:
+                this.setW4(1).setModifier(-1);
+                break;
+            case 3:
+                this.setW4(1);
+                break;
+            case 4:
+                this.setW6(1);
+                break;
+            case 5:
+                this.setW8(1);
+                break;
+            case 6:
+                this.setW10(1);
+                break;
+            case 7:
+                this.setW12(1);
+                break;
+            case 8:
+                this.setW6(2);
+                break;
+            case 9:
+                this.setW8(1).setW6(1);
+                break;
+            case 10:
+                this.setW8(2);
+                break;
+            case 11:
+                this.setW10(1).setW8(1);
+                break;
+            case 12:
+                this.setW10(2);
+            case 13:
+                this.setW12(1).setW10(1);
+                break;
+            case 14:
+                this.setW12(2);
+                break;
+            case 15:
+                this.setW12(1).setW6(2);
+                break;
+            case 16:
+                this.setW12(1).setW8(1).setW6(1);
+                break;
+            case 17:
+                this.setW12(1).setW8(2);
+                break;
+            case 18:
+                this.setW12(1).setW10(1).setW8(1);
+                break;
+            default:
+                int w20 = 0;
+                w20 = (stufe-8)/11;
+                switch ((stufe-8)%11) {
+                    case 0:
+                        this.setW20(w20).setW6(2);
+                        break;
+                    case 1:
+                        this.setW20(w20).setW8(1).setW6(1);
+                        break;
+                    case 2:
+                        this.setW20(w20).setW8(2);
+                        break;
+                    case 3:
+                        this.setW20(w20).setW10(1).setW8(1);
+                        break;
+                    case 4:
+                        this.setW20(w20).setW10(2);
+                        break;
+                    case 5:
+                        this.setW20(w20).setW12(1).setW10(1);
+                        break;
+                    case 6:
+                        this.setW20(w20).setW12(2);
+                        break;
+                    case 7:
+                        this.setW20(w20).setW12(1).setW6(2);
+                        break;
+                    case 8:
+                        this.setW20(w20).setW12(1).setW8(1).setW6(1);
+                        break;
+                    case 9:
+                        this.setW20(w20).setW12(1).setW8(2);
+                        break;
+                    case 10:
+                        this.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";
+        */
+
+    }
+
+
+    public EarthdawnLogic setW4(int w4) {
+        this.w4 = w4;
+        return this;
+    }
+
+    public EarthdawnLogic setW6(int w6) {
+        this.w6 = w6;
+        return this;
+    }
+
+
+    public EarthdawnLogic setW8(int w8) {
+        this.w8 = w8;
+        return this;
+    }
+
+    public EarthdawnLogic setW10(int w10) {
+        this.w10 = w10;
+        return this;
+    }
+
+    public EarthdawnLogic setW12(int w12) {
+        this.w12 = w12;
+        return this;
+    }
+
+    public EarthdawnLogic setW20(int w20) {
+        this.w20 = w20;
+        return this;
+    }
+
+
+    public EarthdawnLogic setKarma(int karma) {
+        this.karma = karma;
+        return this;
+    }
+
+
+    public EarthdawnLogic setMeisterkarma(int meisterkarma) {
+        this.meisterkarma = meisterkarma;
+        return this;
+    }
+
+    public EarthdawnLogic setWeiheA(int weiheA) {
+        this.weiheA = weiheA;
+        return this;
+    }
+
+
+    public EarthdawnLogic setWeiheJ(int weiheJ) {
+        this.weiheJ = weiheJ;
+        return this;
+    }
+
+
+    public EarthdawnLogic setWeiheV(int weiheV) {
+        this.weiheV = weiheV;
+        return this;
+    }
+
+    public boolean isGlitches() {
+        return glitches;
+    }
+
+    public EarthdawnLogic setGlitches(boolean glitches) {
+        this.glitches = glitches;
+        return this;
+    }
+
+
+    public EarthdawnLogic setModifier(int modifier) {
+        this.modifier = modifier;
+        return this;
+    }
+
+
+
+    private void rollDice(int numberOfDice, int diceart) {
+        int dice;
+        for(int i = 0; i < numberOfDice; i++) {
+            dice = 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;
+        }
+    }
+    static class DiceRollAction {
+        int count;
+        int sides;
+        String label; // Optionaler Beschreibungslabel
+
+        public DiceRollAction(int count, int sides, String label) {
+            this.count = count;
+            this.sides = sides;
+            this.label = label;
+        }
+    }
+
+
+}

src/main/java/de/ocame/wuerfelbot/Earthdawn/dice.java

@@ -0,0 +1,394 @@
+package de.ocame.wuerfelbot.Earthdawn;
+
+import de.ocame.wuerfelbot.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;
+
+public class dice extends ListenerAdapter {
+
+    private final String prefixSr;
+
+    private final language langDe = new language("de");
+    private final language langEn = new language("en");
+
+    private language activLang;
+
+    private final db_connect db;
+
+    private final Map<String, String> channelList = new HashMap<>();
+
+    private final step dieRoll = new step();
+
+
+    public dice() {
+        this.prefixSr = "/ed";
+        //this.prefixIni = "/ini";
+
+        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"));
+        }
+        switch (channelList.get(event.getChannel().getId())) {
+            case "de":
+                activLang = langDe;
+                break;
+            case "en":
+                activLang = langEn;
+                break;
+            default:
+                activLang = langDe;
+
+        }
+        User author = event.getAuthor();
+        author.isBot();
+        if (true) {
+            if (event.getMessage().getContentRaw().startsWith(this.prefixSr))
+                this.roll(event);
+        }
+    }
+
+
+    /**
+     * 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;
+        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 = (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/de/ocame/wuerfelbot/Earthdawn/language.java

@@ -0,0 +1,89 @@
+package de.ocame.wuerfelbot.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/de/ocame/wuerfelbot/Earthdawn/messageInterpreter.java

@@ -0,0 +1,117 @@
+package de.ocame.wuerfelbot.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 final language activLang;
+    private final MessageReceivedEvent event;
+    boolean glitches = true;
+
+    public Integer getDiceart() {
+        return diceart;
+    }
+
+    public Integer getNumberOfDice() {
+        return numberOfDice;
+    }
+
+    public Integer getIntResult() {
+        return intResult;
+    }
+
+
+
+    public boolean isNum() {
+        return typ == 1;
+    }
+
+    public boolean isDice() {
+        return typ == 2;
+    }
+    /**
+     *
+     * @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());
+        }
+        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/de/ocame/wuerfelbot/Earthdawn/step.java

@@ -0,0 +1,292 @@
+package de.ocame.wuerfelbot.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/de/ocame/wuerfelbot/Engel/arcana.java

@@ -0,0 +1,65 @@
+package de.ocame.wuerfelbot.Engel;
+
+public class arcana {
+    private final String name;
+    private final String upsideMeaning;
+    private final String upsideExplain;
+    private final String upsideText;
+    private final String downSideMeaning;
+    private final String downSideExplain;
+    private final String downsideText;
+
+
+
+    private final String upsideNumber;
+    private final 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/de/ocame/wuerfelbot/Engel/arcanaList.java

@@ -0,0 +1,197 @@
+package de.ocame.wuerfelbot.Engel;
+
+import net.dv8tion.jda.api.EmbedBuilder;
+
+import java.util.Random;
+
+public class arcanaList {
+
+    private arcana[] arcanas;
+
+    public boolean isSide() {
+        return side;
+    }
+
+    private boolean side;
+    private int stack;
+    private final 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]) { // 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);
+        side = UpDown % 2 != 0;
+
+        activArcana = j;
+        LoF = j == 15;
+    }
+
+    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/de/ocame/wuerfelbot/Engel/dice.java

@@ -0,0 +1,139 @@
+package de.ocame.wuerfelbot.Engel;
+
+import de.ocame.wuerfelbot.Shadowrun.db_connect;
+import de.ocame.wuerfelbot.Simpleroll.help;
+import de.ocame.wuerfelbot.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;
+
+public class dice extends ListenerAdapter {
+
+    private final String prefixEngel;
+    private final String prefixEngelShort;
+
+    private final language langDe = new language("de");
+    private final language langEn = new language("en");
+
+    private final help helpDe = new help("de");
+    private final help helpEn = new help("En");
+
+    private language activLang;
+    private help activHelp;
+
+    private arcanaList activArcanaList;
+
+    private final db_connect db;
+
+    private final Map<String, String> channelList = new HashMap<>();
+    private final 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"));
+        }
+        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/de/ocame/wuerfelbot/Engel/language.java

@@ -0,0 +1,89 @@
+package de.ocame.wuerfelbot.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/de/ocame/wuerfelbot/Keeproll/dice.java

@@ -0,0 +1,319 @@
+package de.ocame.wuerfelbot.Keeproll;
+
+import de.ocame.wuerfelbot.Shadowrun.db_connect;
+import de.ocame.wuerfelbot.Simpleroll.help;
+import de.ocame.wuerfelbot.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 final String prefixlong;
+    private final String prefixShort;
+    private final String prefixVeryShort;
+
+    private final language langDe = new language("de");
+    private final language langEn = new language("en");
+
+    private final help helpDe = new help("de");
+    private final help helpEn = new help("En");
+
+    private language activLang;
+    private help activHelp;
+
+    private final db_connect db;
+
+    private final 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"));
+        }
+        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.equalsIgnoreCase("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.equalsIgnoreCase("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.equalsIgnoreCase("help") || msgText.equalsIgnoreCase("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/de/ocame/wuerfelbot/Keeproll/result.java

@@ -0,0 +1,105 @@
+package de.ocame.wuerfelbot.Keeproll;
+
+import java.util.Random;
+
+public class result {
+    private StringBuilder text;
+    private int value;
+    private final 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/de/ocame/wuerfelbot/Shadowrun/db_connect.java

@@ -0,0 +1,191 @@
+package de.ocame.wuerfelbot.Shadowrun;
+
+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 de.ocame.wuerfelbot.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();
+    }
+
+    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/de/ocame/wuerfelbot/Shadowrun/dice.java

@@ -0,0 +1,632 @@
+package de.ocame.wuerfelbot.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.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 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 final String prefixSr;
+    private final String prefixIni;
+    private final String prefixZitat;
+    private final String prefixTest;
+    private final String prefixCId;
+
+    private final language langDe = new language("de");
+    private final language langEn = new language("en");
+
+    private final help helpDe = new help("de");
+    private final help helpEn = new help("En");
+
+    private language activLang;
+    private help activHelp;
+
+    private final db_connect db;
+
+
+    private final 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"));
+        }
+        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), 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), 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), 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().equalsIgnoreCase("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().equalsIgnoreCase("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%", 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%", 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().equalsIgnoreCase("de")) {
+                    activLang = langDe;
+                    channelList.put(event.getChannel().getId(), "de");
+                    event.getChannel().sendMessage(getAsMention(event) + activLang.language).queue();
+                    return;
+                }
+                else if(MsgParts[1].trim().equalsIgnoreCase("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(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/de/ocame/wuerfelbot/Shadowrun/help.java

@@ -0,0 +1,28 @@
+package de.ocame.wuerfelbot.Shadowrun;
+
+
+public class help {
+
+    private final StringBuilder hilfstext;
+    private final 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/de/ocame/wuerfelbot/Shadowrun/language.java

@@ -0,0 +1,93 @@
+package de.ocame.wuerfelbot.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/de/ocame/wuerfelbot/Shadowrun/messageInterpreter.java

@@ -0,0 +1,83 @@
+package de.ocame.wuerfelbot.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 final language activLang;
+    private final MessageReceivedEvent event;
+
+
+    public Integer getDiceart() {
+        return diceart;
+    }
+
+    public Integer getNumberOfDice() {
+        return numberOfDice;
+    }
+
+    public Integer getIntResult() {
+        return intResult;
+    }
+
+    public boolean isNum() {
+        return typ == 1;
+    }
+
+    public boolean isDice() {
+        return typ == 2;
+    }
+    /**
+     *
+     * @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());
+        }
+        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/de/ocame/wuerfelbot/Simpleroll/dice.java

@@ -0,0 +1,173 @@
+package de.ocame.wuerfelbot.Simpleroll;
+
+import de.ocame.wuerfelbot.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;
+
+public class dice extends ListenerAdapter {
+
+    private final String prefixR;
+    private final String prefixRoll;
+    private final String prefixHelp;
+
+    private final language langDe = new language("de");
+    private final language langEn = new language("en");
+
+    private final help helpDe = new help("de");
+    private final help helpEn = new help("En");
+
+    private language activLang;
+    private help activHelp;
+
+    private final db_connect db;
+
+    private final 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"));
+        }
+        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().equalsIgnoreCase("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().equalsIgnoreCase("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/de/ocame/wuerfelbot/Simpleroll/diceOld.java

@@ -0,0 +1,238 @@
+package de.ocame.wuerfelbot.Simpleroll;
+
+import de.ocame.wuerfelbot.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 final String prefixR;
+    private final String prefixRoll;
+    private final String prefixHelp;
+
+    private final language langDe = new language("de");
+    private final language langEn = new language("en");
+
+    private final help helpDe = new help("de");
+    private final help helpEn = new help("En");
+
+    private language activLang;
+    private help activHelp;
+
+    private final db_connect db;
+
+    private final 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"));
+        }
+        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().equalsIgnoreCase("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().equalsIgnoreCase("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 de.ocame.wuerfelbot.Shadowrun 5\n\n");
+        result.append("**/ed** für de.ocame.wuerfelbot.Earthdawn 4\n\n");
+        result.append("**/e** bzw **/engel** für die Arcane Version von de.ocame.wuerfelbot.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/de/ocame/wuerfelbot/Simpleroll/help.java

@@ -0,0 +1,28 @@
+package de.ocame.wuerfelbot.Simpleroll;
+
+
+public class help {
+
+    private final StringBuilder hilfstext;
+    private final 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/de/ocame/wuerfelbot/Simpleroll/language.java

@@ -0,0 +1,89 @@
+package de.ocame.wuerfelbot.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/de/ocame/wuerfelbot/Simpleroll/messageInterpreter.java

@@ -0,0 +1,225 @@
+package de.ocame.wuerfelbot.Simpleroll;
+
+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/de/ocame/wuerfelbot/Simpleroll/subpart.java

@@ -0,0 +1,69 @@
+package de.ocame.wuerfelbot.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/de/ocame/wuerfelbot/Socket/shadowrun.java

@@ -0,0 +1,172 @@
+package de.ocame.wuerfelbot.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 final 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("de.ocame.wuerfelbot.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 final Socket socket;
+        private final JDA jda;
+
+        private boolean checkin;
+        private Scanner in;
+        private PrintWriter out;
+
+        private final 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) {
+                        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/de/ocame/wuerfelbot/Vampire/dice.java

@@ -0,0 +1,302 @@
+package de.ocame.wuerfelbot.Vampire;
+
+import de.ocame.wuerfelbot.Shadowrun.db_connect;
+import de.ocame.wuerfelbot.Simpleroll.help;
+import de.ocame.wuerfelbot.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 final String prefixlong;
+    private final String prefixShort;
+    private String prefixVeryShort;
+
+    private final language langDe = new language("de");
+    private final language langEn = new language("en");
+
+    private final help helpDe = new help("de");
+    private final help helpEn = new help("En");
+
+    private language activLang;
+    private help activHelp;
+
+    private final db_connect db;
+
+    private final 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"));
+        }
+        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.equalsIgnoreCase("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.equalsIgnoreCase("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.equalsIgnoreCase("help") || msgText.equalsIgnoreCase("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/de/ocame/wuerfelbot/Vampire/result.java

@@ -0,0 +1,105 @@
+package de.ocame.wuerfelbot.Vampire;
+
+import java.util.Random;
+
+public class result {
+    private StringBuilder text;
+    private int value;
+    private final 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/de/ocame/wuerfelbot/commands/CommandListener.java

@@ -0,0 +1,113 @@
+package de.ocame.wuerfelbot.commands;
+
+import net.dv8tion.jda.api.entities.User;
+import net.dv8tion.jda.api.entities.channel.ChannelType;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import net.dv8tion.jda.api.hooks.ListenerAdapter;
+
+
+public class CommandListener extends ListenerAdapter {
+
+    private final String prefix;
+    private final CommandManager commandManager;
+
+
+    public CommandListener(CommandManager commandManager, String prefix) {
+        this.commandManager = commandManager;
+        this.prefix = prefix;
+    }
+
+
+    public void onMessageReceivedX(MessageReceivedEvent event) {
+        if ((!event.getMessage().getContentRaw().startsWith(this.prefix))
+                || (event.getChannelType() != ChannelType.TEXT && event.getChannelType() != ChannelType.PRIVATE)) {
+            return;
+        }
+
+
+
+        User author = event.getAuthor();
+        author.isBot();
+        /*if (true) {
+            if (event.getMessage().getContentRaw().startsWith(this.prefixSr))
+                this.roll(event);
+        }*/
+    }
+
+
+    /**
+     * Behandelt Slash-Befehle.
+     * Dies ist die empfohlene Methode zur Befehlsverarbeitung in modernen Discord-Bots.
+     */
+    @Override
+    public void onSlashCommandInteraction(SlashCommandInteractionEvent event) {
+        // Ignoriere Bots, damit dein Bot nicht auf Befehle von anderen Bots reagiert
+        if (event.getUser().isBot()) {
+            return;
+        }
+
+        // Delegiere das Event an den CommandManager
+        // Der CommandManager ist dafür zuständig, den passenden ICommand zu finden und auszuführen.
+        commandManager.handleSlashCommand(event);
+    }
+
+    /**
+     * Behandelt traditionelle Text-Befehle.
+     * Dies ist nützlich für ältere Bots oder spezifische Anwendungsfälle.
+     */
+    @Override
+    public void onMessageReceived(MessageReceivedEvent event) {
+        // Ignoriere Bots
+        if (event.getAuthor().isBot()) {
+            //return; // ausgemacht für christian
+        }
+
+        String messageContent = event.getMessage().getContentRaw();
+
+        // Überprüfe, ob die Nachricht mit dem definierten Präfix beginnt
+        if (messageContent.startsWith(prefix)) {
+            // Entferne den Präfix und teile die Nachricht in Befehl und Argumente
+            String[] args = messageContent.substring(prefix.length()).trim().split("\\s+");
+            if (args.length == 0) {
+                return; // Leere Nachricht nach Präfix
+            }
+
+            String commandName = args[0].toLowerCase(); // Der Befehlsname (z.B. "roll", "ed")
+
+            // Erzeuge ein neues Array für die Argumente ohne den Befehlsnamen
+            String[] commandArgs = new String[args.length - 1];
+            System.arraycopy(args, 1, commandArgs, 0, args.length - 1);
+
+            // Delegiere den Text-Befehl an den CommandManager
+            commandManager.handleTextMessage(event, commandName, commandArgs);
+        }
+    }
+
+    /**
+     * Optional: Methode zur Registrierung von Slash-Befehlen beim Start des Bots.
+     * Diese Methode könnte auch in DiscordBot.java oder CommandManager.java liegen.
+     * Hier nur als Beispiel, wie sie im Listener aussehen könnte, wenn er dafür zuständig wäre.
+     */
+    public void registerSlashCommands() {
+        // Erstelle eine Liste von Befehlen, die du registrieren möchtest
+        // Diese Befehle sollten den Definitionen in deinen ICommand-Implementierungen entsprechen
+        // CommandData rollCommand = Commands.slash("roll", "Würfelt eine Zahl")
+        //     .addOption(OptionType.STRING, "notation", "Die Würfelnotation, z.B. 1d6", true);
+        //
+        // CommandData edCommand = Commands.slash("ed", "Führt eine Earthdawn-Operation aus")
+        //     .addOption(OptionType.INTEGER, "zahl", "Eine Zahl für die Earthdawn-Operation", true);
+        //
+        // commandManager.getJda().updateCommands() // Für globale Befehle
+        //    .addCommands(rollCommand, edCommand)
+        //    .queue();
+
+        // Oder für Gilden-spezifische Befehle (schneller zu testen):
+        // Guild guild = commandManager.getJda().getGuildById("DEINE_GILDE_ID");
+        // if (guild != null) {
+        //     guild.updateCommands()
+        //         .addCommands(rollCommand, edCommand)
+        //         .queue();
+        // }
+    }
+}

src/main/java/de/ocame/wuerfelbot/commands/CommandManager.java

@@ -0,0 +1,146 @@
+package de.ocame.wuerfelbot.commands;
+
+
+import de.ocame.wuerfelbot.Earthdawn.EarthdawnCommand;
+import de.ocame.wuerfelbot.core.LoggerUtil;
+import net.dv8tion.jda.api.JDA;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import net.dv8tion.jda.api.interactions.commands.build.CommandData; // Wichtig für die Registrierung
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class CommandManager {
+
+    private final Map<String, ICommand> commands;
+    private final JDA jda; // Referenz zur JDA-Instanz, um Befehle zu registrieren
+
+    public CommandManager(JDA jda) {
+        this.jda = jda;
+        this.commands = new HashMap<>();
+        registerCommands(); // Befehle beim Start registrieren
+    }
+
+    /**
+     * Registriert alle Befehle des Bots.
+     * Hier werden die konkreten Implementierungen der ICommand-Schnittstelle hinzugefügt.
+     */
+    private void registerCommands() {
+        // Füge deine Befehlsimplementierungen hier hinzu
+        //addCommand(new SimpleRollCommand());
+        addCommand(new EarthdawnCommand());
+
+        // Hier können wir auch die Slash-Befehle bei Discord registrieren
+        updateSlashCommands();
+    }
+
+    /**
+     * Fügt einen Befehl zur internen Map hinzu.
+     * @param command Die Instanz des zu registrierenden Befehls.
+     */
+    private void addCommand(ICommand command) {
+        if (commands.containsKey(command.getName())) {
+            LoggerUtil.log("warn", "ComMan", "Befehl '" + command.getName() + "' ist bereits registriert und wird überschrieben.");
+        }
+        commands.put(command.getName().toLowerCase(), command); // Befehlsnamen klein speichern für konsistente Suche
+        LoggerUtil.log("info", "ComMan", "Befehl registriert: " + command.getName());
+    }
+
+    /**
+     * Behandelt einen eingehenden Slash-Befehl.
+     * Sucht den passenden Befehl und führt ihn aus.
+     *
+     * @param event Das SlashCommandInteractionEvent von JDA.
+     */
+    public void handleSlashCommand(SlashCommandInteractionEvent event) {
+        String commandName = event.getName().toLowerCase();
+        ICommand command = commands.get(commandName);
+
+        if (command != null) {
+            try {
+                // Führe den Befehl aus
+                command.executeSlash(event);
+            } catch (Exception e) {
+                LoggerUtil.log("error", "ComMan", "Fehler beim Ausführen von Slash-Befehl '" + commandName + "': " + e.getMessage());
+                event.reply("Hoppla! Beim Ausführen des Befehls ist ein Fehler aufgetreten.").setEphemeral(true).queue();
+            }
+        } else {
+            // Dies sollte bei Slash-Befehlen eigentlich nicht vorkommen,
+            // da Discord nur registrierte Befehle sendet.
+            event.reply("Unbekannter Slash-Befehl: " + commandName).setEphemeral(true).queue();
+            LoggerUtil.log("warn", "ComMan", "Unbekannter Slash-Befehl empfangen: " + commandName);
+        }
+    }
+
+    /**
+     * Behandelt einen eingehenden Text-Befehl.
+     * Sucht den passenden Befehl und führt ihn aus.
+     *
+     * @param event Das MessageReceivedEvent von JDA.
+     * @param commandName Der Name des Befehls (ohne Präfix).
+     * @param args Die Argumente des Befehls.
+     */
+    public void handleTextMessage(MessageReceivedEvent event, String commandName, String[] args) {
+        ICommand command = commands.get(commandName);
+
+        if (command != null) {
+            try {
+                // Führe den Befehl aus
+                command.executeText(event, args);
+            } catch (Exception e) {
+                LoggerUtil.log("error", "ComMan", "Fehler beim Ausführen von Text-Befehl '" + commandName + "': " + e.getMessage());
+                event.getChannel().sendMessage("Hoppla! Beim Ausführen des Befehls ist ein Fehler aufgetreten.").queue();
+            }
+        } else {
+            event.getChannel().sendMessage("Unbekannter Befehl: `" + commandName + "`").queue();
+            LoggerUtil.log("error", "ComMan", "Unbekannter Text-Befehl empfangen: " + commandName);
+        }
+    }
+
+    /**
+     * Registriert oder aktualisiert die Slash-Befehle bei Discord.
+     * Diese Methode sollte beim Start des Bots einmalig aufgerufen werden.
+     */
+    public void updateSlashCommands() {
+        // Sammle alle CommandData-Objekte von den registrierten Befehlen
+        Set<CommandData> slashCommandData = commands.values().stream()
+                .map(ICommand::getSlashCommandData) // Ruft die Methode im ICommand Interface auf
+                .filter(Objects::nonNull) // Nur Befehle, die auch SlashCommandData liefern
+                .collect(Collectors.toSet());
+
+        if (slashCommandData.isEmpty()) {
+            LoggerUtil.log("warn", "ComMan", "Keine Slash-Befehle zum Registrieren gefunden.");
+            return;
+        }
+
+        // Beispiel: Registriere globale Befehle
+        // Für Entwicklung und schnelle Tests empfiehlt es sich, gilden-spezifische Befehle zu nutzen.
+        // jda.updateCommands().addCommands(slashCommandData).queue();
+
+        // Beispiel: Registriere gilden-spezifische Befehle (empfohlen für Entwicklung)
+        // Ersetze "DEINE_GILDE_ID" durch die tatsächliche ID deiner Test-Gilde.
+        String guildId = System.getenv("404979829537243148"); // Aus Umgebungsvariable lesen
+        if (guildId != null && !guildId.isEmpty()) {
+            jda.getGuildById(guildId)
+                    .updateCommands()
+                    .addCommands(slashCommandData)
+                    .queue(
+                            success -> LoggerUtil.log("info", "ComMan", "Slash-Befehle für Gilde " + guildId + " erfolgreich aktualisiert."),
+                            failure -> LoggerUtil.log("error", "ComMan", "Fehler beim Aktualisieren der Slash-Befehle für Gilde " + guildId + ": " + failure.getMessage())
+                    );
+        } else {
+            // Wenn keine Gilden-ID konfiguriert ist, globale Befehle registrieren
+            jda.updateCommands()
+                    .addCommands(slashCommandData)
+                    .queue(
+                            success -> LoggerUtil.log("info", "ComMan", "Globale Slash-Befehle erfolgreich aktualisiert."),
+                            failure -> LoggerUtil.log("error", "ComMan", "Fehler beim Aktualisieren der globalen Slash-Befehle: " + failure.getMessage())
+                    );
+        }
+        LoggerUtil.log("info", "ComMan", "Registrierungsanfrage für " + slashCommandData.size() + " Slash-Befehle gesendet.");
+    }
+}

src/main/java/de/ocame/wuerfelbot/commands/ICommand.java

@@ -0,0 +1,53 @@
+package de.ocame.wuerfelbot.commands;
+
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import net.dv8tion.jda.api.interactions.commands.build.CommandData;
+
+public interface ICommand {
+
+    /**
+     * Gibt den Namen des Befehls zurück.
+     * Dieser Name wird sowohl für Slash-Befehle als auch für Text-Befehle verwendet
+     * und sollte eindeutig sein (z.B. "roll", "ed").
+     *
+     * @return Der Name des Befehls.
+     */
+    String getName();
+
+    /**
+     * Gibt eine kurze Beschreibung des Befehls zurück.
+     * Diese Beschreibung wird in der Discord-UI für Slash-Befehle angezeigt.
+     *
+     * @return Eine kurze Beschreibung des Befehls.
+     */
+    String getDescription();
+
+    /**
+     * Führt die Logik des Befehls aus, wenn er als Slash-Befehl empfangen wird.
+     * Implementierungen sollten hier die spezifische Befehlslogik verarbeiten und auf das Event antworten.
+     *
+     * @param event Das {@link SlashCommandInteractionEvent}, das von JDA ausgelöst wurde.
+     */
+    void executeSlash(SlashCommandInteractionEvent event);
+
+    /**
+     * Führt die Logik des Befehls aus, wenn er als traditioneller Text-Befehl empfangen wird.
+     * Diese Methode ist optional, falls dein Bot nur Slash-Befehle unterstützt.
+     * Implementierungen sollten hier die spezifische Befehlslogik verarbeiten und im Kanal antworten.
+     *
+     * @param event Das {@link MessageReceivedEvent}, das von JDA ausgelöst wurde.
+     * @param args Ein Array von Strings, das die Argumente des Befehls enthält (ohne den Befehlsnamen selbst).
+     */
+    void executeText(MessageReceivedEvent event, String[] args);
+
+    /**
+     * Gibt die {@link CommandData} zurück, die zur Registrierung des Slash-Befehls bei Discord benötigt wird.
+     * Jede Befehlsimplementierung, die ein Slash-Befehl sein soll, muss diese Methode implementieren,
+     * um die Struktur des Befehls (Name, Beschreibung, Optionen) zu definieren.
+     * Wenn ein Befehl kein Slash-Befehl ist, kann diese Methode {@code null} zurückgeben.
+     *
+     * @return Ein {@link CommandData}-Objekt für den Slash-Befehl oder {@code null}, wenn es kein Slash-Befehl ist.
+     */
+    CommandData getSlashCommandData();
+}

src/main/java/de/ocame/wuerfelbot/core/ConfigLoader.java

@@ -0,0 +1,66 @@
+package de.ocame.wuerfelbot.core;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.Properties;
+
+public class ConfigLoader {
+
+    private final Properties properties;
+
+    public ConfigLoader() {
+        properties = new Properties();
+        try (FileInputStream input = new FileInputStream("shadowrun.cfg")) {
+            properties.load(input);
+        } catch (IOException e) {
+            LoggerUtil.log("info", "ConfigLoader", "Konfigurationsdatei konnte nicht geladen werden: " + e.getMessage());
+            e.printStackTrace();
+        }
+        LoggerUtil.log("info", "ConfigLoader", "Konfigurationsdatei wurde geladen");
+    }
+
+    public String getToken() {
+        return properties.getProperty("api.token");
+    }
+
+    public String getUsername() {
+        return properties.getProperty("ff.username");
+    }
+
+    public String getPassword() {
+        return properties.getProperty("ff.password");
+    }
+
+    public String getFfFavList() {
+        return properties.getProperty("ff.favList");
+    }
+
+    public Long getDebugChannel() {
+        return Long.parseLong(properties.getProperty("debug.Channel"));
+    }
+
+    public boolean getFFActive() {
+        return Boolean.parseBoolean(properties.getProperty("ff.active", "true"));
+    }
+
+    public String getMySQLHost() {
+        return properties.getProperty("mysql.host", "localhost");
+    }
+
+    public String getMySQLPort() {
+        return properties.getProperty("mysql.port", "3306");
+    }
+
+    public String getMySQLUsername() {
+        return properties.getProperty("mysql.username", "");
+    }
+
+    public String getMySQLPassword() {
+        return properties.getProperty("mysql.password", "");
+    }
+
+    public String getMySQLDatabase() {
+        return properties.getProperty("mysql.database", "fuchsbot");
+    }
+
+}

src/main/java/de/ocame/wuerfelbot/core/DiscordBot.java

@@ -0,0 +1,99 @@
+package de.ocame.wuerfelbot.core;
+
+
+import de.ocame.wuerfelbot.commands.CommandListener;
+import de.ocame.wuerfelbot.commands.CommandManager;
+import net.dv8tion.jda.api.JDA;
+import net.dv8tion.jda.api.JDABuilder;
+import net.dv8tion.jda.api.OnlineStatus;
+import net.dv8tion.jda.api.entities.Activity;
+import net.dv8tion.jda.api.requests.GatewayIntent;
+import net.dv8tion.jda.api.utils.ChunkingFilter;
+import net.dv8tion.jda.api.utils.MemberCachePolicy;
+import net.dv8tion.jda.api.hooks.ListenerAdapter; // JDA ListenerAdapter
+import net.dv8tion.jda.api.exceptions.InvalidTokenException; // Für Token-Fehler
+
+import javax.security.auth.login.LoginException; // Für Login-Fehler
+
+public class DiscordBot {
+
+    private JDA jda;
+    private final String botToken;
+    private final String testGuildId; // Für gilden-spezifische Slash-Befehle
+    private CommandManager commandManager;
+
+    public DiscordBot(String botToken, String testGuildId) {
+        this.botToken = botToken;
+        this.testGuildId = testGuildId; // Kann null sein, wenn nicht verwendet
+    }
+
+    /**
+     * Startet den Discord Bot.
+     * Initialisiert JDA, registriert Listener und Befehle.
+     * @throws LoginException Wenn der Bot-Token ungültig ist oder ein Anmeldefehler auftritt.
+     * @throws InterruptedException Wenn der Thread beim Warten auf den Bot unterbrochen wird.
+     */
+    public void start() throws LoginException, InterruptedException, InvalidTokenException {
+        // Konfiguriere JDABuilder mit notwendigen Intents
+        // Intents sind Berechtigungen, die dein Bot für bestimmte Events benötigt.
+        JDABuilder builder = JDABuilder.createDefault(botToken)
+                .enableIntents(
+                        GatewayIntent.MESSAGE_CONTENT, // Für Text-Befehle (Nachrichteninhalt lesen)
+                        GatewayIntent.GUILD_MESSAGES,    // Für Nachrichten in Gilden
+                        GatewayIntent.GUILD_MEMBERS,     // Für Zugriff auf Mitgliederinformationen (falls benötigt)
+                        GatewayIntent.GUILD_PRESENCES    // Für Präsenzinformationen (falls benötigt)
+                )
+                // Empfohlen für größere Bots, um Caching zu optimieren
+                .setMemberCachePolicy(MemberCachePolicy.ALL)
+                .setChunkingFilter(ChunkingFilter.ALL)
+                .setStatus(OnlineStatus.ONLINE) // Setze den Online-Status
+                .setActivity(Activity.playing("mit den Würfeln")); // Setze eine Aktivität
+
+        // Baue die JDA-Instanz. Dies blockiert, bis der Bot bereit ist.
+        this.jda = builder.build();
+
+        // Warte, bis JDA vollständig geladen und verbunden ist
+        jda.awaitReady();
+
+        // Initialisiere den CommandManager mit der JDA-Instanz
+        this.commandManager = new CommandManager(jda);
+
+        // Erstelle und registriere den CommandListener
+        // Der Präfix für Text-Befehle ist hier auf "!" gesetzt.
+        CommandListener commandListener = new CommandListener(commandManager, "/");
+        jda.addEventListener(commandListener);
+
+        LoggerUtil.log("info", "DiscordBot", "JDA ist bereit. Bot ist online!");
+
+        // Registriere Slash-Befehle beim Start.
+        // Dies wird nun vom CommandManager übernommen, der eine Referenz auf JDA hat.
+        // Der CommandManager wird seine eigene updateSlashCommands() Methode aufrufen.
+        // commandManager.updateSlashCommands(); // Wird bereits im CommandManager-Konstruktor aufgerufen
+    }
+
+    /**
+     * Fährt den Discord Bot sauber herunter.
+     */
+    public void shutdown() {
+        if (jda != null) {
+            jda.shutdownNow(); // Beendet JDA sofort
+            LoggerUtil.log("info", "DiscordBot", "JDA Instanz wurde heruntergefahren.");
+        }
+    }
+
+    /**
+     * Gibt die JDA-Instanz zurück.
+     * @return Die {@link JDA}-Instanz.
+     */
+    public JDA getJda() {
+        return jda;
+    }
+
+    /**
+     * Gibt den CommandManager zurück.
+     * @return Den {@link CommandManager}.
+     */
+    public CommandManager getCommandManager() {
+        return commandManager;
+    }
+}

src/main/java/de/ocame/wuerfelbot/core/LoggerUtil.java

@@ -0,0 +1,39 @@
+package de.ocame.wuerfelbot.core;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class LoggerUtil {
+    //private static final Logger logger = LoggerFactory.getLogger(LoggerUtil.class);
+
+    /**
+     * Erstellt einen Logeintrag basierend auf Typ, Modul und Nachricht.
+     *
+     * @param logType   Der Typ des Logs: "trace", "debug", "info", "warn", "error".
+     * @param module    Der Name des Moduls oder Kontextes.
+     * @param message   Die Nachricht, die geloggt werden soll.
+     */
+    public static void log(String logType, String module, String message) {
+        Logger logger = LoggerFactory.getLogger(module);
+        switch (logType.toLowerCase()) {
+            case "trace":
+                logger.trace(message);
+                break;
+            case "debug":
+                logger.debug(message);
+                break;
+            case "info":
+                logger.info(message);
+                break;
+            case "warn":
+                logger.warn(message);
+                break;
+            case "error":
+                logger.error(message);
+                break;
+            default:
+                logger.warn("Unbekannter Log-Typ: {}. Nachricht: {}", logType, message);
+
+        }
+    }
+}

src/main/java/de/ocame/wuerfelbot/core/Main.java

@@ -0,0 +1,66 @@
+package de.ocame.wuerfelbot.core;
+
+
+//import Serenity.balance;
+import de.ocame.wuerfelbot.core.ConfigLoader;
+import net.dv8tion.jda.api.JDA;
+import net.dv8tion.jda.api.JDABuilder;
+import net.dv8tion.jda.api.OnlineStatus;
+import net.dv8tion.jda.api.entities.*;
+import net.dv8tion.jda.api.requests.GatewayIntent;
+
+public class Main {
+
+    public static void main(String[] args) {
+
+
+        ConfigLoader configLoader = new ConfigLoader();
+
+        String token = configLoader.getToken();
+
+        try {
+            // Erstelle eine neue Instanz deines DiscordBots
+            LoggerUtil.log("info", "Main", "Discord Bot wird gestartet...");
+
+            DiscordBot bot = new DiscordBot(token, null);
+            bot.start(); // Starte den Bot
+
+            LoggerUtil.log("info", "Main", "Bot ist online und bereit!" );
+
+
+            // Du könntest hier einen Hook hinzufügen, um den Bot sauber herunterzufahren,
+            // wenn das Programm beendet wird.
+            Runtime.getRuntime().addShutdownHook(new Thread(() -> {
+                LoggerUtil.log("info", "Main", "Bot wird heruntergefahren...");
+                bot.shutdown();
+                LoggerUtil.log("info", "Main", "Bot wurde heruntergefahren.");
+            }));
+
+        } catch (Exception e) {
+            LoggerUtil.log("error", "Main", "Ein schwerwiegender Fehler ist beim Starten des Bots aufgetreten: " + e.getMessage());
+            e.printStackTrace();
+        }
+
+/*
+        JDA jda = JDABuilder.createDefault(token)
+                .enableIntents(GatewayIntent.MESSAGE_CONTENT)
+                .setActivity(Activity.playing("mit den Würfeln"))
+                .setStatus(OnlineStatus.ONLINE)
+                //.addEventListeners(new dice())
+                .addEventListeners(new de.ocame.wuerfelbot.Earthdawn.dice())
+                .addEventListeners(new de.ocame.wuerfelbot.Simpleroll.dice())
+                .addEventListeners(new de.ocame.wuerfelbot.Shadowrun.dice())
+                .addEventListeners(new de.ocame.wuerfelbot.Engel.dice())
+                .addEventListeners(new de.ocame.wuerfelbot.Keeproll.dice())
+                .setAutoReconnect(true)
+                .build();
+*/
+
+           // Thread thread = new Thread(new shadowrun(jda));
+            //thread.start();
+
+
+
+    }
+
+}

src/main/java/de/ocame/wuerfelbot/dicebase/DiceResult.java

@@ -0,0 +1,41 @@
+package de.ocame.wuerfelbot.dicebase;
+
+import java.util.List;
+
+public class DiceResult {
+    private final List<Integer> rolls;
+    private final int total;
+    private final String breakdown;
+    private final boolean glitch;
+
+    public DiceResult(List<Integer> rolls, int total, String breakdown, boolean glitch) {
+        this.rolls = rolls;
+        this.total = total;
+        this.breakdown = breakdown;
+        this.glitch = glitch;
+    }
+
+    public List<Integer> getRolls() {
+        return rolls;
+    }
+
+    public int getTotal() {
+        return total;
+    }
+
+    public String getBreakdown() {
+        return breakdown;
+    }
+
+    public boolean isGlitch() {
+        return glitch;
+    }
+
+    @Override
+    public String toString() {
+        return "Ergebnis: " + total + "\n" +
+                "Würfe: " + rolls + "\n" +
+                "Details: " + breakdown +
+                (glitch ? "\n Patzer erkannt!" : "");
+    }
+}

src/main/java/de/ocame/wuerfelbot/dicebase/DiceSystem.java

@@ -0,0 +1,24 @@
+package de.ocame.wuerfelbot.dicebase;
+
+import de.ocame.wuerfelbot.dicebase.DiceResult;
+
+public interface DiceSystem {
+    /**
+     * Gibt den internen Namen des Systems zurück, z.B. "earthdawn" oder "shadowrun".
+     */
+    String getName();
+
+    /**
+     * Führt einen Wurf mit dem angegebenen Nutzereingabe-String aus.
+     * @param input Der Eingabestring, z.B. "5" für Earthdawn-Stufe 5 oder "4w6+1" für klassische Systeme.
+     * @return Ein DiceResult-Objekt mit allen relevanten Würfelinformationen.
+     */
+    DiceResult roll(String input);
+
+    /**
+     * Gibt eine kurze Beschreibung oder Hilfe zu diesem Würfelsystem zurück.
+     */
+    default String getDescription() {
+        return "Kein Beschreibungstext verfügbar.";
+    }
+}

src/main/java/de/ocame/wuerfelbot/dicebase/dice.java

@@ -0,0 +1,96 @@
+package de.ocame.wuerfelbot.dicebase;
+
+import de.ocame.wuerfelbot.Earthdawn.language;
+import de.ocame.wuerfelbot.Earthdawn.messageInterpreter;
+import de.ocame.wuerfelbot.Earthdawn.step;
+import de.ocame.wuerfelbot.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;
+
+public class dice extends ListenerAdapter {
+
+    private final String prefixSr;
+
+    private final language langDe = new language("de");
+    private final language langEn = new language("en");
+
+    private language activLang;
+
+    private final db_connect db;
+
+    private final Map<String, String> channelList = new HashMap<>();
+
+    private final step dieRoll = new step();
+
+
+    public dice() {
+        this.prefixSr = "/ed";
+        //this.prefixIni = "/ini";
+
+        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"));
+        }
+        switch (channelList.get(event.getChannel().getId())) {
+            case "de":
+                activLang = langDe;
+                break;
+            case "en":
+                activLang = langEn;
+                break;
+            default:
+                activLang = langDe;
+
+        }
+        User author = event.getAuthor();
+        author.isBot();
+        if (true) {
+            if (event.getMessage().getContentRaw().startsWith(this.prefixSr))
+                this.roll(event);
+        }
+    }
+
+
+    /**
+     *
+     *
+     * @param event JDA Event
+     */
+    private void roll(MessageReceivedEvent 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() + " ";
+    }
+
+}

src/main/java/de/ocame/wuerfelbot/dicebase/output/OutputContentElement.java

@@ -0,0 +1,39 @@
+package de.ocame.wuerfelbot.dicebase.output;
+
+import java.awt.*;
+
+public class OutputContentElement {
+
+    private final String message;
+    private final String image;
+    private final Color color;
+
+    public OutputContentElement(String message) {
+        this.message = message;
+        this.image = null;
+        this.color = new Color(36, 153, 245);
+    }
+    public OutputContentElement(String message, String image) {
+        this.message = message;
+        this.image = image;
+        this.color = new Color(36, 153, 245);
+    }
+    public OutputContentElement(String message, String image, Color color) {
+        this.message = message;
+        this.image = image;
+        this.color = color;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public String getImage() {
+        return image;
+    }
+
+    public Color getColor() {
+        return color;
+    }
+
+}

src/main/java/de/ocame/wuerfelbot/output/DiceOutputFormatter.java

@@ -0,0 +1,53 @@
+package de.ocame.wuerfelbot.output;
+
+import net.dv8tion.jda.api.EmbedBuilder;
+
+import java.awt.*;
+
+
+public class DiceOutputFormatter {
+
+    /**
+     * Formatiert das Ergebnis in einer Standart Discord-Ausgabe.
+     *
+     * @param glitch True = rote Balken sonst Grüner.
+     * @param title  Überschrift der Box.
+     * @param description   Inhalt der Box z.b. Würfelergebnise.
+     * @return Eine formatierte String-Nachricht für Discord.
+     */
+
+    public EmbedBuilder DCDefaultOutput(String title, String description, boolean glitch) {
+        EmbedBuilder outputBox = new EmbedBuilder();
+
+        if(glitch) { // Patzer
+            outputBox.setColor(Color.red);
+        }
+        else { // Erfolg
+            outputBox.setColor(Color.green);
+        }
+
+        outputBox.setTitle(title);
+        outputBox.setDescription(description);
+
+        return outputBox;
+    }
+
+    /**
+     * Formatiert ein allgemeines Würfelergebnis.
+     * @param result Das Ergebnis des Würfels.
+     * @param notation Die Würfelnotation (z.B. "1d6").
+     * @return Der formatierte String.
+     */
+    public String formatRollResult(int result, String notation) {
+        return String.format("Du hast mit %s eine **%d** gewürfelt.", notation, result);
+    }
+
+    /**
+     * Formatiert eine Fehlermeldung.
+     * @param message Die Fehlermeldung.
+     * @return Der formatierte String.
+     */
+    public String formatError(String message) {
+        return String.format("❌ Fehler: %s", message);
+    }
+}