diff --git a/src/main/java/Keeproll/dice.java b/src/main/java/Keeproll/dice.java
new file mode 100644
index 0000000..5f66af8
--- /dev/null
+++ b/src/main/java/Keeproll/dice.java
@@ -0,0 +1,308 @@
+package Keeproll;
+
+import Shadowrun.db_connect;
+import Simpleroll.help;
+import Simpleroll.language;
+import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.entities.ChannelType;
+import net.dv8tion.jda.api.entities.User;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import net.dv8tion.jda.api.hooks.ListenerAdapter;
+
+import java.awt.*;
+import java.util.*;
+import java.util.regex.MatchResult;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class dice extends ListenerAdapter {
+
+    private String prefixlong;
+    private String prefixShort;
+    private String prefixVeryShort;
+
+    private language langDe = new language("de");
+    private language langEn = new language("en");
+
+    private help helpDe = new help("de");
+    private help helpEn = new help("En");
+
+    private language activLang;
+    private help activHelp;
+
+    private db_connect db;
+
+    private Map<String, String> channelList = new HashMap<>();
+
+
+    public dice() {
+        this.prefixlong = "/keeproll";
+        this.prefixShort = "/keep";
+        this.prefixVeryShort = "/k ";
+
+        this.db = new db_connect();
+    }
+
+    @Override
+    public void onMessageReceived(MessageReceivedEvent event) {
+        if ((!event.getMessage().getContentRaw().toLowerCase().startsWith(this.prefixlong)
+                && !event.getMessage().getContentRaw().toLowerCase().startsWith(this.prefixShort)
+                && !event.getMessage().getContentRaw().toLowerCase().startsWith(this.prefixVeryShort))
+                || (event.getChannelType() != ChannelType.TEXT && event.getChannelType() != ChannelType.PRIVATE)) {
+            return;
+        }
+
+        if(!channelList.containsKey(event.getChannel().getId())) {
+            Map<String, String> Einstellungen = db.getChannelSettings(event.getChannel().getId());
+            channelList.put(event.getChannel().getId(), Einstellungen.get("lang").toString());
+        }
+        switch (channelList.get(event.getChannel().getId())) {
+            case "de":
+                activLang = langDe;
+                break;
+            case "en":
+                activLang = langEn;
+                break;
+            default:
+                activLang = langDe;
+
+        }
+        User author = event.getAuthor();
+        if (event.getMessage().getContentRaw().toLowerCase().startsWith(this.prefixlong) || event.getMessage().getContentRaw().toLowerCase().startsWith(this.prefixShort) || event.getMessage().getContentRaw().toLowerCase().startsWith(this.prefixVeryShort))
+            this.roll(event);
+    }
+
+
+    private String getEffectiveName(MessageReceivedEvent event) {
+        if(event.getMember() == null) {
+            return "";
+        }
+        return event.getMember().getEffectiveName() + " ";
+    }
+
+    private String getAsMention(MessageReceivedEvent event) {
+        if(event.getMember() == null) {
+            return "";
+        }
+        return event.getMember().getAsMention() + " ";
+    }
+
+    /**
+     *
+     *
+     * @param event JDA Event
+     */
+    private void roll(MessageReceivedEvent event) {
+
+        EmbedBuilder outputBox = new EmbedBuilder();
+        StringBuilder result = new StringBuilder("");
+        String msgText = "";
+
+        int numberOfDice, diceCount, resultValue, difficult, bonus;
+        numberOfDice = diceCount =  resultValue = difficult = bonus = 0;
+
+        boolean reroll9, reroll1, maxreroll, noreroll;
+        reroll9 = reroll1 = maxreroll = noreroll = false;
+
+        try {
+
+            String ContentRaw = event.getMessage().getContentRaw();
+
+            // Prüfen ob Leerer Command gesendet wird
+            String[] MsgParts = ContentRaw.replace("  ", " ").split(" ", 2);
+
+            if(MsgParts.length < 2) {
+                String message = activLang.emptyCommand;
+                message = message.replace("%command%", this.prefixShort);
+                event.getChannel().sendMessage(getAsMention(event) + message).queue();
+                return;
+            }
+
+            msgText = MsgParts[1].trim();
+            if(msgText.matches(".*[^0-9].*")) { // es wurden andere zeichen als Zahlen gefunden
+                if(msgText.toLowerCase().equals("de")) {
+                    activLang = langDe;
+                    channelList.put(event.getChannel().getId(), "de");
+                    event.getChannel().sendMessage(getAsMention(event) + activLang.language).queue();
+                    db.setChannelSettings(event.getChannel().getId(), "de", event.getGuild().getId(), event.getChannel().getName());
+                    return;
+                }
+                else if(msgText.toLowerCase().equals("en")) {
+                    activLang = langEn;
+                    channelList.put(event.getChannel().getId(), "en");
+                    event.getChannel().sendMessage(getAsMention(event) + activLang.language).queue();
+                    db.setChannelSettings(event.getChannel().getId(), "en", event.getGuild().getId(), event.getChannel().getName());
+                    return;
+                }
+                else if(msgText.toLowerCase().equals("help") || msgText.toLowerCase().equals("hilfe")) {
+                    event.getChannel().sendMessage(getAsMention(event)
+                    + " Die Syntax lautet XkY z.b. 5k4\nEs werden X mal W10 gewürfelt und davon die höhsten Anzahl Y behalten und addiert. Wird eine 10 gewürfelt, wird der Wurf weiter gewürfelt und addiert aber nur als ein Wurf gezählt.\nWird nach dem XkY eine weiter Zahl angeben so ist dies die Schwierigkeit\n"
+                        + "Wird nach dem XkY eine Zahl mit + oder - Angegeben, zählt dies als ein Modifikator für das ergebnis.\n\n"
+                        + "Zudem gibt es folgente sonderzeichen, die an belibiger stelle gesetz werden können:\n"
+                        + "! - auch gewüfelte 9 explodieren\n"
+                        + "e - gewürfelte 1 werden neu gewürfelt\n"
+                        + "# - Würfel explodierente nur einmal\n"
+                        + "n - Würfel explodierente nicht\n"
+                     ).queue();
+
+                    return;
+                }
+                if(msgText.contains("!")) {
+                    reroll9 = true;
+                    msgText = msgText.replace("!", "");
+                }
+                if(msgText.contains("e")) {
+                    reroll1 = true;
+                    msgText = msgText.replace("e", "");
+                }
+                if(msgText.contains("#")) {
+                    maxreroll = true;
+                    msgText = msgText.replace("#", "");
+                }
+                if(msgText.contains("n")) {
+                    noreroll = true;
+                    msgText = msgText.replace("n", "");
+                }
+
+                if(msgText.matches(".*[+-] *[0-9]+.*")) { // Modifikator gefunden
+                    Pattern pattern = Pattern.compile("([+-]) *([0-9]+)");
+                    Matcher matcher = pattern.matcher(msgText.toLowerCase());
+                    matcher.find();
+                    MatchResult elements = matcher.toMatchResult();
+                    bonus = Integer.parseInt(elements.group(2));
+                    if(elements.group(1).equals("-")) {
+                        bonus *= -1;
+                    }
+                    msgText = msgText.replaceFirst("[+-] *[0-9]+", "");
+                }
+
+                if(msgText.toLowerCase().matches(".*([0-9]+)k([0-9]+) +([0-9]+).*")) { // XkY Z Aufbau in der Anfrage
+                    Pattern pattern = Pattern.compile("([0-9]+)k([0-9]+) +([0-9]+)");
+                    Matcher matcher = pattern.matcher(msgText.toLowerCase());
+                    matcher.find();
+                    MatchResult elements = matcher.toMatchResult();
+                    numberOfDice = Integer.parseInt(elements.group(1));
+                    diceCount = Integer.parseInt(elements.group(2));
+                    difficult = Integer.parseInt(elements.group(3));
+                }
+                else if(msgText.toLowerCase().matches(".*([0-9]+)k([0-9]+).*")) { // XkY Aufbau in der Anfrage
+                    Pattern pattern = Pattern.compile("([0-9]+)k([0-9]+)");
+                    Matcher matcher = pattern.matcher(msgText.toLowerCase());
+                    matcher.find();
+                    MatchResult elements = matcher.toMatchResult();
+                    numberOfDice = Integer.parseInt(elements.group(1));
+                    diceCount = Integer.parseInt(elements.group(2));
+                }
+                else {
+                    String message = activLang.error;
+                    message = message.replace("%command%", msgText);
+                    event.getChannel().sendMessage(getAsMention(event) + message).queue();
+                    return;
+                }
+            }
+            else {
+                    String message = activLang.error;
+                    message = message.replace("%command%", msgText);
+                    event.getChannel().sendMessage(getAsMention(event) + message).queue();
+                    return;
+            }
+
+            if(numberOfDice < diceCount && numberOfDice < 10) {
+                numberOfDice = diceCount;
+            }
+
+            if(numberOfDice > 10) {
+                int diceovflow = numberOfDice-10;
+                numberOfDice = 10;
+                if(diceCount >= 10) {
+                    bonus += diceovflow*2;
+                }
+                else {
+                    if(diceCount + Math.floorDiv(diceovflow, 2) <= 10) {
+                        diceCount += Math.floorDiv(diceovflow, 2);
+                    }
+                    else {
+                        diceCount = 10;
+                        bonus += (diceCount + Math.floorDiv(diceovflow, 2) - 10)*2;
+                    }
+                }
+
+            }
+
+            if(diceCount > 10) {
+                bonus += (diceCount-10)*2;
+                diceCount = 10;
+            }
+
+            if(numberOfDice <= 0) {
+                String message = activLang.noNegativ;
+                event.getChannel().sendMessage(getAsMention(event) + message).queue();
+                return;
+            }
+
+
+            result[] rolls = new result[numberOfDice];
+
+            int [][] sortRolls = new int[numberOfDice][2];
+
+            for(int i = 0; i < numberOfDice; i++) {
+                rolls[i] = new result();
+                rolls[i].setMaxReroll(maxreroll).setReroll1(reroll1).setReroll9(reroll9).setNoreroll(noreroll);
+                rolls[i].roll();
+                sortRolls[i][0] = i;
+                sortRolls[i][1] = rolls[i].getValue();
+            }
+
+
+            // sortierung
+            Arrays.sort(sortRolls, Comparator.comparingInt(o -> o[1]));
+            for(int i = numberOfDice; i > numberOfDice-diceCount; i--) {
+                resultValue += sortRolls[i-1][1];
+                rolls[sortRolls[i-1][0]].setMarket();
+            }
+            resultValue += bonus;
+
+            // Border Farbe
+            if(resultValue >= difficult) {
+                outputBox.setColor(Color.green);
+            }
+            else {
+                outputBox.setColor(Color.red);
+            }
+
+            // Ausgabe beginn
+            String addition = "";
+            if(bonus != 0) {
+                if(bonus < 0) {
+                    addition += " - " + (bonus*-1) + " ";;
+                }
+                else {
+                    addition += " + " + bonus + " ";;
+                }
+            }
+            if(difficult > 0) {
+                addition += " Schwierigkeit " + difficult;
+            }
+
+            outputBox.setTitle(getEffectiveName(event) + numberOfDice + "k" + diceCount + addition + ": " + resultValue);
+
+            StringBuilder description = new StringBuilder();
+            for(int i = 0; i < numberOfDice; i++) {
+                if(description.length() > 0) {
+                    description.append(", ");
+                }
+                description.append(rolls[i].getText());
+            }
+            outputBox.setDescription("(" +  description + ")");
+            event.getChannel().sendMessage(outputBox.build()).queue();
+        }
+        catch (NumberFormatException e) {
+            event.getChannel().sendMessage("Nope").queue();
+        }
+        catch (Exception e) {
+            System.out.println("problem: " + e.getMessage());
+        }
+
+    }
+
+}
diff --git a/src/main/java/Keeproll/result.java b/src/main/java/Keeproll/result.java
new file mode 100644
index 0000000..087dda0
--- /dev/null
+++ b/src/main/java/Keeproll/result.java
@@ -0,0 +1,105 @@
+package Keeproll;
+
+import java.util.Random;
+
+public class result {
+    private StringBuilder text;
+    private int value;
+    private int diceart;
+    private Boolean reroll9;
+    private Boolean reroll1;
+    private Boolean maxReroll;
+    private Boolean noreroll;
+
+    public result() {
+        diceart = 10;
+        text = new StringBuilder();
+        value = 0;
+        reroll9 = false;
+        reroll1 = false;
+        maxReroll = false;
+        noreroll = false;
+    }
+
+    public String getText() {
+        return text.toString();
+    }
+
+    public void setText(String text) {
+        this.text = new StringBuilder();
+        this.text.append(text);
+    }
+
+    public void setMarket() {
+        String tmp = this.text.toString();
+        this.text = new StringBuilder();
+        this.text.append("**").append(tmp).append("**");
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    public void setValue(Integer value) {
+        this.value = value;
+    }
+
+    public result setReroll9(Boolean reroll9) {
+        this.reroll9 = reroll9;
+        return this;
+    }
+
+    public result setReroll1(Boolean reroll1) {
+        this.reroll1 = reroll1;
+        return this;
+    }
+
+    public result setMaxReroll(Boolean maxReroll) {
+        this.maxReroll = maxReroll;
+        return this;
+    }
+
+    public result setNoreroll(Boolean noreroll) {
+        this.noreroll = noreroll;
+        return this;
+    }
+
+    public result roll() {
+        int dice;
+        int rolls = 0;
+        Boolean reroll = false;
+
+        do{
+            reroll = false;
+            dice = new Random().nextInt(diceart);
+            dice++;
+
+            if(text.length() > 0) {
+                text.append("+");
+            }
+            if(reroll1 && dice == 1 && rolls <= 0) {
+                text.append("~~ ").append(dice).append(" ~~ ");
+            }
+            else {
+                text.append(dice);
+            }
+
+            value += dice;
+
+            if(!noreroll) {
+                if (dice == 10) {
+                    reroll = rolls <= 0 || !maxReroll; // wenn maxRolls an und schon einmal gerollt wurde kein reroll
+                    ++rolls;
+                } else if (reroll9 && dice == 9) {
+                    reroll = rolls <= 0 || !maxReroll;
+                } else if (reroll1 && dice == 1 && rolls <= 0) {
+                    reroll = true;
+                    value--;
+                }
+            }
+
+        } while(reroll);
+
+        return this;
+    }
+}