From 67dffe9c1303f1ad23b4669a7581b42767e7655a Mon Sep 17 00:00:00 2001 From: Ocame Date: Fri, 5 Mar 2021 16:30:22 +0100 Subject: [PATCH] Engel Modul --- src/main/java/Engel/arcana.java | 65 +++++++++ src/main/java/Engel/arcanaList.java | 206 ++++++++++++++++++++++++++++ src/main/java/Engel/dice.java | 140 +++++++++++++++++++ src/main/java/Engel/language.java | 89 ++++++++++++ 4 files changed, 500 insertions(+) create mode 100644 src/main/java/Engel/arcana.java create mode 100644 src/main/java/Engel/arcanaList.java create mode 100644 src/main/java/Engel/dice.java create mode 100644 src/main/java/Engel/language.java diff --git a/src/main/java/Engel/arcana.java b/src/main/java/Engel/arcana.java new file mode 100644 index 0000000..8ebce27 --- /dev/null +++ b/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; + } +} diff --git a/src/main/java/Engel/arcanaList.java b/src/main/java/Engel/arcanaList.java new file mode 100644 index 0000000..cdb05e9 --- /dev/null +++ b/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"); + } +} diff --git a/src/main/java/Engel/dice.java b/src/main/java/Engel/dice.java new file mode 100644 index 0000000..3812fac --- /dev/null +++ b/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 channelList = new HashMap<>(); + private Map 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 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()); + } + + } +} diff --git a/src/main/java/Engel/language.java b/src/main/java/Engel/language.java new file mode 100644 index 0000000..cef2b76 --- /dev/null +++ b/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(); + } + } + } + } +} +