Engel Modul

src/main/java/Engel/arcana.java

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

src/main/java/Engel/arcanaList.java

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

src/main/java/Engel/dice.java

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

src/main/java/Engel/language.java

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