diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..98003fe --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +.idea +LyokoDB.db \ No newline at end of file diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..dd5db01 --- /dev/null +++ b/pom.xml @@ -0,0 +1,58 @@ + + + 4.0.0 + mulley.sky + lyokobot + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 1.8 + 1.8 + + + + + maven-assembly-plugin + 3.1.0 + + + jar-with-dependencies + + + + + mulley.sky.lyokobot.Main + + + + + + make-assembly + package + + single + + + + + + + + + com.discord4j + Discord4J + 2.10.1 + + + org.xerial + sqlite-jdbc + LATEST + + + \ No newline at end of file diff --git a/src/main/java/mulley/sky/lyokobot/Commands/CommandCore.java b/src/main/java/mulley/sky/lyokobot/Commands/CommandCore.java new file mode 100644 index 0000000..f41a244 --- /dev/null +++ b/src/main/java/mulley/sky/lyokobot/Commands/CommandCore.java @@ -0,0 +1,44 @@ +package mulley.sky.lyokobot.Commands; + +import sx.blah.discord.handle.impl.events.guild.channel.message.MessageReceivedEvent; +import sx.blah.discord.util.EmbedBuilder; +import sx.blah.discord.util.RequestBuffer; + +import java.util.ArrayList; +import java.util.List; + +public abstract class CommandCore { + protected String commandName; + protected String helpMessage; + protected String Usage; + protected boolean helpViewable = true; + protected boolean adminOnly = false; + protected boolean serverOwner = false; + protected List commandAliases = new ArrayList<>(); + + public String getCommandName() {return commandName;} + public String getHelpMessage() {return helpMessage;} + public String getUsage() {return Usage;} + public boolean isHelpViewable() {return helpViewable;} + public boolean isAdminOnly() {return adminOnly;} + public boolean isServerOwner() {return serverOwner;} + public List getAliases() {return commandAliases;} + + public void addAlias(String command) {commandAliases.add(command);} + + public boolean isAlias(String command) { + if(commandAliases.contains(command)) { + return true; + } + return false; + } + + public boolean executeCommand(MessageReceivedEvent event, String[] argArray) {return true;} + + public void argsNotFound(MessageReceivedEvent event) { + EmbedBuilder builder = new EmbedBuilder(); + builder.withDescription("You haven't supplied the right args in your request. Check with the help command if you are unsure of the usage of this command."); + builder.withFooterText("Not enough args"); + RequestBuffer.request(() -> event.getMessage().getChannel().sendMessage(builder.build())); + } +} diff --git a/src/main/java/mulley/sky/lyokobot/Commands/Commands/Administration/Admin.java b/src/main/java/mulley/sky/lyokobot/Commands/Commands/Administration/Admin.java new file mode 100644 index 0000000..daf5890 --- /dev/null +++ b/src/main/java/mulley/sky/lyokobot/Commands/Commands/Administration/Admin.java @@ -0,0 +1,60 @@ +package mulley.sky.lyokobot.Commands.Commands.Administration; + +import mulley.sky.lyokobot.Commands.CommandCore; +import mulley.sky.lyokobot.Logic.Objects.Guild; +import mulley.sky.lyokobot.ObjectManager; +import sx.blah.discord.handle.impl.events.guild.channel.message.MessageReceivedEvent; +import sx.blah.discord.handle.obj.IMessage; +import sx.blah.discord.handle.obj.IUser; + +import java.time.Duration; +import java.time.LocalDateTime; +import java.time.ZoneId; + +public class Admin extends CommandCore { + public Admin () { + commandName = "Admin"; + helpMessage = "Allows Server Owners to change the bot prefix and blacklist users"; + Usage = "admin "; + serverOwner = true; + } + + @Override + public boolean executeCommand(MessageReceivedEvent event, String[] argArray) { + Guild guild = ObjectManager.getGuild(event.getGuild().getLongID()); + if(argArray.length!=3) { argsNotFound(event);} + if(argArray[1].equalsIgnoreCase("blacklist") || argArray[1].equalsIgnoreCase("prefix")) { + if(argArray[1].equalsIgnoreCase("prefix")) { + if(argArray[2].length()>5) { + event.getChannel().sendMessage("Prefix is too long, please choose one shorter or equal to 5 characters"); + return true; + } + guild.setPrefix(argArray[2]); + event.getChannel().sendMessage("Prefix set successfully"); + } else { + IUser user = null; + try { + long id = Long.parseLong(argArray[2].replaceAll("\\D+","")); + user = event.getMessage().getClient().getUserByID(id); + } catch(Exception e) { + argsNotFound(event); + return false; + } + if(user.equals(event.getAuthor())) { + event.getChannel().sendMessage("You can't blacklist yourself! You're the Guild Owner!"); + return true; + } + if(guild.getBlacklisted().contains(user)) { + guild.removeBlacklist(user); + event.getChannel().sendMessage("User has been removed from the blacklist"); + } else { + guild.addBlacklist(user); + event.getChannel().sendMessage("User has been added to the blacklist"); + } + } + } else { + argsNotFound(event); + } + return true; + } +} diff --git a/src/main/java/mulley/sky/lyokobot/Commands/Commands/Administration/Query.java b/src/main/java/mulley/sky/lyokobot/Commands/Commands/Administration/Query.java new file mode 100644 index 0000000..5cbdec2 --- /dev/null +++ b/src/main/java/mulley/sky/lyokobot/Commands/Commands/Administration/Query.java @@ -0,0 +1,50 @@ +package mulley.sky.lyokobot.Commands.Commands.Administration; + +import com.vdurmont.emoji.Emoji; +import com.vdurmont.emoji.EmojiManager; +import mulley.sky.lyokobot.Commands.CommandCore; +import mulley.sky.lyokobot.Logic.Objects.Guild; +import mulley.sky.lyokobot.Main; +import mulley.sky.lyokobot.ObjectManager; +import sx.blah.discord.handle.impl.events.guild.channel.message.MessageReceivedEvent; +import sx.blah.discord.handle.obj.IMessage; + +import java.sql.ResultSet; +import java.sql.ResultSetMetaData; +import java.time.Duration; +import java.time.LocalDateTime; +import java.time.ZoneId; + +public class Query extends CommandCore { + public Query () { + commandName = "Query"; + helpMessage = "Run a query on the SQL database"; + Usage = "query "; + adminOnly = true; + helpViewable = false; + } + + @Override + public boolean executeCommand(MessageReceivedEvent event, String[] argArray) { + try { + Guild guild = ObjectManager.getGuild(event.getGuild().getLongID()); + ResultSet rs = Main.getDbManager().runQuery(event.getMessage().getContent().substring(5 + guild.getPrefix().length())); + event.getMessage().addReaction(EmojiManager.getForAlias("ok")); + ResultSetMetaData rsmd = rs.getMetaData(); + int columnsNumber = rsmd.getColumnCount(); + String embed = ""; + while (rs.next()) { + for (int i = 1; i <= columnsNumber; i++) { + if (i > 1) embed = embed + (", "); + String columnValue = rs.getString(i); + embed = embed + (columnValue + " " + rsmd.getColumnName(i) + ""); + } + embed = embed + "\n\n"; + } + event.getChannel().sendMessage("```"+embed+"```"); + return true; + }catch (Exception e) { + return true; + } + } +} diff --git a/src/main/java/mulley/sky/lyokobot/Commands/Commands/LWManagement/Register.java b/src/main/java/mulley/sky/lyokobot/Commands/Commands/LWManagement/Register.java new file mode 100644 index 0000000..d8c8b3b --- /dev/null +++ b/src/main/java/mulley/sky/lyokobot/Commands/Commands/LWManagement/Register.java @@ -0,0 +1,30 @@ +package mulley.sky.lyokobot.Commands.Commands.LWManagement; + +import mulley.sky.lyokobot.Commands.CommandCore; +import mulley.sky.lyokobot.Logic.Runnables.CreateLyokoWarrior; +import mulley.sky.lyokobot.Main; +import mulley.sky.lyokobot.ObjectManager; +import sx.blah.discord.handle.impl.events.guild.channel.message.MessageReceivedEvent; + +public class Register extends CommandCore { + public Register () { + commandName = "Register"; + helpMessage = "Create your LyokoWarrior to start playing"; + Usage = "register"; + addAlias("create"); + } + + @Override + public boolean executeCommand(MessageReceivedEvent event, String[] argArray) { + if(ObjectManager.isLyokoWarrior(event.getAuthor())) { + event.getChannel().sendMessage("You already have an Avatar registered, you can't have multiple!"); + return false; + } + if(Main.getObjectManager().isMakingLW(event.getAuthor())) { + event.getChannel().sendMessage("You're already in the process of registering an avatar, check your DM's to finish it off"); + return false; + } + Main.getObjectManager().addCLW(new CreateLyokoWarrior(event.getAuthor(),event)); + return true; + } +} diff --git a/src/main/java/mulley/sky/lyokobot/Commands/Commands/LWManagement/Reset.java b/src/main/java/mulley/sky/lyokobot/Commands/Commands/LWManagement/Reset.java new file mode 100644 index 0000000..3008066 --- /dev/null +++ b/src/main/java/mulley/sky/lyokobot/Commands/Commands/LWManagement/Reset.java @@ -0,0 +1,45 @@ +package mulley.sky.lyokobot.Commands.Commands.LWManagement; + +import mulley.sky.lyokobot.Commands.CommandCore; +import mulley.sky.lyokobot.Logic.Objects.LyokoWarrior; +import mulley.sky.lyokobot.Logic.Runnables.ResetLyokoWarrior; +import mulley.sky.lyokobot.Main; +import mulley.sky.lyokobot.ObjectManager; +import sx.blah.discord.handle.impl.events.guild.channel.message.MessageReceivedEvent; +import sx.blah.discord.handle.obj.IMessage; +import sx.blah.discord.util.EmbedBuilder; + +public class Reset extends CommandCore { + public Reset() { + commandName = "Reset"; + helpMessage = "Reset your Lyoko Warrior so you can create a new one"; + Usage = "reset"; + addAlias("delete"); + } + + @Override + public boolean executeCommand(MessageReceivedEvent event, String[] argsArray) { + if(!ObjectManager.isLyokoWarrior(event.getAuthor())) { + event.getChannel().sendMessage("You do not have a LyokoWarrior created, so nothing will be reset!"); + return false; + } + if(Main.getObjectManager().isResettingLW(event.getAuthor())) { + event.getChannel().sendMessage("You are already resetting your LyokoWarrior, finish that one first"); + return false; + } + LyokoWarrior lyokoWarrior = ObjectManager.getLyokoWarrior(event.getAuthor()); + if(lyokoWarrior.getVirtualized()) { + event.getChannel().sendMessage("You're currently virtualized, devirtualize first then run this command again"); + return false; + } + EmbedBuilder builder = new EmbedBuilder(); + builder.withColor(255,0,0); + builder.withAuthorName("Resetting LyokoWarrior"); + builder.withDescription("You are about to reset your Lyoko Warrior, this is a destructive action and it can never be recovered after reset. Reply with the message `CONFIRM` to reset your LyokoWarrior"); + builder.appendField("Class",lyokoWarrior.getLWClass().getName(),true); + builder.appendField("Level",""+lyokoWarrior.getLevel(),true); + IMessage message = event.getChannel().sendMessage(builder.build()); + Main.getObjectManager().addRLW(new ResetLyokoWarrior(lyokoWarrior,event.getChannel(),event.getClient(),message)); + return true; + } +} diff --git a/src/main/java/mulley/sky/lyokobot/Commands/Commands/LWManagement/Upgrade.java b/src/main/java/mulley/sky/lyokobot/Commands/Commands/LWManagement/Upgrade.java new file mode 100644 index 0000000..6393ee2 --- /dev/null +++ b/src/main/java/mulley/sky/lyokobot/Commands/Commands/LWManagement/Upgrade.java @@ -0,0 +1,69 @@ +package mulley.sky.lyokobot.Commands.Commands.LWManagement; + +import com.vdurmont.emoji.EmojiManager; +import mulley.sky.lyokobot.Commands.CommandCore; +import mulley.sky.lyokobot.Logic.Objects.LyokoWarrior; +import mulley.sky.lyokobot.ObjectManager; +import sx.blah.discord.handle.impl.events.guild.channel.message.MessageReceivedEvent; +import sx.blah.discord.util.EmbedBuilder; + +public class Upgrade extends CommandCore { + public Upgrade() { + commandName = "Upgrade"; + helpMessage = "Use your earned skill points to upgrade your avatar"; + Usage = "upgrade (primary/secondary/defense)"; + addAlias("shop"); + addAlias("buy"); + } + + @Override + public boolean executeCommand(MessageReceivedEvent event, String[] argsArray) { + if(!ObjectManager.isLyokoWarrior(event.getAuthor())) { + event.getChannel().sendMessage("You do not have a registered LyokoWarrior"); + return false; + } + LyokoWarrior warrior = ObjectManager.getLyokoWarrior(event.getAuthor()); + if(warrior.getVirtualized()) { + event.getChannel().sendMessage("You are currently virtualized, you cannot upgrade your Avatar while it is in use"); + return false; + } + if(argsArray.length==2) { + if(warrior.getPoints()==0) { + event.getChannel().sendMessage("You do not have any points to use for upgrading, level up to gain them!"); + return false; + } + if(argsArray[1].equalsIgnoreCase("primary")) { + warrior.upgradePrimary(); + event.getChannel().sendMessage("Primary Points increased to "+warrior.getPrimaryAttack()); + return true; + } + if(argsArray[1].equalsIgnoreCase("secondary")) { + warrior.upgradeSecondary(); + event.getChannel().sendMessage("Secondary Points increased to "+warrior.getSecondaryAttack()); + return true; + } + if(argsArray[1].equalsIgnoreCase("defense")) { + warrior.upgradeDefense(); + event.getChannel().sendMessage("Defense Points increased to "+warrior.getDefense()); + return true; + } + if(argsArray[1].equalsIgnoreCase("luck")) { + warrior.upgradeLuck(); + event.getChannel().sendMessage("Luck Points increased to "+warrior.getLuck()); + return true; + } + }else { + String prefix = ObjectManager.getGuild(event.getGuild().getLongID()).getPrefix(); + EmbedBuilder builder = new EmbedBuilder(); + builder.withAuthorIcon(event.getClient().getOurUser().getAvatarURL()); + builder.withAuthorName("Upgrade Menu"); + builder.appendField(prefix + "upgrade primary", "Upgrade your Primary Attacks to do more damage\n**Current Primary Points: **" + warrior.getPrimaryAttack(), false); + builder.appendField(prefix + "upgrade secondary", "Upgrade your Secondary Attacks to do more damage\n**Current Secondary Points: **" + warrior.getSecondaryAttack(), false); + builder.appendField(prefix + "upgrade defense", "Upgrade your Defense to take less damage\n**Current Defense Points: **" + warrior.getDefense(), false); + builder.appendField(prefix + "upgrade luck", "Upgrade your luck to increase your chances of landing attacks\n**Current Luck Points: **" + warrior.getLuck(), false); + builder.withFooterText("Avaliable Skill Points to use: " + warrior.getPoints()); + event.getChannel().sendMessage(builder.build()); + } + return true; + } +} diff --git a/src/main/java/mulley/sky/lyokobot/Commands/Commands/LWUtility/Materialise.java b/src/main/java/mulley/sky/lyokobot/Commands/Commands/LWUtility/Materialise.java new file mode 100644 index 0000000..ae0d1fc --- /dev/null +++ b/src/main/java/mulley/sky/lyokobot/Commands/Commands/LWUtility/Materialise.java @@ -0,0 +1,42 @@ +package mulley.sky.lyokobot.Commands.Commands.LWUtility; + +import mulley.sky.lyokobot.Commands.CommandCore; +import mulley.sky.lyokobot.Logic.Objects.LyokoWarrior; +import mulley.sky.lyokobot.Main; +import mulley.sky.lyokobot.ObjectManager; +import sx.blah.discord.handle.impl.events.guild.channel.message.MessageReceivedEvent; +import sx.blah.discord.handle.obj.StatusType; +import sx.blah.discord.util.EmbedBuilder; + +public class Materialise extends CommandCore { + public Materialise() { + commandName = "Materialise"; + helpMessage = "Rematerialise from Lyoko."; + Usage = "materialise"; + addAlias("devirtualize"); + addAlias("devirtualise"); + addAlias("stop"); + addAlias("rematerialise"); + } + + @Override + public boolean executeCommand(MessageReceivedEvent event, String[] argArray) { + if(!ObjectManager.isLyokoWarrior(event.getAuthor())) { + event.getChannel().sendMessage("You do not have a registered LyokoWarrior"); + return false; + } + LyokoWarrior warrior = ObjectManager.getLyokoWarrior(event.getAuthor()); + if(!warrior.getVirtualized()) { + event.getChannel().sendMessage("You are not currently Virtualized!"); + return false; + } + warrior.setVirtualized(event.getChannel(),false); + if(warrior.getHP()==100) { + event.getChannel().sendMessage("You have returned from Lyoko, please wait 2 minutes before revirtualizing"); + warrior.setHP(98); + } else { + event.getChannel().sendMessage("You have returned from Lyoko, you must wait "+((100-warrior.getHP()))+" minutes before being able to revirtualize"); + } + return true; + } +} diff --git a/src/main/java/mulley/sky/lyokobot/Commands/Commands/LWUtility/Virtualize.java b/src/main/java/mulley/sky/lyokobot/Commands/Commands/LWUtility/Virtualize.java new file mode 100644 index 0000000..ef5baaa --- /dev/null +++ b/src/main/java/mulley/sky/lyokobot/Commands/Commands/LWUtility/Virtualize.java @@ -0,0 +1,44 @@ +package mulley.sky.lyokobot.Commands.Commands.LWUtility; + +import mulley.sky.lyokobot.Commands.CommandCore; +import mulley.sky.lyokobot.Logic.Objects.LyokoWarrior; +import mulley.sky.lyokobot.Main; +import mulley.sky.lyokobot.ObjectManager; +import sx.blah.discord.handle.impl.events.guild.channel.message.MessageReceivedEvent; +import sx.blah.discord.handle.impl.obj.Presence; +import sx.blah.discord.handle.obj.ActivityType; +import sx.blah.discord.handle.obj.IPresence; +import sx.blah.discord.handle.obj.StatusType; +import sx.blah.discord.util.EmbedBuilder; + +public class Virtualize extends CommandCore { + public Virtualize() { + commandName = "Virtualize"; + helpMessage = "Virtualize yourself onto the Guilds Lyoko."; + Usage = "virtualize"; + addAlias("virtualise"); + addAlias("start"); + } + + @Override + public boolean executeCommand(MessageReceivedEvent event, String[] argArray) { + if(!ObjectManager.isLyokoWarrior(event.getAuthor())) { + event.getChannel().sendMessage("You do not have a registered LyokoWarrior"); + return false; + } + LyokoWarrior warrior = ObjectManager.getLyokoWarrior(event.getAuthor()); + if(warrior.getVirtualized()) { + event.getChannel().sendMessage("You are already virtualized on Guild "+warrior.getVirtualizedGuild().getGuild().getName()); + return false; + } + if(warrior.getHP()!=100) { + event.getChannel().sendMessage("You are currently on cooldown, please wait another "+((100-warrior.getHP()))+" minutes before you can be virtualized again"); + return false; + } + warrior.setVirtualized(event.getChannel(),true); + ObjectManager.getGuild(event.getGuild().getLongID()).addVirtualizedLW(warrior); + Main.getVirtualizedLyokoWarriors().add(warrior); + event.getChannel().sendMessage("You are now Virtualized on this Guild, keep an eye on this channel for battle notifications"); + return true; + } +} diff --git a/src/main/java/mulley/sky/lyokobot/Commands/Commands/Utility/Feedback.java b/src/main/java/mulley/sky/lyokobot/Commands/Commands/Utility/Feedback.java new file mode 100644 index 0000000..73bc63d --- /dev/null +++ b/src/main/java/mulley/sky/lyokobot/Commands/Commands/Utility/Feedback.java @@ -0,0 +1,28 @@ +package mulley.sky.lyokobot.Commands.Commands.Utility; + +import mulley.sky.lyokobot.Commands.CommandCore; +import mulley.sky.lyokobot.ObjectManager; +import sx.blah.discord.handle.impl.events.guild.channel.message.MessageReceivedEvent; +import sx.blah.discord.util.EmbedBuilder; + +public class Feedback extends CommandCore { + public Feedback() { + commandName = "Feedback"; + helpMessage = "Send feedback, suggestions or bug reports directly to the bot owner"; + Usage = "feedback "; + } + + public boolean executeCommand(MessageReceivedEvent event,String[] argsArray) { + if(argsArray.length>5) { + EmbedBuilder builder = new EmbedBuilder(); + builder.withAuthorName("Feedback"); + builder.withDescription("Guild: " + event.getGuild().getName()+" | Guild Owner: "+event.getGuild().getOwner().getName()); + builder.appendField("User: " + event.getAuthor().getName() + "#" + event.getAuthor().getDiscriminator(), event.getMessage().getContent().replace(ObjectManager.getGuild(event.getGuild().getLongID()).getPrefix()+"feedback", ""), false); + event.getClient().getApplicationOwner().getOrCreatePMChannel().sendMessage(builder.build()); + event.getChannel().sendMessage("Feedback submitted, please note depending on your message my creator could get in touch for more information. Keep an eye out for `"+event.getClient().getApplicationOwner().getName()+"#"+event.getClient().getApplicationOwner().getDiscriminator()+"` adding you as a friend."); + } else { + event.getChannel().sendMessage("Your message is a bit too short, please add a bit more to your message (This is to prevent spam or trash mail)"); + } + return true; + } +} diff --git a/src/main/java/mulley/sky/lyokobot/Commands/Commands/Utility/Help.java b/src/main/java/mulley/sky/lyokobot/Commands/Commands/Utility/Help.java new file mode 100644 index 0000000..2f2fb2e --- /dev/null +++ b/src/main/java/mulley/sky/lyokobot/Commands/Commands/Utility/Help.java @@ -0,0 +1,62 @@ +package mulley.sky.lyokobot.Commands.Commands.Utility; + +import com.vdurmont.emoji.EmojiManager; +import mulley.sky.lyokobot.Commands.CommandCore; +import mulley.sky.lyokobot.ObjectManager; +import sx.blah.discord.handle.impl.events.guild.channel.message.MessageReceivedEvent; +import sx.blah.discord.util.EmbedBuilder; + +import java.util.List; + +public class Help extends CommandCore { + private List GC; + public Help(List GC) { + commandName = "Help"; + helpViewable = false; + this.GC = GC; + } + + @Override + public boolean executeCommand(MessageReceivedEvent event, String[] argsArray) { + EmbedBuilder builder = new EmbedBuilder(); + builder.withAuthorName("Help Menu"); + builder.withAuthorIcon(event.getClient().getOurUser().getAvatarURL()); + builder.withColor(255, 255, 255); + String prefix = ObjectManager.getGuild(event.getGuild().getLongID()).getPrefix(); + if(argsArray.length==2) { + boolean found = false; + for(CommandCore GG : GC) { + if (GG.getCommandName().equalsIgnoreCase(argsArray[1]) || GG.isAlias(argsArray[1])) { + if(GG.isHelpViewable()) { + builder.withDescription("More help for the command `" + GG.getCommandName() + "`"); + builder.appendField("Help Message", GG.getHelpMessage(), false); + builder.appendField("Usage", prefix+GG.getUsage(), false); + String message = "`"; + for (String alias : GG.getAliases()) { + message = message + alias + "\n"; + } + message = message + "`"; + builder.appendField("Command Aliases", message, false); + event.getChannel().sendMessage(builder.build()); + return true; + } else { + event.getChannel().sendMessage("You don't have permission to look at the advanced help for this command"); + return false; + } + } + } + event.getChannel().sendMessage("No commands where found by that name. Please check your spelling and try again"); + return false; + }else { + String message = ""; + for (CommandCore GG : GC) { + if (GG.isHelpViewable()) { + message = message + "\n**" + GG.getCommandName() + " - **" + GG.getHelpMessage() + "\nUsage: " + prefix + GG.getUsage(); + } + } + builder.appendField("Commands", message, false); + event.getChannel().sendMessage(builder.build()); + } + return true; + } +} diff --git a/src/main/java/mulley/sky/lyokobot/Commands/Commands/Utility/Info.java b/src/main/java/mulley/sky/lyokobot/Commands/Commands/Utility/Info.java new file mode 100644 index 0000000..09a7478 --- /dev/null +++ b/src/main/java/mulley/sky/lyokobot/Commands/Commands/Utility/Info.java @@ -0,0 +1,73 @@ +package mulley.sky.lyokobot.Commands.Commands.Utility; + +import mulley.sky.lyokobot.Commands.CommandCore; +import mulley.sky.lyokobot.Logic.Objects.LyokoWarrior; +import mulley.sky.lyokobot.ObjectManager; +import sx.blah.discord.handle.impl.events.guild.channel.message.MessageReceivedEvent; +import sx.blah.discord.handle.obj.IUser; +import sx.blah.discord.util.EmbedBuilder; + +import java.util.ArrayList; +import java.util.List; + +public class Info extends CommandCore { + public Info() { + commandName = "Info"; + helpMessage = "Gets the Lyoko Warrior information about you or another player"; + Usage = "info (User)"; + } + + @Override + public boolean executeCommand(MessageReceivedEvent event,String[] argsArray) { + IUser user; + if(argsArray.length==2) { + if(argsArray[1].contains("@")) { + long id = Long.parseLong(argsArray[1].replaceAll("\\D+", "")); + user = event.getClient().getUserByID(id); + } else { + List users = new ArrayList<>(); + for(IUser user1 : event.getClient().getUsers()) { + if(user1.getName().startsWith(argsArray[1])) { + users.add(user1); + } + } + if(users.size()==0) { + event.getChannel().sendMessage("No users with that name were found (Name is caps-sensitive)"); + return false; + } + if(users.size()>1) { + event.getChannel().sendMessage("Multiple results found, please enter the users full name or alternatively tag them"); + return false; + } + user = users.get(0); + } + } else { + user = event.getAuthor(); + } + if(user.isBot()) { + event.getChannel().sendMessage("Bots aren't able to be Lyoko Warriors, choose a user instead"); + return false; + } + if(!ObjectManager.isLyokoWarrior(user)) { + event.getChannel().sendMessage("This player doesn't have a registered Lyoko Warrior and so has no information to show!"); + return false; + } + LyokoWarrior lyokoWarrior = ObjectManager.getLyokoWarrior(user); + EmbedBuilder builder = new EmbedBuilder(); + builder.withAuthorName(user.getName()+"'s LyokoWarrior Information"); + builder.withColor(0,255,0); + builder.appendField("Class",lyokoWarrior.getLWClass().getName(),true); + builder.appendField("Level - XP",lyokoWarrior.getLevel()+" ("+lyokoWarrior.getXP()+"/"+(lyokoWarrior.getLevel()*100/2)+")",true); + builder.appendField("Primary Attack Points",""+lyokoWarrior.getPrimaryAttack(),true); + builder.appendField("Secondary Attack Points",""+lyokoWarrior.getSecondaryAttack(),true); + builder.appendField("Defense Points",""+lyokoWarrior.getDefense(),true); + builder.appendField("Luck Points",""+lyokoWarrior.getLuck(),false); + if(lyokoWarrior.getVirtualized()) { + builder.appendField("Virtualized on",lyokoWarrior.getVirtualizedGuild().getGuild().getName(),true); + builder.appendField("Current Lifepoints",""+lyokoWarrior.getHP(),true); + } + builder.withAuthorIcon(lyokoWarrior.getUser().getAvatarURL()); + event.getChannel().sendMessage(builder.build()); + return true; + } +} diff --git a/src/main/java/mulley/sky/lyokobot/Commands/Commands/Utility/Ping.java b/src/main/java/mulley/sky/lyokobot/Commands/Commands/Utility/Ping.java new file mode 100644 index 0000000..50aec04 --- /dev/null +++ b/src/main/java/mulley/sky/lyokobot/Commands/Commands/Utility/Ping.java @@ -0,0 +1,27 @@ +package mulley.sky.lyokobot.Commands.Commands.Utility; + +import mulley.sky.lyokobot.Commands.CommandCore; +import sx.blah.discord.handle.impl.events.guild.channel.message.MessageReceivedEvent; +import sx.blah.discord.handle.obj.IMessage; + +import java.time.Duration; +import java.time.LocalDateTime; +import java.time.ZoneId; + +public class Ping extends CommandCore { + public Ping () { + commandName = "Ping"; + helpMessage = "Find out the latency between the server and client"; + Usage = "ping"; + } + + @Override + public boolean executeCommand(MessageReceivedEvent event, String[] argArray) { + LocalDateTime sentTime = LocalDateTime.ofInstant(event.getMessage().getTimestamp(), ZoneId.systemDefault()); + IMessage probe = event.getChannel().sendMessage("Waiting for reply.."); + LocalDateTime repliedTime = LocalDateTime.ofInstant(probe.getTimestamp(), ZoneId.systemDefault()); + long ping = Duration.between(sentTime,repliedTime).toMillis(); + probe.edit(String.format("Pong! %s (%d ms)",event.getAuthor().mention(),ping)); + return true; + } +} \ No newline at end of file diff --git a/src/main/java/mulley/sky/lyokobot/Commands/MessageListener.java b/src/main/java/mulley/sky/lyokobot/Commands/MessageListener.java new file mode 100644 index 0000000..74b991f --- /dev/null +++ b/src/main/java/mulley/sky/lyokobot/Commands/MessageListener.java @@ -0,0 +1,88 @@ +package mulley.sky.lyokobot.Commands; + +import mulley.sky.lyokobot.Commands.Commands.Administration.Admin; +import mulley.sky.lyokobot.Commands.Commands.Administration.Query; +import mulley.sky.lyokobot.Commands.Commands.LWManagement.Register; +import mulley.sky.lyokobot.Commands.Commands.LWManagement.Reset; +import mulley.sky.lyokobot.Commands.Commands.LWManagement.Upgrade; +import mulley.sky.lyokobot.Commands.Commands.LWUtility.Materialise; +import mulley.sky.lyokobot.Commands.Commands.LWUtility.Virtualize; +import mulley.sky.lyokobot.Commands.Commands.Utility.Feedback; +import mulley.sky.lyokobot.Commands.Commands.Utility.Help; +import mulley.sky.lyokobot.Commands.Commands.Utility.Info; +import mulley.sky.lyokobot.Commands.Commands.Utility.Ping; +import mulley.sky.lyokobot.DBManager; +import mulley.sky.lyokobot.Logic.Objects.Guild; +import mulley.sky.lyokobot.Main; +import mulley.sky.lyokobot.ObjectManager; +import sx.blah.discord.api.events.EventSubscriber; +import sx.blah.discord.handle.impl.events.guild.channel.message.MessageReceivedEvent; +import sx.blah.discord.handle.obj.ActivityType; +import sx.blah.discord.handle.obj.StatusType; + +import java.util.ArrayList; +import java.util.List; +import java.util.Random; +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; + +public class MessageListener { + private List commandList = new ArrayList<>(); + private DBManager manager; + + public MessageListener() { + getCommands(); + } + + @EventSubscriber + public void onMessageRecieved(MessageReceivedEvent event) { + if(!event.getChannel().isPrivate() || !event.getAuthor().isBot()) { + Guild guild = new Guild(); + guild = ObjectManager.getGuild(event.getGuild().getLongID()); + if(guild.getBlacklisted().contains(event.getAuthor())) { return;} + if(event.getAuthor().isBot()) {return;} + if(event.getMessage().getContent().startsWith("<@"+event.getClient().getOurUser().getLongID()+">")) { + event.getChannel().sendMessage("Hey there!\nMy prefix for this guild is: `"+guild.getPrefix()+"`\nUse `"+guild.getPrefix()+"help` for commands and their usages or `"+guild.getPrefix()+"tutorial` for more information on how to actually use me"); + return; + } + String[] argArray = event.getMessage().getContent().split(" "); + if (argArray.length == 0 || !argArray[0].startsWith(guild.getPrefix())) { + return; + } + String commandStr = argArray[0].substring(guild.getPrefix().length()); + for (CommandCore command : commandList) { + if (commandStr.toLowerCase().contains(command.getCommandName().toLowerCase()) || command.isAlias(commandStr.toLowerCase())) { + if(command.isServerOwner()) { + if(!event.getAuthor().equals(event.getGuild().getOwner())) { + return; + } + } + if(command.isAdminOnly()) { + if(!event.getAuthor().equals(event.getClient().getApplicationOwner())) { + return; + } + } + try { Thread.sleep(500);}catch (Exception e){} + System.out.println(event.getAuthor().getName() + "(" + event.getAuthor().getLongID() + ") ran command " + command.getCommandName() + " on Guild " + event.getGuild().getName() + "(" + event.getGuild().getLongID() + ")"); + command.executeCommand(event, argArray); + } + } + } + } + + private void getCommands() { + commandList.add(new Ping()); + commandList.add(new Query()); + commandList.add(new Admin()); + commandList.add(new Info()); + commandList.add(new Register()); + commandList.add(new Reset()); + commandList.add(new Virtualize()); + commandList.add(new Materialise()); + commandList.add(new Upgrade()); + commandList.add(new Feedback()); + + commandList.add(new Help(commandList)); + } +} diff --git a/src/main/java/mulley/sky/lyokobot/DBManager.java b/src/main/java/mulley/sky/lyokobot/DBManager.java new file mode 100644 index 0000000..b7ed843 --- /dev/null +++ b/src/main/java/mulley/sky/lyokobot/DBManager.java @@ -0,0 +1,117 @@ +package mulley.sky.lyokobot; + +import mulley.sky.lyokobot.Logic.Enums.CLASS; +import mulley.sky.lyokobot.Logic.Objects.Guild; +import mulley.sky.lyokobot.Logic.Objects.LyokoWarrior; +import sx.blah.discord.api.IDiscordClient; +import sx.blah.discord.handle.obj.IChannel; +import sx.blah.discord.handle.obj.IGuild; + +import java.io.File; +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.ResultSet; +import java.sql.Statement; +import java.util.ArrayList; +import java.util.List; + +public class DBManager { + Connection c = null; + Statement stmt = null; + IDiscordClient cli; + DBManager(IDiscordClient client) { + try { + this.cli = client; + c = DriverManager.getConnection("jdbc:sqlite:LyokoDB.db"); + stmt = c.createStatement(); + stmt.execute("CREATE TABLE IF NOT EXISTS Guilds (GuildID bigint(20), Prefix VARCHAR (5),Blacklisted varchar(2000))"); + stmt.execute("CREATE TABLE IF NOT EXISTS Players (UserID bigint(20), Class varchar(10),Level int, Points int, PrimaryAttack int, SecondaryAttack int, Defense int, XP int, Luck int)"); + System.out.println("Database Connection Complete"); + } catch (Exception e) { + System.out.println("Something has gone wrong"); + e.printStackTrace(); + } + } + + public void createLW(long id, String classs) { + try { + stmt = c.createStatement(); + stmt.execute("INSERT INTO Players (userid,class,level,points,primaryattack,secondaryattack,defense,xp,luck) VALUES ("+id+",'"+classs+"',1,0,0,0,0,0,0)"); + }catch (Exception e) { + System.out.println("Something has gone wrong"); + e.printStackTrace(); + } + } + + public void createGuild(long guildid) { + try { + stmt = c.createStatement(); + stmt.execute("INSERT INTO Guilds (guildid,prefix) VALUES ("+guildid+",'lb!')"); + } catch (Exception e) { + System.out.println("Something has gone wrong"); + e.printStackTrace(); + } + } + + public void deleteGuild(long guildid) { + try { + stmt = c.createStatement(); + stmt.execute("DELETE FROM Guilds WHERE GuildID = "+guildid); + } catch (Exception e) { + System.out.println("Something has gone wrong"); + e.printStackTrace(); + } + } + + public void deleteLyokoWarrior(long userid) { + try { + stmt = c.createStatement(); + stmt.execute("DELETE FROM Players WHERE UserID = "+userid); + }catch (Exception e) { + System.out.println("Something has gone wrong"); + e.printStackTrace(); + } + } + + public List getGuilds() { + try { + stmt = c.createStatement(); + ResultSet rs = stmt.executeQuery("SELECT * FROM Guilds"); + List guilds = new ArrayList<>(); + while(rs.next()) { + guilds.add(new Guild(cli.getGuildByID(rs.getLong("guildid")),rs.getString("prefix"),cli,rs.getString("blacklisted"))); + } + return guilds; + } catch (Exception e) { + System.out.println("Something has gone wrong"); + e.printStackTrace(); + return null; + } + } + + public List getPlayers() { + try { + stmt = c.createStatement(); + ResultSet rs = stmt.executeQuery("SELECT * FROM Players"); + List players = new ArrayList<>(); + while (rs.next()) { + players.add(new LyokoWarrior(cli.getUserByID(rs.getLong("userid")), CLASS.getClass(rs.getString("class")), rs.getInt("level"), rs.getInt("points"), rs.getInt("primaryattack"), rs.getInt("secondaryattack"), rs.getInt("defense"), rs.getInt("xp"),rs.getInt("luck"))); + } + return players; + }catch (Exception e) { + System.out.println("Something has gone wrong"); + e.printStackTrace(); + return null; + } + } + + public ResultSet runQuery(String statement) { + try { + stmt = c.createStatement(); + System.out.println("Query: "+statement+" was just run"); + return stmt.executeQuery(statement); + } catch (Exception e) { + return null; + } + } +} \ No newline at end of file diff --git a/src/main/java/mulley/sky/lyokobot/Listener.java b/src/main/java/mulley/sky/lyokobot/Listener.java new file mode 100644 index 0000000..231e577 --- /dev/null +++ b/src/main/java/mulley/sky/lyokobot/Listener.java @@ -0,0 +1,47 @@ +package mulley.sky.lyokobot; + +import mulley.sky.lyokobot.Logic.Objects.Guild; +import sx.blah.discord.api.events.EventSubscriber; +import sx.blah.discord.handle.impl.events.guild.GuildCreateEvent; +import sx.blah.discord.handle.impl.events.guild.GuildLeaveEvent; +import sx.blah.discord.util.EmbedBuilder; + +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; + +public class Listener { + + @EventSubscriber + public void onGuildStart(GuildCreateEvent event) { + for(Guild guild : Main.getRegisteredGuilds()) { + if(guild.getGuild().equals(event.getGuild())) {return;} + } + System.out.println("Bot was invited into Guild "+event.getGuild().getName()+"("+event.getGuild().getLongID()+")"); + EmbedBuilder builder = new EmbedBuilder(); + builder.withAuthorName("LyokoBot"); + builder.withColor(0,255,0); + builder.withTitle("Hey There!"); + builder.withDescription("Let's get started, the default prefix to use me is `lb!`, so that's `lb!help` to find the rest of my commands.\n You can change this prefix using the Admin command reserved for super Guild Owners! `lb!admin`, along with other stuff like blacklisting users from using me on your server.\nMore information on actually using the bot can be found using `lb!tutorial`, feedback can be given directly to the bot owner using `lb!feedback`\nSee you on Lyoko!"); + builder.withFooterText("Made by Sky#2134"); + builder.withAuthorIcon(event.getClient().getOurUser().getAvatarURL()); + event.getGuild().getOwner().getOrCreatePMChannel().sendMessage(builder.build()); + Main.getDbManager().createGuild(event.getGuild().getLongID()); + Main.getRegisteredGuilds().add(new Guild(event.getGuild(),"lb!",event.getClient(),"")); + System.out.println("Guild successfully registered into system"); + } + + @EventSubscriber + public void onGuildLeave(GuildLeaveEvent event) { + System.out.println("Bot was kicked out of Guild "+event.getGuild().getName()+"("+event.getGuild().getLongID()+")"); + Main.getDbManager().deleteGuild(event.getGuild().getLongID()); + Guild delGuild = new Guild(); + for(Guild guild : Main.getRegisteredGuilds()) { + if(guild.getGuild().equals(event.getGuild())) { + delGuild = guild; + } + } + Main.getRegisteredGuilds().remove(delGuild); + System.out.println("Guild successfully removed from system"); + } +} diff --git a/src/main/java/mulley/sky/lyokobot/Logic/Enums/CLASS.java b/src/main/java/mulley/sky/lyokobot/Logic/Enums/CLASS.java new file mode 100644 index 0000000..65b2e2b --- /dev/null +++ b/src/main/java/mulley/sky/lyokobot/Logic/Enums/CLASS.java @@ -0,0 +1,35 @@ +package mulley.sky.lyokobot.Logic.Enums; + +public enum CLASS { + GUARDIAN("Guardian","Energy Field","Energy Smash","Flight"), + FELINE("Feline","Lazer Arrow","Lazer Storm","Shield"), + GEISHA("Geisha","Single Fan","Dual Fans","Telekenesis"), + SAMURAI("Samurai","Sword Flash","Triplicate","Super Sprint"), + WARRIOR("Warrior","Sword Smash","Spinning Top","Super Smoke"); + + + final String name; + final String primaryAttack; + final String secondaryAttack; + final String defense; + CLASS(String name, String primaryAttack, String secondaryAttack, String defense) { + this.name = name; + this.primaryAttack = primaryAttack; + this.secondaryAttack = secondaryAttack; + this.defense = defense; + } + + public static CLASS getClass(String namo) { + for(CLASS classs : CLASS.values()) { + if(namo.equalsIgnoreCase(classs.getName())) { + return classs; + } + } + return null; + } + + public String getName() { return name; } + public String getPrimaryAttack() {return primaryAttack;} + public String getSecondaryAttack() {return secondaryAttack;} + public String getDefense() {return defense;} +} diff --git a/src/main/java/mulley/sky/lyokobot/Logic/Enums/MONSTERS.java b/src/main/java/mulley/sky/lyokobot/Logic/Enums/MONSTERS.java new file mode 100644 index 0000000..16b67ff --- /dev/null +++ b/src/main/java/mulley/sky/lyokobot/Logic/Enums/MONSTERS.java @@ -0,0 +1,43 @@ +package mulley.sky.lyokobot.Logic.Enums; + +import java.util.Random; + +public enum MONSTERS { + KANKRELATS("Kankrelat",1,1,1,100), + BLOKS("Blok",2,2,2,100), + HORNETS("Hornet",3,3,4,100), + KRABS("Krab",4,2,3,100), + MEGATANKS("Megatank",5,5,3,100), + MANTAS("Manta",6,3,4,100), + TARANTULAS("Tarantula",7,4,3,100); + + final String name; + final int requiredLevel; + final int attackPoints; + final int defensePoints; + int health; + + MONSTERS(String name, int requiredLevel, int attackPoints, int defensePoints, int health) { + this.name = name; + this.requiredLevel = requiredLevel; + this.attackPoints = attackPoints; + this.defensePoints = defensePoints; + this.health = health; + } + + public int getRequiredLevel() {return requiredLevel;} + public int getAttackPoints() {return attackPoints;} + public int getDefensePoints() {return defensePoints;} + public int getHealth() {return health;} + public String getName() {return name;} + + public void setHealth(int hp) {health = hp;} + + public static MONSTERS getRandomMonster(int level) { + for(MONSTERS monsters : MONSTERS.values()) { + MONSTERS randomMonster = MONSTERS.values()[new Random().nextInt(MONSTERS.values().length)]; + if(randomMonster.requiredLevel<=level) { return randomMonster;} + } + return null; + } +} diff --git a/src/main/java/mulley/sky/lyokobot/Logic/Objects/Guild.java b/src/main/java/mulley/sky/lyokobot/Logic/Objects/Guild.java new file mode 100644 index 0000000..7ed305a --- /dev/null +++ b/src/main/java/mulley/sky/lyokobot/Logic/Objects/Guild.java @@ -0,0 +1,85 @@ +package mulley.sky.lyokobot.Logic.Objects; + +import mulley.sky.lyokobot.Main; +import sx.blah.discord.api.IDiscordClient; +import sx.blah.discord.handle.obj.IGuild; +import sx.blah.discord.handle.obj.IUser; + +import java.util.ArrayList; +import java.util.List; + +public class Guild { + private IGuild guild; + private String prefix; + private List users = new ArrayList<>(); + private IDiscordClient cli; + private List virtualizedLWs = new ArrayList<>(); + + public Guild(IGuild guild, String prefix, IDiscordClient cli, String blacklisted) { + this.guild = guild; + this.prefix = prefix; + this.cli = cli; + if(blacklisted!=null) { + if (!blacklisted.equals("")) { + String[] blacklist = blacklisted.split(","); + for (String string : blacklist) { + users.add(cli.getUserByID(Long.parseLong(string))); + } + } + } + } + public Guild() {} + + public String getPrefix() { + return prefix; + } + public IGuild getGuild() {return guild;} + public List getBlacklisted() {return users;} + + public void setPrefix(String prefix) { + Main.getDbManager().runQuery("UPDATE Guilds SET Prefix = '"+prefix+"' WHERE GuildID = "+guild.getLongID()); + this.prefix = prefix; + } + + public void addBlacklist(IUser user) { + users.add(user); + if(users.size()==0) { + Main.getDbManager().runQuery("UPDATE Guilds SET Blacklisted = '"+user.getLongID()+"' WHERE GuildID = "+guild.getLongID()); + } else { + String blacklisted = ""; + int i = 0; + for(IUser user1 : getBlacklisted()) { + i = i + 1; + if(i==getBlacklisted().size()) { + blacklisted = blacklisted + user1.getLongID(); + } else { + blacklisted = blacklisted + user1.getLongID() + ","; + } + } + Main.getDbManager().runQuery("UPDATE Guilds SET Blacklisted = '"+blacklisted+"' WHERE GuildID = "+guild.getLongID()); + } + } + + public void removeBlacklist(IUser user) { + users.remove(user); + String blacklisted = ""; + int i = 0; + for(IUser user1 : getBlacklisted()) { + i = i + 1; + if(i==getBlacklisted().size()) { + blacklisted = blacklisted + user1.getLongID(); + } else { + blacklisted = blacklisted + user1.getLongID() + ","; + } + } + Main.getDbManager().runQuery("UPDATE Guilds SET blacklisted '"+blacklisted+"' WHERE GuildID = "+guild.getLongID()); + } + + public void addVirtualizedLW(LyokoWarrior warrior) { + virtualizedLWs.add(warrior); + } + + public void removeVirtualizedLW(LyokoWarrior warrior) { + virtualizedLWs.remove(warrior); + } +} diff --git a/src/main/java/mulley/sky/lyokobot/Logic/Objects/LyokoWarrior.java b/src/main/java/mulley/sky/lyokobot/Logic/Objects/LyokoWarrior.java new file mode 100644 index 0000000..9736d2d --- /dev/null +++ b/src/main/java/mulley/sky/lyokobot/Logic/Objects/LyokoWarrior.java @@ -0,0 +1,166 @@ +package mulley.sky.lyokobot.Logic.Objects; + +import mulley.sky.lyokobot.DBManager; +import mulley.sky.lyokobot.Logic.Enums.CLASS; +import mulley.sky.lyokobot.Logic.Runnables.AttackRunnable; +import mulley.sky.lyokobot.Main; +import mulley.sky.lyokobot.ObjectManager; +import sx.blah.discord.handle.obj.IChannel; +import sx.blah.discord.handle.obj.IGuild; +import sx.blah.discord.handle.obj.IUser; +import sx.blah.discord.util.EmbedBuilder; + +public class LyokoWarrior { + private IUser user; + private CLASS classs; + private int level; + private int points; + private int primaryAttack; + private int secondaryAttack; + private int defense; + private int xp; + private boolean virtualized; + private IChannel virtualizedChannel; + private Guild virtualizedGuild; + private int hp = 100; + private int xpgained = 0; + private int monstersKilled = 0; + private boolean recentlyAttacked = false; + private AttackRunnable runnable; + private int luck; + + public LyokoWarrior(IUser user,CLASS classs, int level, int points, int primaryAttack, int secondaryAttack, int defense, int xp, int luck) { + this.user = user; + this.classs = classs; + this.level = level; + this.points = points; + this.primaryAttack = primaryAttack; + this.secondaryAttack = secondaryAttack; + this.defense = defense; + this.xp = xp; + this.luck = luck; + } + + public IUser getUser() {return this.user;} + public CLASS getLWClass() {return this.classs;} + public int getLevel() {return this.level; } + public int getXP() {return this.xp;} + public int getPrimaryAttack() {return this.primaryAttack;} + public int getSecondaryAttack() {return this.secondaryAttack;} + public int getDefense() {return this.defense;} + public boolean getVirtualized() {return virtualized;} + public IChannel getVirtualizedChannel() {return virtualizedChannel;} + public Guild getVirtualizedGuild() {return virtualizedGuild;} + public int getHP() {return hp;} + public int getPoints() {return points;} + public int getLuck() {return luck;} + + public int getMonstersKilled() {return monstersKilled;} + public int getXpgained() {return xpgained;} + + public void setVirtualized(IChannel guild,boolean toggle) { + virtualized = toggle; + virtualizedChannel = guild; + virtualizedGuild = ObjectManager.getGuild(guild.getGuild().getLongID()); + if (virtualized) { + xpgained = 0; + monstersKilled = 0; + recentlyAttacked = false; + } else { + if(isAttacking()) {runnable.stopAttacking(true);} + runnable = null; + EmbedBuilder builder = new EmbedBuilder(); + builder.withAuthorName("Final Virtualization Figures"); + builder.withAuthorIcon(user.getAvatarURL()); + builder.appendField("Monsters Killed",monstersKilled+"",true); + builder.appendField("XP Gained",xpgained+"",true); + if(this.hp<0) {this.hp=0;} + builder.appendField("Final Lifepoints",hp+"",true); + builder.withColor(0,255,0); + virtualizedChannel.sendMessage(builder.build()); + Main.getVirtualizedLyokoWarriors().remove(this); + ObjectManager.getGuild(guild.getGuild().getLongID()).removeVirtualizedLW(this); + } + } + + public void setHP(int hp) { + this.hp = hp; + } + + public void addHP(int hp) { + this.hp = this.hp + hp; + if(this.hp > 100) { + this.hp = 100; + } + } + + public boolean loseHP(int hp) { + this.hp = this.hp - hp; + if(this.hp<=0) { + setVirtualized(getVirtualizedChannel(),false); + this.hp = 0; + return true; + } + return false; + } + + public boolean addXP(int xps) { + xp = xps + xp; + xpgained = xpgained + xps; + if(xp >= level*100/2) { + level = level + 1; + xp = 0; + points = points + 1; + Main.getDbManager().runQuery("UPDATE Players SET XP = 0 WHERE UserID = "+user.getLongID()); + Main.getDbManager().runQuery("UPDATE Players SET Level = "+level+" WHERE UserID = "+user.getLongID()); + Main.getDbManager().runQuery("UPDATE Players SET Points = "+points+" WHERE UserID = "+user.getLongID()); + return true; + } + Main.getDbManager().runQuery("UPDATE Players SET XP = "+xp+" WHERE UserID = "+user.getLongID()); + return false; + } + + public void upgradePrimary() { + points = points - 1; + Main.getDbManager().runQuery("UPDATE Players SET Points = "+points+" WHERE UserID = "+user.getLongID()); + primaryAttack = primaryAttack + 1; + Main.getDbManager().runQuery("UPDATE Players SET PrimaryAttack = "+primaryAttack+" WHERE UserID = "+user.getLongID()); + } + + public void upgradeSecondary() { + points = points - 1; + Main.getDbManager().runQuery("UPDATE Players SET Points = "+points+" WHERE UserID = "+user.getLongID()); + secondaryAttack = secondaryAttack + 1; + Main.getDbManager().runQuery("UPDATE Players SET PrimaryAttack = "+secondaryAttack+" WHERE UserID = "+user.getLongID()); + } + + public void upgradeDefense() { + points = points - 1; + Main.getDbManager().runQuery("UPDATE Players SET Points = "+points+" WHERE UserID = "+user.getLongID()); + defense = defense + 1; + Main.getDbManager().runQuery("UPDATE Players SET PrimaryAttack = "+defense+" WHERE UserID = "+user.getLongID()); + } + + public void upgradeLuck() { + points = points - 1; + Main.getDbManager().runQuery("UPDATE Players SET Points = "+points+" WHERE UserID = "+user.getLongID()); + luck = luck + 1; + Main.getDbManager().runQuery("UPDATE Players SET PrimaryAttack = "+luck+" WHERE UserID = "+user.getLongID()); + } + + public void startAttacking(AttackRunnable runnable) {this.runnable = runnable;} + public void stopAttacking() {runnable.stopAttacking(true);this.runnable=null;} + public void softStopAttacking() {this.runnable=null;} + public boolean isAttacking() {if(this.runnable!=null){return true;}else{return false;}} + public void addMonsters(int monsters) {this.monstersKilled = this.monstersKilled + monsters;} + + public boolean recentlyAttackedToggle() { + if(recentlyAttacked) { + recentlyAttacked = false; + return false; + } else { + recentlyAttacked = true; + return true; + } + } +} diff --git a/src/main/java/mulley/sky/lyokobot/Logic/Objects/Monster.java b/src/main/java/mulley/sky/lyokobot/Logic/Objects/Monster.java new file mode 100644 index 0000000..8b7209a --- /dev/null +++ b/src/main/java/mulley/sky/lyokobot/Logic/Objects/Monster.java @@ -0,0 +1,19 @@ +package mulley.sky.lyokobot.Logic.Objects; + +import mulley.sky.lyokobot.Logic.Enums.MONSTERS; + +public class Monster { + private MONSTERS monster; + private int health; + + public Monster(MONSTERS monster, int health) { + this.monster = monster; + this.health = health; + } + + public void setHealth(int hp) {health = hp;} + public int getHealth() {return health;} + public String getName() {return monster.getName();} + public int getAttackPoints() {return monster.getAttackPoints();} + public int getDefensePoints() {return monster.getDefensePoints();} +} diff --git a/src/main/java/mulley/sky/lyokobot/Logic/Runnables/AttackRunnable.java b/src/main/java/mulley/sky/lyokobot/Logic/Runnables/AttackRunnable.java new file mode 100644 index 0000000..a0bbe15 --- /dev/null +++ b/src/main/java/mulley/sky/lyokobot/Logic/Runnables/AttackRunnable.java @@ -0,0 +1,297 @@ +package mulley.sky.lyokobot.Logic.Runnables; + +import com.vdurmont.emoji.EmojiManager; +import mulley.sky.lyokobot.Logic.Enums.MONSTERS; +import mulley.sky.lyokobot.Logic.Objects.LyokoWarrior; +import mulley.sky.lyokobot.Logic.Objects.Monster; +import mulley.sky.lyokobot.Main; +import sx.blah.discord.api.events.EventSubscriber; +import sx.blah.discord.handle.impl.events.guild.channel.message.MessageReceivedEvent; +import sx.blah.discord.handle.obj.IMessage; +import sx.blah.discord.handle.obj.StatusType; +import sx.blah.discord.util.EmbedBuilder; + +import java.util.ArrayList; +import java.util.List; +import java.util.Random; +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.ScheduledFuture; +import java.util.concurrent.TimeUnit; + +public class AttackRunnable { + private LyokoWarrior lyokoWarrior; + private List monsters = new ArrayList<>(); + private int amountMonsters = 0; + private int xpGained = 0; + private IMessage message; + private boolean checking = false; + private ScheduledFuture future; + public AttackRunnable(LyokoWarrior warrior) { + this.lyokoWarrior = warrior; + } + + public void start() { + try { + int numberMonsters = new Random().nextInt(2) + 1; + for (int i = 0; i < numberMonsters; i++) { + MONSTERS monsters1 = MONSTERS.getRandomMonster(lyokoWarrior.getLevel()); + if(monsters1==null) { + i = i - 1; + } else { + Monster monster2 = new Monster(monsters1,100); + monsters.add(monster2); + } + } + EmbedBuilder builder = new EmbedBuilder(); + builder.withColor(0, 0, 0); + builder.withAuthorName(lyokoWarrior.getUser().getName() + "'s Battle"); + builder.withAuthorIcon(lyokoWarrior.getUser().getAvatarURL()); + String monsterType = "\n"; + int monsterNum = 0; + for (Monster monster1 : monsters) { + monsterNum = monsterNum + 1; + monsterType = monsterType + "\n**" + monsterNum + ".** " + monster1.getName() + " | " + monster1.getHealth() + "/100"; + } + lyokoWarrior.getVirtualizedChannel().sendMessage(lyokoWarrior.getUser().mention()); + builder.withDescription("You are faced with " + numberMonsters + " of XANA's monsters" + monsterType); + builder.appendField("Your turn", "Health: " + lyokoWarrior.getHP() + "/100", false); + builder.withFooterText("Tip: Reply with `primary 1` to use a primary attack"); + message = lyokoWarrior.getVirtualizedChannel().sendMessage(builder.build()); + lyokoWarrior.getVirtualizedChannel().getClient().getDispatcher().registerListener(this); + startChecking(); + }catch (Exception e) {e.printStackTrace();lyokoWarrior.stopAttacking();} + } + + @EventSubscriber + public void onMessageReceieved(MessageReceivedEvent event) { + if(event.getAuthor().equals(lyokoWarrior.getUser())) { + if(event.getChannel().equals(lyokoWarrior.getVirtualizedChannel())) { + String[] argArray = event.getMessage().getContent().split(" "); + EmbedBuilder builder = new EmbedBuilder(); + builder.withColor(0,0,0); + builder.withAuthorName(lyokoWarrior.getUser().getName()+"'s Battle"); + builder.withAuthorIcon(lyokoWarrior.getUser().getAvatarURL()); + if(argArray[0].equalsIgnoreCase("primary")) { + if (argArray.length!=2 || argArray[1].equals("1") || argArray[1].equals("2") || argArray[1].equals("3")) { + int monsterVar = Integer.parseInt(argArray[1]) - 1; + String recent = ""; + if(monsters.size()>=monsterVar) { + try { + Thread.sleep(500); + event.getMessage().delete(); + } catch (Exception e) {} + if((new Random().nextInt(3)+1 != 2)) { + int damage = (20 + (lyokoWarrior.getPrimaryAttack()*2)) - monsters.get(monsterVar).getDefensePoints()*3; + recent = lyokoWarrior.getUser().getName()+" used "+lyokoWarrior.getLWClass().getPrimaryAttack()+" and did "+damage+" damage to "+monsters.get(monsterVar).getName(); + monsters.get(monsterVar).setHealth(monsters.get(monsterVar).getHealth()-damage); + if(monsters.get(monsterVar).getHealth()<=0) { + recent = recent + "\n" +monsters.get(monsterVar).getName()+" was devirtualized"; + xpGained = (monsters.get(monsterVar).getAttackPoints() * 10) + xpGained; + monsters.remove(monsterVar); + amountMonsters = amountMonsters + 1; + } + } else { + recent = lyokoWarrior.getUser().getName()+" used "+lyokoWarrior.getLWClass().getPrimaryAttack()+" on "+monsters.get(monsterVar).getName() + " but missed!"; + } + } else { + event.getMessage().addReaction(EmojiManager.getForAlias("interrobang")); + return; + } + + for(Monster monster : monsters) { + if ((new Random().nextInt(3) + 1) == 2) { + if (lyokoWarrior.loseHP((monster.getAttackPoints() * 10) - lyokoWarrior.getDefense()*2)) { + recent = recent + "\n" + monster.getName() + " hit you and dealt " +((monster.getAttackPoints() * 10) - lyokoWarrior.getDefense()*2)+" damage!"; + checking = true; + stopAttacking(false); + builder.withDescription(recent+"\n\n**You have lost all your life points and have been devirtualized...**"); + String monsterType = "\n"; + int monsterNum = 0; + for (Monster monster1 : monsters) { + monsterNum = monsterNum + 1; + monsterType = monsterType + "\n**" + monsterNum + ".** " + monster.getName() + " | " + monster.getHealth() + "/100"; + } + builder.appendField("Final Monster Stats",monsterType,false); + builder.appendField("Monsters Defeated",""+amountMonsters,false); + builder.appendField("XP Gained",""+xpGained,false); + builder.withColor(255,0,0); + if(lyokoWarrior.addXP(xpGained)) { + lyokoWarrior.getVirtualizedChannel().sendMessage(lyokoWarrior.getUser().mention()+" **Level Up!** "+(lyokoWarrior.getLevel()-1)+" >> "+lyokoWarrior.getLevel()+"\nYou earned a skill point! Use it to increase your stats!"); + } + message.edit(builder.build()); + return; + } + recent = recent + "\n" + monster.getName() + " hit you and dealt " +monster.getAttackPoints()*10+" damage!"; + } else { + recent = recent + "\n" + monster.getName() + " shot at you but missed."; + } + } + if(monsters.size()!=0) { + getEmbed(recent); + } else { + builder.appendField("Battle Over","You won!",false); + builder.appendField("Monsters Defeated",""+amountMonsters,true); + builder.appendField("XP Gained",""+xpGained,true); + builder.withColor(0,255,0); + message.edit(builder.build()); + if(lyokoWarrior.addXP(xpGained)) { + lyokoWarrior.getVirtualizedChannel().sendMessage(lyokoWarrior.getUser().mention()+" **Level Up!** "+(lyokoWarrior.getLevel()-1)+" >> "+lyokoWarrior.getLevel()+"\nYou earned a skill point! Use it to increase your stats!"); + } + stopAttacking(false); + } + } else { + event.getMessage().addReaction(EmojiManager.getForAlias("interrobang")); + return; + } + } + if(argArray[0].equalsIgnoreCase("secondary")) { + String recent = ""; + try { + Thread.sleep(500); + event.getMessage().delete(); + }catch (Exception e){} + for(Monster monster : monsters) { + if ((new Random().nextInt(3) + 1 != 2)) { + int damage = (15 + (lyokoWarrior.getSecondaryAttack()*2) - monster.getDefensePoints()*3); + recent = lyokoWarrior.getUser().getName()+" used "+lyokoWarrior.getLWClass().getSecondaryAttack()+" and did "+damage+" damage to "+monster.getName(); + monster.setHealth(monster.getHealth()-damage); + if(monster.getHealth()<=0) { + recent = recent + "\n" +monster.getName()+" was devirtualized"; + xpGained = (monster.getAttackPoints()*10) + xpGained; + monsters.remove(monster); + amountMonsters = amountMonsters + 1; + } + } else { + recent = lyokoWarrior.getUser().getName()+" used "+lyokoWarrior.getLWClass().getSecondaryAttack()+" on "+monster.getName()+" but missed!"; + } + } + for(Monster monster : monsters) { + if ((new Random().nextInt(3) + 1) == 2) { + if (lyokoWarrior.loseHP((monster.getAttackPoints() * 10) - lyokoWarrior.getDefense()*2)) { + recent = recent + "\n" + monster.getName() + " hit you and dealt " +((monster.getAttackPoints() * 10) - lyokoWarrior.getDefense()*2)+" damage!"; + checking = true; + stopAttacking(false); + builder.withDescription(recent+"\n\n**You have lost all your life points and have been devirtualized...**"); + String monsterType = "\n"; + int monsterNum = 0; + for (Monster monster1 : monsters) { + monsterNum = monsterNum + 1; + monsterType = monsterType + "\n**" + monsterNum + ".** " + monster.getName() + " | " + monster.getHealth() + "/100"; + } + builder.appendField("Final Monster Stats",monsterType,false); + builder.appendField("Monsters Defeated",""+amountMonsters,false); + builder.appendField("XP Gained",""+xpGained,false); + builder.withColor(255,0,0); + if(lyokoWarrior.addXP(xpGained)) { + lyokoWarrior.getVirtualizedChannel().sendMessage(lyokoWarrior.getUser().mention()+" **Level Up!** "+(lyokoWarrior.getLevel()-1)+" >> "+lyokoWarrior.getLevel()+"\nYou earned a skill point! Use it to increase your stats!"); + } + message.edit(builder.build()); + return; + } + recent = recent + "\n" + monster.getName() + " hit you and dealt " +monster.getAttackPoints()*10+" damage!"; + } else { + recent = recent + "\n" + monster.getName() + " shot at you but missed."; + } + } + if(monsters.size()!=0) { + getEmbed(recent); + } else { + builder.appendField("Battle Over","You won!",false); + builder.appendField("Monsters Defeated",""+amountMonsters,true); + builder.appendField("XP Gained",""+xpGained,true); + builder.withColor(0,255,0); + message.edit(builder.build()); + if(lyokoWarrior.addXP(xpGained)) { + lyokoWarrior.getVirtualizedChannel().sendMessage(lyokoWarrior.getUser().mention()+" **Level Up!** "+(lyokoWarrior.getLevel()-1)+" >> "+lyokoWarrior.getLevel()+"\nYou earned a skill point! Use it to increase your stats!"); + } + stopAttacking(false); + } + } + } + } + } + + private ScheduledExecutorService service = Executors.newScheduledThreadPool(1); + private void startChecking() { + future = service.scheduleAtFixedRate(() -> { + String recent = ""; + for(Monster monster : monsters) { + if((new Random().nextInt(3)+1) == 2) { + if(lyokoWarrior.loseHP((monster.getAttackPoints()*10) - lyokoWarrior.getDefense()*2)) { + recent = recent + "\n" + monster.getName() + " hit you and dealt " +((monster.getAttackPoints()*10) - lyokoWarrior.getDefense()*2)+" damage!"; + checking = true; + stopAttacking(false); + EmbedBuilder builder = new EmbedBuilder(); + builder.withAuthorName(lyokoWarrior.getUser().getName() + "'s Battle"); + builder.withAuthorIcon(lyokoWarrior.getUser().getAvatarURL()); + builder.withColor(255,0,0); + builder.withDescription(recent+"\n\n**You have lost all your life points and have been devirtualized...**"); + String monsterType = "\n"; + int monsterNum = 0; + for (Monster monster1 : monsters) { + monsterNum = monsterNum + 1; + monsterType = monsterType + "\n**" + monsterNum + ".** " + monster.getName() + " | " + monster.getHealth() + "/100"; + } + builder.appendField("Final Monster Stats",monsterType,false); + builder.appendField("Monsters Defeated",""+amountMonsters,true); + builder.appendField("XP Gained",""+xpGained,true); + message.edit(builder.build()); + if(lyokoWarrior.addXP(xpGained)) { + lyokoWarrior.getVirtualizedChannel().sendMessage(lyokoWarrior.getUser().mention()+" **Level Up!** "+(lyokoWarrior.getLevel()-1)+" >> "+lyokoWarrior.getLevel()+"\nYou earned a skill point! Use it to increase your stats!"); + } + return; + } + recent = recent + "\n" + monster.getName() + " hit you and dealt " +monster.getAttackPoints()*10+" damage!"; + } else { + recent = recent + "\n" + monster.getName() + " shot at you but missed."; + } + } + getEmbed(recent); + },30,30, TimeUnit.SECONDS); + } + + public LyokoWarrior getLyokoWarrior() {return lyokoWarrior;} + + public void stopAttacking(boolean doEmbed) { + lyokoWarrior.getVirtualizedChannel().getClient().getDispatcher().unregisterListener(this); + lyokoWarrior.softStopAttacking(); + future.cancel(false); + if(doEmbed && !checking) { + EmbedBuilder builder = new EmbedBuilder(); + builder.withAuthorName(lyokoWarrior.getUser().getName() + "'s Battle"); + builder.withAuthorIcon(lyokoWarrior.getUser().getAvatarURL()); + builder.withColor(255, 0, 0); + builder.withDescription("You were devirtualized"); + String monsterType = "\n"; + int monsterNum = 0; + for (Monster monster1 : monsters) { + monsterNum = monsterNum + 1; + monsterType = monsterType + "\n**" + monsterNum + ".** " + monster1.getName() + " | " + monster1.getHealth() + "/100"; + } + builder.appendField("Final Monster Stats", monsterType, false);builder.appendField("Remaining Lifepoints",""+lyokoWarrior.getHP(),true); + builder.appendField("Monsters Defeated",""+amountMonsters,true); + builder.appendField("XP Gained",""+xpGained,true); + message.edit(builder.build()); + if(lyokoWarrior.addXP(xpGained)) { + lyokoWarrior.getVirtualizedChannel().sendMessage(lyokoWarrior.getUser().mention()+" **Level Up!** "+(lyokoWarrior.getLevel()-1)+">>"+lyokoWarrior.getLevel()+"\nYou earned a skill point! Use it to increase your stats!"); + } + } + } + + public void getEmbed(String recent) { + String monsterType = "\n"; + int monsterNum = 0; + for (Monster monster : monsters) { + monsterNum = monsterNum + 1; + monsterType = monsterType + "\n**" + monsterNum + ".** " + monster.getName() + " | " + monster.getHealth() + "/100"; + } + EmbedBuilder builder = new EmbedBuilder(); + builder.withAuthorName(lyokoWarrior.getUser().getName() + "'s Battle"); + builder.withAuthorIcon(lyokoWarrior.getUser().getAvatarURL()); + builder.withDescription(recent + monsterType); + builder.appendField("Your turn", "Health: " + lyokoWarrior.getHP() + "/100", false); + builder.withFooterText("Tip: Reply with `primary 1` to use a primary attack"); + message.edit(builder.build()); + } +} diff --git a/src/main/java/mulley/sky/lyokobot/Logic/Runnables/CreateLyokoWarrior.java b/src/main/java/mulley/sky/lyokobot/Logic/Runnables/CreateLyokoWarrior.java new file mode 100644 index 0000000..7255be1 --- /dev/null +++ b/src/main/java/mulley/sky/lyokobot/Logic/Runnables/CreateLyokoWarrior.java @@ -0,0 +1,77 @@ +package mulley.sky.lyokobot.Logic.Runnables; + +import mulley.sky.lyokobot.Commands.MessageListener; +import mulley.sky.lyokobot.Logic.Enums.CLASS; +import mulley.sky.lyokobot.Logic.Objects.LyokoWarrior; +import mulley.sky.lyokobot.Main; +import mulley.sky.lyokobot.ObjectManager; +import sx.blah.discord.api.IDiscordClient; +import sx.blah.discord.api.events.EventSubscriber; +import sx.blah.discord.handle.impl.events.guild.channel.message.MessageReceivedEvent; +import sx.blah.discord.handle.impl.events.guild.channel.message.reaction.ReactionAddEvent; +import sx.blah.discord.handle.obj.IMessage; +import sx.blah.discord.handle.obj.IUser; +import sx.blah.discord.util.EmbedBuilder; + +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.ScheduledFuture; +import java.util.concurrent.TimeUnit; + +public class CreateLyokoWarrior { + private IUser user; + private MessageReceivedEvent cli; + private IMessage message; + private ScheduledFuture future; + public CreateLyokoWarrior(IUser user, MessageReceivedEvent cli) { + this.user = user; + this.cli = cli; + start(user,cli); + cli.getClient().getDispatcher().registerListener(this); + } + private void start(IUser user, MessageReceivedEvent cli) { + EmbedBuilder builder = new EmbedBuilder(); + builder.withAuthorName("Register a new Lyoko Warrior"); + builder.withAuthorIcon(cli.getClient().getOurUser().getAvatarURL()); + builder.withDescription("Welcome to the Lyoko Warrior registration process, this process just requires you to pick your class. Then you'll be good to go, here are your choices. When you pick one just reply back with its name.\n**MAKE SURE YOU PICK RIGHT, ONCE YOU PICK YOUR CLASS THERE IS NO CHANGING IT UNLESS YOU RESET YOUR LYOKOWARRIOR**"); + builder.withColor(255,165,0); + for(CLASS classs : CLASS.values()) { + builder.appendField(classs.getName(),"Primary Attack: "+classs.getPrimaryAttack()+"\nSecondary Attack: "+classs.getSecondaryAttack()+"\nDefense: "+classs.getDefense(),false); + } + cli.getChannel().sendMessage(cli.getAuthor().mention()); + message = cli.getChannel().sendMessage(builder.build()); + start(); + } + + @EventSubscriber + public void checkMessages(MessageReceivedEvent event) { + if(event.getChannel().equals(cli.getChannel())) { + if(event.getAuthor().equals(cli.getAuthor())) { + for (CLASS classs : CLASS.values()) { + if (event.getMessage().getContent().equalsIgnoreCase(classs.getName())) { + Main.getLyokoWarriors().add(new LyokoWarrior(event.getAuthor(), classs, 1, 0, 0, 0, 0, 0,0)); + Main.getDbManager().createLW(event.getAuthor().getLongID(), classs.getName()); + message.edit("Your LyokoWarrior has been registered successfully!"); + Main.getObjectManager().removeCLW(this); + cli.getClient().getDispatcher().unregisterListener(this); + future.cancel(true); + try { + event.getMessage().delete(); + } catch (Exception e) {} + } + } + } + } + } + + private void start() { + ScheduledExecutorService service = Executors.newScheduledThreadPool(1); + future = service.scheduleAtFixedRate(() -> { + message.edit("LyokoWarrior creation cancelled, user took longer than 60 seconds"); + Main.getObjectManager().removeCLW(this); + cli.getClient().getDispatcher().unregisterListener(this); + future.cancel(false); + },1,1, TimeUnit.MINUTES); + } + public IUser getUser() {return user;} +} diff --git a/src/main/java/mulley/sky/lyokobot/Logic/Runnables/ResetLyokoWarrior.java b/src/main/java/mulley/sky/lyokobot/Logic/Runnables/ResetLyokoWarrior.java new file mode 100644 index 0000000..6811ce8 --- /dev/null +++ b/src/main/java/mulley/sky/lyokobot/Logic/Runnables/ResetLyokoWarrior.java @@ -0,0 +1,66 @@ +package mulley.sky.lyokobot.Logic.Runnables; + +import mulley.sky.lyokobot.Commands.Commands.LWManagement.Reset; +import mulley.sky.lyokobot.Logic.Objects.LyokoWarrior; +import mulley.sky.lyokobot.Main; +import mulley.sky.lyokobot.ObjectManager; +import sx.blah.discord.api.IDiscordClient; +import sx.blah.discord.api.events.EventSubscriber; +import sx.blah.discord.handle.impl.events.guild.channel.message.MessageReceivedEvent; +import sx.blah.discord.handle.obj.IChannel; +import sx.blah.discord.handle.obj.IMessage; +import sx.blah.discord.handle.obj.IUser; + +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.ScheduledFuture; +import java.util.concurrent.TimeUnit; + +public class ResetLyokoWarrior { + private LyokoWarrior warrior; + private IChannel channel; + private IDiscordClient client; + private IMessage message; + private ScheduledFuture future; + public ResetLyokoWarrior(LyokoWarrior warrior,IChannel channel, IDiscordClient client, IMessage message) { + this.warrior = warrior; + this.channel = channel; + this.client = client; + this.message = message; + client.getDispatcher().registerListener(this); + start(); + } + + @EventSubscriber + public void gotConfirmedMessage(MessageReceivedEvent event) { + if(event.getAuthor().equals(warrior.getUser())) { + if(event.getChannel().equals(channel)) { + if(event.getMessage().getContent().equalsIgnoreCase("confirm")) { + try { + event.getMessage().delete(); + } catch (Exception e) {} + message.edit("LyokoWarrior Reset"); + Main.getDbManager().deleteLyokoWarrior(event.getAuthor().getLongID()); + Main.getLyokoWarriors().remove(warrior); + client.getDispatcher().unregisterListener(this); + Main.getObjectManager().removeRLW(this); + future.cancel(true); + } + } + } + } + + private void start() { + ScheduledExecutorService service = Executors.newScheduledThreadPool(1); + future = service.scheduleAtFixedRate(() -> { + message.edit("LyokoWarrior reset cancelled, user took longer than 60 seconds"); + Main.getObjectManager().removeRLW(this); + client.getDispatcher().unregisterListener(this); + future.cancel(false); + },1,1, TimeUnit.MINUTES); + } + + public IUser getUser() { + return warrior.getUser(); + } +} diff --git a/src/main/java/mulley/sky/lyokobot/Main.java b/src/main/java/mulley/sky/lyokobot/Main.java new file mode 100644 index 0000000..7a50635 --- /dev/null +++ b/src/main/java/mulley/sky/lyokobot/Main.java @@ -0,0 +1,68 @@ +package mulley.sky.lyokobot; + +import mulley.sky.lyokobot.Commands.MessageListener; +import mulley.sky.lyokobot.Logic.Objects.Guild; +import mulley.sky.lyokobot.Logic.Objects.LyokoWarrior; +import sx.blah.discord.api.ClientBuilder; +import sx.blah.discord.api.IDiscordClient; +import sx.blah.discord.handle.obj.ActivityType; +import sx.blah.discord.handle.obj.IGuild; +import sx.blah.discord.handle.obj.StatusType; + +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; + +public class Main { + private static DBManager dbManager; + private static List registeredGuilds; + private static List lyokoWarriors; + private static List virtualizedLyokoWarriors = new ArrayList<>(); + private static IDiscordClient cli; + private static ObjectManager objectManager = new ObjectManager(); + public static void main(String[] args) { + System.out.println("Bootup Stage 1 - Discord Connection Starting"); + String token = "TOKENGOESHERE"; + cli = new ClientBuilder() + .withToken(token) + .build(); + cli.getDispatcher().registerListener(new MessageListener()); + cli.login(); + System.out.println("Bootup Stage 1 - Complete"); + System.out.println("Bootup Stage 2 - SQL Connection"); + dbManager = new DBManager(cli); + System.out.println("Bootup Stage 2 - Complete"); + try { + Thread.sleep(3000); + }catch (Exception e){} + System.out.println("Bootup Stage 3 - Object Registration"); + registeredGuilds = dbManager.getGuilds(); + System.out.println("Guilds in DB: "+registeredGuilds.size()+" Guilds Existing: "+cli.getGuilds().size()); + for(IGuild guild : cli.getGuilds()) { + boolean found = false; + for(Guild regGuild : registeredGuilds) { + if (guild.equals(regGuild.getGuild())) { + found = true; + } + } + if(!found) { + dbManager.createGuild(guild.getLongID()); + registeredGuilds.add(new Guild(guild,"lb!",cli,"")); + } + } + lyokoWarriors = dbManager.getPlayers(); + System.out.println("Players in DB: "+lyokoWarriors.size()); + System.out.println("Bootup Stage 3 - Complete"); + cli.getDispatcher().registerListener(new Listener()); + new TimeManager().startRunning(); + } + + public static List getRegisteredGuilds() {return registeredGuilds;} + public static List getLyokoWarriors() {return lyokoWarriors;} + public static DBManager getDbManager() {return dbManager;} + public static IDiscordClient getDiscordClient() {return cli;} + public static ObjectManager getObjectManager() {return objectManager;} + public static List getVirtualizedLyokoWarriors() {return virtualizedLyokoWarriors;} +} diff --git a/src/main/java/mulley/sky/lyokobot/ObjectManager.java b/src/main/java/mulley/sky/lyokobot/ObjectManager.java new file mode 100644 index 0000000..89bb437 --- /dev/null +++ b/src/main/java/mulley/sky/lyokobot/ObjectManager.java @@ -0,0 +1,82 @@ +package mulley.sky.lyokobot; + +import mulley.sky.lyokobot.Logic.Objects.Guild; +import mulley.sky.lyokobot.Logic.Objects.LyokoWarrior; +import mulley.sky.lyokobot.Logic.Runnables.AttackRunnable; +import mulley.sky.lyokobot.Logic.Runnables.CreateLyokoWarrior; +import mulley.sky.lyokobot.Logic.Runnables.ResetLyokoWarrior; +import sx.blah.discord.api.IDiscordClient; +import sx.blah.discord.handle.obj.ActivityType; +import sx.blah.discord.handle.obj.IUser; +import sx.blah.discord.handle.obj.StatusType; + +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; + +public class ObjectManager { + private List CLW = new ArrayList<>(); + private List RLW = new ArrayList<>(); + private List AR = new ArrayList<>(); + public ObjectManager(){} + + public static Guild getGuild(long id) { + for(Guild iguild : Main.getRegisteredGuilds()) { + if(iguild.getGuild().getLongID()==id) { return iguild;} + } + return null; + } + + public static boolean isLyokoWarrior(IUser user) { + for (LyokoWarrior lyokoWarrior : Main.getLyokoWarriors()) { + if (user.equals(lyokoWarrior.getUser())) { + return true; + } + } + return false; + } + + public static LyokoWarrior getLyokoWarrior(IUser user) { + for( LyokoWarrior lyokoWarrior : Main.getLyokoWarriors()) { + if(user.equals(lyokoWarrior.getUser())) { + return lyokoWarrior; + } + } + return null; + } + + public boolean isMakingLW(IUser user) { + for(CreateLyokoWarrior clw : CLW) { + if(clw.getUser().equals(user)) { + return true; + } + } + return false; + } + + public void addCLW(CreateLyokoWarrior lw) { + CLW.add(lw); + } + public void removeCLW(CreateLyokoWarrior lw) { + CLW.remove(lw); + } + + public boolean isResettingLW(IUser user) { + for(ResetLyokoWarrior rlw : RLW) { + if(rlw.getUser().equals(user)) { + return true; + } + } + return false; + } + + public void addRLW(ResetLyokoWarrior lw) { + RLW.add(lw); + } + + public void removeRLW(ResetLyokoWarrior lw) { + RLW.remove(lw); + } +} diff --git a/src/main/java/mulley/sky/lyokobot/TimeManager.java b/src/main/java/mulley/sky/lyokobot/TimeManager.java new file mode 100644 index 0000000..5a7b295 --- /dev/null +++ b/src/main/java/mulley/sky/lyokobot/TimeManager.java @@ -0,0 +1,38 @@ +package mulley.sky.lyokobot; + +import mulley.sky.lyokobot.Logic.Objects.LyokoWarrior; +import mulley.sky.lyokobot.Logic.Runnables.AttackRunnable; +import sx.blah.discord.handle.obj.StatusType; + +import java.util.Random; +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; + +public class TimeManager { + private ScheduledExecutorService service = Executors.newScheduledThreadPool(1); + private Random random = new Random(); + public void startRunning() { + service.scheduleAtFixedRate(() -> { + for(LyokoWarrior warrior : Main.getVirtualizedLyokoWarriors()) { + if(!warrior.isAttacking()) { + if(warrior.recentlyAttackedToggle()) { + if(random.nextInt(2)+1==2) { + AttackRunnable runnable = new AttackRunnable(warrior); + runnable.start(); + warrior.startAttacking(runnable); + } + } + } + } + + for(LyokoWarrior warrior : Main.getLyokoWarriors()) { + if(!warrior.getVirtualized()) { + if (warrior.getHP() != 100) { + warrior.addHP(2); + } + } + } + },2,2, TimeUnit.MINUTES); + } +}