diff options
Diffstat (limited to 'src/main/java')
44 files changed, 2768 insertions, 0 deletions
diff --git a/src/main/java/net/tylermurphy/ken/Config.java b/src/main/java/net/tylermurphy/ken/Config.java new file mode 100644 index 0000000..c5a5991 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/Config.java @@ -0,0 +1,247 @@ +package net.tylermurphy.ken; + +import org.yaml.snakeyaml.Yaml; +import org.yaml.snakeyaml.error.YAMLException; + +import java.io.*; +import java.nio.charset.Charset; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +public class Config { + + private final File file; + private final Map<String, Object> config = new HashMap<>(); + private final Map<String, Object> defaultConfig = new HashMap<>(); + private final String defaultFilename; + + public static Config create(String filename) { + return new Config(filename, filename); + } + + public static Config create(String filename, String defaultFilename) { + return new Config(filename, defaultFilename); + } + + private Config(String filename, String defaultFilename) { + + File dataFolder = Ken.getInstance().getConfigFolder(); + + this.defaultFilename = defaultFilename; + this.file = new File(dataFolder, filename); + + if (!dataFolder.exists()) { + if (!dataFolder.mkdirs()) { + throw new RuntimeException("Failed to make directory: " + file.getPath()); + } + } + + if (!file.exists()) { + try{ + InputStream input = Ken.getInstance().getResource(defaultFilename); + if (input == null) { + throw new RuntimeException("Could not create input stream for "+defaultFilename); + } + Files.copy(input, file.toPath()); + input.close(); + } catch(IOException e) { + e.printStackTrace(); + } + } + + FileInputStream fileInputStream; + try { + fileInputStream = new FileInputStream(file); + } catch (FileNotFoundException e) { + throw new RuntimeException("Could not create inputstream for "+file.getPath()); + } + InputStreamReader reader = new InputStreamReader(fileInputStream, StandardCharsets.UTF_8); + Yaml yaml = new Yaml(); + Map<String, Object> temp = null; + try { + temp = yaml.load(reader); + } catch(YAMLException e) { + throw new RuntimeException("Invalid configuration in config file: "+file.getPath()); + } catch(Exception e) { + throw new RuntimeException("Could not access file: "+file.getPath()); + } + parseYAML(temp, this.config, ""); + + InputStream input = Ken.getInstance().getResource(defaultFilename); + if (input == null) { + throw new RuntimeException("Could not create input stream for "+defaultFilename); + } + InputStreamReader default_reader = new InputStreamReader(input, StandardCharsets.UTF_8); + try { + temp = yaml.load(default_reader); + } catch(YAMLException e) { + throw new RuntimeException("Invalid configuration in config file: "+file.getPath()); + } catch(Exception e) { + throw new RuntimeException("Could not access file: "+file.getPath()); + } + parseYAML(temp, this.defaultConfig, ""); + + try{ + fileInputStream.close(); + reader.close(); + default_reader.close(); + input.close(); + } catch (IOException e) { + throw new RuntimeException("Unable to finalize loading of config files."); + } + + } + + @SuppressWarnings({"rawtypes", "unchecked"}) + private void parseYAML(Map<String, Object> temp, Map<String, Object> target, String prefix){ + for(Map.Entry<String, Object> entry : temp.entrySet()) { + String path = entry.getKey(); + Object data = entry.getValue(); + if (data instanceof Map<?,?>) { + Map map = (Map) data; + parseYAML(map, target, path+"."); + } else { + target.put(prefix+path, data); + } + } + } + + public boolean contains(String path) { + return config.containsKey(path); + } + + private Object getValue(String path){ + if (!contains(path)) { + return defaultConfig.get(path); + } else { + return config.get(path); + } + } + + public Integer getInt(String path) { + Object v = getValue(path); + if(v instanceof Integer) + return (Integer)v; + else + return 0; + } + + public Double getDouble(String path) { + Object v = getValue(path); + if(v instanceof Double) + return (Double) v; + else + return 0.0; + } + + public Float getFloat(String path) { + Object v = getValue(path); + if(v instanceof Float) + return (Float)v; + else + return 0.0f; + } + + public Long getLong(String path) { + Object v = getValue(path); + if(v instanceof Long) + return (Long)v; + else + return 0L; + } + + public String getString(String path) { + Object v = getValue(path); + if(v instanceof String) + return (String)v; + else + return null; + } + + public Boolean getBoolean(String path) { + Object v = getValue(path); + if(v instanceof Boolean) + return (Boolean) v; + else + return false; + } + + public void reset(String path) { + config.put(path, defaultConfig.get(path)); + } + + public void set(String path, Object value) { + config.put(path, value); + } + + public void saveConfig() { + try { + InputStream is = Ken.getInstance().getResource(defaultFilename); + if (is == null) { + throw new RuntimeException("Could not create input stream for "+defaultFilename); + } + StringBuilder textBuilder = new StringBuilder(new String("".getBytes(), StandardCharsets.UTF_8)); + Reader reader = new BufferedReader(new InputStreamReader(is, Charset.forName(StandardCharsets.UTF_8.name()))); + int c; + while((c = reader.read()) != -1) { + textBuilder.append((char) c); + } + String yamlString = new String(textBuilder.toString().getBytes(), StandardCharsets.UTF_8); + Map<String, Object> temp = new HashMap<>(this.config); + for(Map.Entry<String, Object> entry: temp.entrySet()) { + if (entry.getValue() instanceof Integer || entry.getValue() instanceof Double || entry.getValue() instanceof String || entry.getValue() instanceof Boolean || entry.getValue() instanceof List) { + String[] parts = entry.getKey().split("\\."); + int index = 0; + int i = 0; + for(String part : parts) { + if (i == 0) { + index = yamlString.indexOf(part+":", index); + } else { + index = yamlString.indexOf(" " + part+":", index); + index++; + } + i++; + if (index == -1) break; + } + if (index < 10) continue; + int start = yamlString.indexOf(' ', index); + int end = yamlString.indexOf('\n', index); + if (end == -1) end = yamlString.length(); + StringBuilder replace = new StringBuilder(new String("".getBytes(), StandardCharsets.UTF_8)); + if (entry.getValue() instanceof List) { + if (((List<?>) entry.getValue()).isEmpty()) { + replace.append("[]"); + } else { + replace.append("["); + for (Object o : (List<?>) entry.getValue()) { + replace.append(o.toString()).append(", "); + } + replace = new StringBuilder(replace.substring(0, replace.length() - 2)); + replace.append("]"); + } + } else { + replace.append(entry.getValue()); + } + if (entry.getValue() instanceof String) { + replace.append("\""); + replace.reverse(); + replace.append("\""); + replace.reverse(); + } + StringBuilder builder = new StringBuilder(yamlString); + builder.replace(start+1, end, replace.toString()); + yamlString = builder.toString(); + } + } + Writer fileWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), StandardCharsets.UTF_8)); + fileWriter.write(yamlString); + fileWriter.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + +}
\ No newline at end of file diff --git a/src/main/java/net/tylermurphy/ken/Ken.java b/src/main/java/net/tylermurphy/ken/Ken.java new file mode 100644 index 0000000..0481bb6 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/Ken.java @@ -0,0 +1,122 @@ +package net.tylermurphy.ken; + +import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport; +import com.google.api.client.json.jackson2.JacksonFactory; +import com.google.api.services.youtube.YouTube; +import net.dv8tion.jda.api.EmbedBuilder; +import net.dv8tion.jda.api.JDA; +import net.dv8tion.jda.api.JDABuilder; +import net.dv8tion.jda.api.entities.Activity; +import net.dv8tion.jda.api.entities.TextChannel; +import net.dv8tion.jda.api.entities.VoiceChannel; +import net.dv8tion.jda.api.hooks.ListenerAdapter; +import net.dv8tion.jda.api.requests.GatewayIntent; +import net.dv8tion.jda.api.utils.MemberCachePolicy; +import net.tylermurphy.ken.command.Responder; +import net.tylermurphy.ken.music.PlayerManager; +import org.jetbrains.annotations.NotNull; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.awt.Color; +import java.io.File; +import java.io.InputStream; +import java.lang.reflect.InvocationTargetException; + +public class Ken { + + private static Ken instance; + private final Config config; + private final Logger log; + private final JDA api; + private final PlayerManager playerManager; + private final YouTube youTube; + private final Responder responder; + + private Ken(){ + Ken.instance = this; + this.config = Config.create("config.yml"); + this.log = LoggerFactory.getLogger(Ken.class); + try { + api = JDABuilder.createDefault(config.getString("botToken")) + .setActivity(Activity.playing("Use "+config.getString("prefix")+"help")) + .setMemberCachePolicy(MemberCachePolicy.ALL) + .enableIntents(GatewayIntent.GUILD_MEMBERS) + .build() + .awaitReady(); + } catch (Exception e) { + log.error(e.getMessage()); + throw new RuntimeException("Unable to Initialize JDA"); + } + this.responder = new Responder(api); + try{ + responder.registerCommands(); + } catch (InvocationTargetException | InstantiationException | IllegalAccessException | NoSuchMethodException e) { + log.error(e.getMessage()); + throw new RuntimeException("Unable to register commands"); + } + this.addEventListener(responder); + this.playerManager = new PlayerManager(); + try { + youTube = new YouTube.Builder( + GoogleNetHttpTransport.newTrustedTransport(), + JacksonFactory.getDefaultInstance(), + null + ).setApplicationName("Ken").build(); + } catch(Exception e) { + log.error(e.getMessage()); + throw new RuntimeException("Unable to connect with YouTube API"); + } + } + + public static Ken getInstance(){ + return instance; + } + + public File getConfigFolder() { + return new File("config"); + } + + public InputStream getResource(@NotNull String filename) { + return getClass().getClassLoader().getResourceAsStream(filename); + } + + public Config getConfig(){ + return config; + } + + public Logger getLogger(){ + return log; + } + + public PlayerManager getPlayerManager() { return playerManager; } + + public YouTube getYouTube() { return youTube; } + + public EmbedBuilder getDefaultEmbed() { + EmbedBuilder builder = new EmbedBuilder(); + builder.setColor(new Color( + config.getInt("colors.r"), + config.getInt("colors.g"), + config.getInt("colors.b") + )); + return builder; + } + + public TextChannel getTextChannel(long id) { + return api.getTextChannelById(id); + } + + public VoiceChannel getVoiceChannel(long id) { + return api.getVoiceChannelById(id); + } + + public void addEventListener(ListenerAdapter listener){ + api.addEventListener(listener); + } + + public static void main(String[] args){ + new Ken(); + } + +} diff --git a/src/main/java/net/tylermurphy/ken/api/E621API.java b/src/main/java/net/tylermurphy/ken/api/E621API.java new file mode 100644 index 0000000..06aa02e --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/api/E621API.java @@ -0,0 +1,28 @@ +package net.tylermurphy.ken.api; + +import net.tylermurphy.ken.api.wrapper.HTTPMethod; +import net.tylermurphy.ken.api.wrapper.JsonRequest; +import org.json.JSONArray; +import org.json.JSONException; +import org.json.JSONObject; + +public class E621API { + + public static String request(String query){ + JSONObject json = (JSONObject) new JsonRequest() + .setURL("https://e621.net/posts.json?tags="+query) + .setType(HTTPMethod.GET) + .request(); + try { + System.out.println(json.toString()); + JSONArray results = json.getJSONArray("posts"); + int choice = (int) (Math.random()*results.length()-1); + JSONObject post = (JSONObject) results.get(choice); + JSONObject file = post.getJSONObject("file"); + return file.getString("url"); + } catch (JSONException e) { + return null; + } + } + +} diff --git a/src/main/java/net/tylermurphy/ken/api/Rule34API.java b/src/main/java/net/tylermurphy/ken/api/Rule34API.java new file mode 100644 index 0000000..3c78522 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/api/Rule34API.java @@ -0,0 +1,30 @@ +package net.tylermurphy.ken.api; + +import net.tylermurphy.ken.api.wrapper.HTTPMethod; +import net.tylermurphy.ken.api.wrapper.XmlRequest; +import org.json.JSONException; +import org.w3c.dom.Document; +import org.w3c.dom.Element; +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +public class Rule34API { + + public static String request(String query){ + Document doc = (Document) new XmlRequest() + .setURL("https://rule34.xxx/index.php?page=dapi&s=post&q=index&tags="+ query) + .setType(HTTPMethod.GET) + .request(); + try { + NodeList nList = doc.getElementsByTagName("post"); + int choice = (int) (Math.random()*nList.getLength()-1); + if(choice < 0) return null; + Node node = nList.item(choice); + Element element = (Element) node; + return element.getAttribute("file_url"); + } catch (JSONException e) { + return null; + } + } + +} diff --git a/src/main/java/net/tylermurphy/ken/api/wrapper/HTTPMethod.java b/src/main/java/net/tylermurphy/ken/api/wrapper/HTTPMethod.java new file mode 100644 index 0000000..094a8c6 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/api/wrapper/HTTPMethod.java @@ -0,0 +1,10 @@ +package net.tylermurphy.ken.api.wrapper; + +public enum HTTPMethod { + + GET, + POST, + PUT, + DELETE + +} diff --git a/src/main/java/net/tylermurphy/ken/api/wrapper/JsonRequest.java b/src/main/java/net/tylermurphy/ken/api/wrapper/JsonRequest.java new file mode 100644 index 0000000..f95d23f --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/api/wrapper/JsonRequest.java @@ -0,0 +1,38 @@ +package net.tylermurphy.ken.api.wrapper; + +import org.json.JSONException; +import org.json.JSONObject; + +import java.io.*; +import java.net.HttpURLConnection; +import java.nio.charset.StandardCharsets; + +public class JsonRequest extends Request { + + public Object request() { + super.addHeaders("Content-type","application/json"); + HttpURLConnection connection = super.getConnection(); + try { + return parseJson(connection.getInputStream()); + } catch (Exception ignored) {} finally { + if (connection != null) { + connection.disconnect(); + } + } + return null; + } + + public static JSONObject parseJson(InputStream is) throws JSONException { + char[] buffer = new char[1024 * 4]; + int n; + try (BufferedInputStream stream = new BufferedInputStream(is); InputStreamReader reader = new InputStreamReader(stream, StandardCharsets.UTF_8)) { + StringWriter writer = new StringWriter(); + while (-1 != (n = reader.read(buffer))) { + writer.write(buffer, 0, n); + } + return new JSONObject(writer.toString()); + } catch (IOException ignored) {} + return new JSONObject(""); + } + +} diff --git a/src/main/java/net/tylermurphy/ken/api/wrapper/Request.java b/src/main/java/net/tylermurphy/ken/api/wrapper/Request.java new file mode 100644 index 0000000..a5b8e4d --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/api/wrapper/Request.java @@ -0,0 +1,76 @@ +package net.tylermurphy.ken.api.wrapper; + +import java.io.OutputStream; +import java.net.HttpURLConnection; +import java.net.URL; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public abstract class Request { + + private HTTPMethod method; + private String url; + private String body; + private List<String> headers; + + protected Request(){ + this.method = HTTPMethod.GET; + this.url = null; + this.body = null; + this.headers = new ArrayList<>(); + } + + public Request setType(HTTPMethod method){ + this.method = method; + return this; + } + + public Request setURL(String url){ + this.url = url; + return this; + } + + public Request setBody(String body){ + this.body = body; + return this; + } + + public Request addHeaders(String... headers){ + this.headers.addAll(Arrays.asList(headers)); + return this; + } + + public abstract Object request(); + + protected HttpURLConnection getConnection() { + HttpURLConnection connection = null; + try { + connection = (HttpURLConnection) new URL(url).openConnection(); + connection.setDoInput(true); + connection.setDoOutput(true); + connection.setRequestMethod(method.toString()); + connection.addRequestProperty("User-Agent", "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:25.0) Gecko/20100101 Firefox/25.0"); + + for(int i=0; i+1<headers.size(); i+=2) { + connection.addRequestProperty(headers.get(i), headers.get(i+1)); + } + + if(body != null) { + try(OutputStream os = connection.getOutputStream()) { + byte[] input = body.getBytes("utf-8"); + os.write(input, 0, input.length); + } catch (Exception e) { + throw new Exception("Error writing body to HTTP connection.\n"+e.getMessage()); + } + } + + return connection; + + } catch (Exception e) { + e.printStackTrace(); + } + return null; + } + +} diff --git a/src/main/java/net/tylermurphy/ken/api/wrapper/XmlRequest.java b/src/main/java/net/tylermurphy/ken/api/wrapper/XmlRequest.java new file mode 100644 index 0000000..80a755a --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/api/wrapper/XmlRequest.java @@ -0,0 +1,40 @@ +package net.tylermurphy.ken.api.wrapper; + +import org.w3c.dom.Document; +import org.xml.sax.SAXException; + +import javax.xml.parsers.DocumentBuilder; +import javax.xml.parsers.DocumentBuilderFactory; +import javax.xml.parsers.ParserConfigurationException; +import java.io.BufferedInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.net.HttpURLConnection; + +public class XmlRequest extends Request { + + public Document request() { + super.addHeaders("Content-type","text/xml"); + HttpURLConnection connection = super.getConnection(); + try { + return parseXML(connection.getInputStream()); + } catch (Exception ignored) {} finally { + if (connection != null) { + connection.disconnect(); + } + } + return null; + } + + private static Document parseXML(InputStream is) throws ParserConfigurationException, SAXException { + try (BufferedInputStream stream = new BufferedInputStream(is)) { + DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance(); + DocumentBuilder dBuilder = dbFactory.newDocumentBuilder(); + Document doc = dBuilder.parse(stream); + doc.getDocumentElement().normalize(); + return doc; + } catch (IOException ignored) {} + return null; + } + +} diff --git a/src/main/java/net/tylermurphy/ken/command/ButtonCallback.java b/src/main/java/net/tylermurphy/ken/command/ButtonCallback.java new file mode 100644 index 0000000..7d96dac --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/command/ButtonCallback.java @@ -0,0 +1,12 @@ +package net.tylermurphy.ken.command; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Target(ElementType.METHOD) +@Retention(RetentionPolicy.RUNTIME) +public @interface ButtonCallback { + String name(); +} diff --git a/src/main/java/net/tylermurphy/ken/command/Command.java b/src/main/java/net/tylermurphy/ken/command/Command.java new file mode 100644 index 0000000..0b961d5 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/command/Command.java @@ -0,0 +1,13 @@ +package net.tylermurphy.ken.command; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Target(ElementType.METHOD) +@Retention(RetentionPolicy.RUNTIME) +public @interface Command { + String name(); + String description(); +} diff --git a/src/main/java/net/tylermurphy/ken/command/Container.java b/src/main/java/net/tylermurphy/ken/command/Container.java new file mode 100644 index 0000000..55e05ed --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/command/Container.java @@ -0,0 +1,49 @@ +package net.tylermurphy.ken.command; + +import net.dv8tion.jda.api.Permission; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +public class Container { + + private final Method method; + private final Object handle; + + private Method buttonCallback; + private Permission permission; + + public Container(Method method) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException { + this.method = method; + this.handle = method.getDeclaringClass().getConstructor().newInstance(); + } + + public Container setButtonCallback(Method method){ + this.buttonCallback = method; + return this; + } + + public Container setPermission(Permission permission){ + this.permission = permission; + return this; + } + + public Method getMethod(){ + return method; + } + + public Object getHandle(){ + return handle; + } + + public Method getButtonCallback(){ + return buttonCallback; + } + + public Permission getPermission(){ + return permission; + } + + + +} diff --git a/src/main/java/net/tylermurphy/ken/command/Option.java b/src/main/java/net/tylermurphy/ken/command/Option.java new file mode 100644 index 0000000..09ae9e9 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/command/Option.java @@ -0,0 +1,16 @@ +package net.tylermurphy.ken.command; + +import net.dv8tion.jda.api.interactions.commands.OptionType; + +import java.lang.annotation.*; + +@Target(ElementType.METHOD) +@Retention(RetentionPolicy.RUNTIME) +@Repeatable(Options.class) +public @interface Option { + OptionType type(); + String name(); + String description(); + boolean required() default false; +} + diff --git a/src/main/java/net/tylermurphy/ken/command/Options.java b/src/main/java/net/tylermurphy/ken/command/Options.java new file mode 100644 index 0000000..a5ec6fc --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/command/Options.java @@ -0,0 +1,12 @@ +package net.tylermurphy.ken.command; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Target(ElementType.METHOD) +@Retention(RetentionPolicy.RUNTIME) +public @interface Options { + Option[] value(); +} diff --git a/src/main/java/net/tylermurphy/ken/command/Requirement.java b/src/main/java/net/tylermurphy/ken/command/Requirement.java new file mode 100644 index 0000000..fd59d29 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/command/Requirement.java @@ -0,0 +1,12 @@ +package net.tylermurphy.ken.command; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Target(ElementType.METHOD) +@Retention(RetentionPolicy.RUNTIME) +public @interface Requirement { + net.dv8tion.jda.api.Permission value(); +} diff --git a/src/main/java/net/tylermurphy/ken/command/Responder.java b/src/main/java/net/tylermurphy/ken/command/Responder.java new file mode 100644 index 0000000..2a00ee0 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/command/Responder.java @@ -0,0 +1,230 @@ +package net.tylermurphy.ken.command; + +import net.dv8tion.jda.api.EmbedBuilder; +import net.dv8tion.jda.api.JDA; +import net.dv8tion.jda.api.entities.Guild; +import net.dv8tion.jda.api.entities.GuildMessageChannel; +import net.dv8tion.jda.api.entities.Member; +import net.dv8tion.jda.api.entities.Message; +import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent; +import net.dv8tion.jda.api.events.interaction.component.ButtonInteractionEvent; +import net.dv8tion.jda.api.hooks.ListenerAdapter; +import net.dv8tion.jda.api.interactions.commands.build.Commands; +import net.dv8tion.jda.api.interactions.commands.build.SlashCommandData; +import net.dv8tion.jda.api.interactions.components.buttons.Button; +import net.dv8tion.jda.api.requests.restaction.WebhookMessageAction; +import net.tylermurphy.ken.Ken; +import org.reflections.Reflections; +import org.reflections.scanners.MethodAnnotationsScanner; + +import java.awt.*; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.*; +import java.util.List; + +public class Responder extends ListenerAdapter { + + private final Map<String, Container> register; + private final JDA api; + + public Responder(JDA api) { + this.register = new HashMap<>(); + this.api = api; + } + + public void registerCommands() throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException { + + // Reset register + register.clear(); + + // Get all Methods that use the @Command annotation + for (Method method : new Reflections("net.tylermurphy.ken.command", new MethodAnnotationsScanner()).getMethodsAnnotatedWith(Command.class)) { + if(method.getReturnType() != Response.class) continue; + // Register Main Command Information If Not Already Registered; + Command command = method.getAnnotation(Command.class); + if (register.containsKey(command.name())) continue; + // Create Command Container + Container container = new Container(method); + // Check For Permissions + if (method.isAnnotationPresent(Requirement.class)) + container.setPermission(method.getAnnotation(Requirement.class).value()); + // Add Command To Register + register.put(command.name(), container); + // Create Slash Command Data + SlashCommandData data = Commands.slash(command.name(), command.description()); + // Add Options to Slash Command Data if @Option is used + if(method.isAnnotationPresent(Options.class)) { + Option[] options = method.getAnnotation(Options.class).value(); + for(Option option : options){ + data = data.addOption(option.type(), option.name(), option.description(), option.required()); + } + } else if (method.isAnnotationPresent(Option.class)) { + Option option = method.getAnnotation(Option.class); + data = data.addOption(option.type(), option.name(), option.description(), option.required()); + } + api.upsertCommand(data).queue(); + } + + // Get all Methods that use the @ButtonCallback annotation + for (Method method : new Reflections("net.tylermurphy.ken.command", new MethodAnnotationsScanner()).getMethodsAnnotatedWith(ButtonCallback.class)) { + if(method.getReturnType() != Response.class) continue; + ButtonCallback callback = method.getAnnotation(ButtonCallback.class); + if(!register.containsKey(callback.name())) continue; + Container container = register.get(callback.name()); + container.setButtonCallback(method); + register.put(callback.name(), container); + } + } + + public void onSlashCommandInteraction(SlashCommandInteractionEvent event) { + + // Make sure the Bot can Talk + if(!event.getChannel().canTalk()) return; + + // Bots are not allowed to use commands + if (event.getMember() == null || event.getUser().isBot()) return; + + // Get Command Information From Invoke + final String invoke = event.getName().toLowerCase(Locale.ROOT); + if(!register.containsKey(invoke)) return; + Container container = register.get(invoke); + Method method = container.getMethod(); + + // Check Permissions + if(!event.getMember().hasPermission(container.getPermission())) { + EmbedBuilder builder = Ken.getInstance().getDefaultEmbed() + .appendDescription(":x: **Invalid Permissions**\n") + .appendDescription("You require the "+ container.getPermission().toString()+" permission to use this command."); + event.getHook().sendMessageEmbeds(builder.build()).queue(); + return; + } + + // Defer Reply + event.deferReply().queue(); + + // Get slash command options if there are any + List<Object> args = new ArrayList<>(); + event.getOptions().forEach(option -> { + switch (option.getType()){ + case STRING: args.add(option.getAsString()); break; + case INTEGER: args.add(option.getAsInt()); break; + case BOOLEAN: args.add(option.getAsBoolean()); break; + case USER: args.add(option.getAsMember()); break; + case CHANNEL: args.add(option.getAsChannel()); break; + case ROLE: args.add(option.getAsRole()); break; + case MENTIONABLE: args.add(option.getAsMentionable()); break; + default: break; + } + }); + + // Get parameters to send to Method + Object[] parameters = new Object[method.getParameterTypes().length]; + Class<?>[] types = method.getParameterTypes(); + for(int i = 0; i < types.length; i++){ + if(types[i] == Member.class){ + parameters[i] = event.getMember(); + } else if(types[i] == GuildMessageChannel.class){ + parameters[i] = event.getGuildChannel(); + } else if(types[i] == Guild.class) { + parameters[i] = event.getGuild(); + } else if(types[i] == List.class) { + parameters[i] = args; + } else { + parameters[i] = null; + } + } + + // Invoke Method and Respond to User + try { + Object temp = method.invoke(container.getHandle(), parameters); + Response response = (Response)temp; + if(response.error()) { + EmbedBuilder builder = Ken.getInstance().getDefaultEmbed() + .setColor(Color.RED) + .setTitle(":x: **Error**") + .setDescription(response.getMessage()); + event.getHook().sendMessageEmbeds(builder.build()).queue(); + } else { + WebhookMessageAction<?> message; + if(response.hasEmbed()) { + message = event.getHook().sendMessageEmbeds(response.getEmbeds()); + } else { + message = event.getHook().sendMessage(response.getMessage()); + } + if(response.hasButtons()) message = message.addActionRow(response.getButtons()); + if(response.hasFile()) message = message.addFile(response.getFile()); + message.queue(); + } + } catch (Exception e) { + EmbedBuilder builder = Ken.getInstance().getDefaultEmbed() + .setColor(Color.RED) + .setTitle(":x: **Error**") + .setDescription(e.getMessage()); + event.getHook().sendMessageEmbeds(builder.build()).queue(); + e.printStackTrace(); + } + } + + public void onButtonInteraction(ButtonInteractionEvent event) { + + // Make sure the Bot can Talk + if(!event.getChannel().canTalk()) return; + // Bots are not allowed to use commands + if (event.getMember() == null || event.getUser().isBot()) return; + + // Get Command Information From Invoke + final String invoke = event.getComponentId().toLowerCase(Locale.ROOT).split("_")[0]; + if(!register.containsKey(invoke)) return; + Container container = register.get(invoke); + Method method = container.getButtonCallback(); + + // Defer Reply + event.deferEdit().queue(); + + // Get parameters to send to Method + Object[] parameters = new Object[method.getParameterTypes().length]; + Class<?>[] types = method.getParameterTypes(); + for(int i = 0; i < types.length; i++){ + if(types[i] == Member.class){ + parameters[i] = event.getMember(); + } else if(types[i] == GuildMessageChannel.class){ + parameters[i] = event.getGuildChannel(); + } else if(types[i] == Guild.class) { + parameters[i] = event.getGuild(); + } else if(types[i] == Button.class) { + parameters[i] = event.getButton(); + } else if(types[i] == Message.class) { + parameters[i] = event.getMessage(); + } else if(types[i] == String.class) { + parameters[i] = event.getComponentId().substring(invoke.length()+1); + } else { + parameters[i] = null; + } + } + + // Invoke Method and Respond to User + try { + Object temp = method.invoke(container.getHandle(), parameters); + Response response = (Response) temp; + if(response.error()) { + EmbedBuilder builder = Ken.getInstance().getDefaultEmbed() + .setColor(Color.RED) + .setTitle(":x: **Error**") + .setDescription(response.getMessage()); + event.getHook().sendMessageEmbeds(builder.build()).queue(); + } else { + if(response.hasEmbed()) { + event.getHook().editOriginalEmbeds(response.getEmbeds()).queue(); + } else { + event.getHook().editOriginal(response.getMessage()).queue(); + } + } + } catch (Exception e) { + event.getHook().sendMessage(e.getMessage()).queue(); + e.printStackTrace(); + } + + } + +} diff --git a/src/main/java/net/tylermurphy/ken/command/Response.java b/src/main/java/net/tylermurphy/ken/command/Response.java new file mode 100644 index 0000000..9b87905 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/command/Response.java @@ -0,0 +1,89 @@ +package net.tylermurphy.ken.command; + +import net.dv8tion.jda.api.entities.MessageEmbed; +import net.dv8tion.jda.api.interactions.components.buttons.Button; + +import java.io.File; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class Response { + + private final String message; + private final String type; + private final MessageEmbed[] embeds; + private final List<Button> buttons; + private final File file; + + private Response(String type, String message, File file, MessageEmbed... embed){ + this.type = type; + this.message = message; + this.embeds = embed; + this.file = file; + this.buttons = new ArrayList<>(); + } + + public static Response error(String message){ + return new Response("error", message, null, null); + } + + public static Response success(String message){ + return new Response("success", message, null, null); + } + + public static Response success(String message, File file){ + return new Response("success", message, file, null); + } + + public static Response success(MessageEmbed... embed){ + return new Response("success", "", null, embed); + } + + public Response addPrimaryButton(String callback, String id, String label){ + buttons.add(Button.primary(callback + "_" + id ,label)); + return this; + } + + public Response addSecondaryButton(String callback, String id, String label){ + buttons.add(Button.secondary(callback + "_" + id ,label)); + return this; + } + + public Response addSuccessButton(String callback, String id, String label){ + buttons.add(Button.success(callback + "_" + id ,label)); + return this; + } + + public Response addDangerButton(String callback, String id, String label){ + buttons.add(Button.danger(callback + "_" + id ,label)); + return this; + } + + public boolean error(){ + return type.equals("error"); + } + + public boolean hasEmbed() { return embeds != null; } + + public boolean hasFile() { return file != null; } + + public boolean hasButtons() { return !buttons.isEmpty(); } + + public Button[] getButtons() { + Button[] arr = new Button[buttons.size()]; + arr = buttons.toArray(arr); + return arr; + } + + public File getFile(){ + return file; + } + + public String getMessage(){ + return message; + } + + public List<MessageEmbed> getEmbeds() { return Arrays.asList(embeds); } + +} diff --git a/src/main/java/net/tylermurphy/ken/command/fun/Dice.java b/src/main/java/net/tylermurphy/ken/command/fun/Dice.java new file mode 100644 index 0000000..8bce8bf --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/command/fun/Dice.java @@ -0,0 +1,59 @@ +package net.tylermurphy.ken.command.fun; + +import net.dv8tion.jda.api.EmbedBuilder; +import net.dv8tion.jda.api.entities.Member; +import net.dv8tion.jda.api.interactions.commands.OptionType; +import net.tylermurphy.ken.Ken; +import net.tylermurphy.ken.command.Command; +import net.tylermurphy.ken.command.Option; +import net.tylermurphy.ken.command.Response; + +import java.util.List; + +public class Dice { + + @Command(name="d6", description="Rolls a d6 die") + public Response d6(Member sender){ + return rollDice(6, sender); + } + + @Command(name="d8", description="Rolls a d8 die") + public Response d8(Member sender){ + return rollDice(8, sender); + } + + @Command(name="d12", description="Rolls a d12 die") + public Response d12(Member sender){ + return rollDice(12, sender); + } + + @Command(name="d20", description="Rolls a d20 die") + public Response d20(Member sender){ + return rollDice(20, sender); + } + + @Command(name="dice", description="Rolls a dice with set sides") + @Option(name="sides", description="Sides of dice you want to roll", type= OptionType.INTEGER, required=true) + public Response dice(Member sender, List<Object> args){ + int sides = (int) args.get(0); + if(sides < 1 || sides > 20) { + return Response.error("Sides must be between 1 and 20"); + } + return rollDice(sides, sender); + } + + private Response rollDice(int sides, Member sender){ + String sided = "d6"; + if(sides <= 6) sided = "d6"; + else if(sides <= 8) sided = "d8"; + else if(sides <= 12) sided = "d12"; + else if(sides <= 20) sided = "d20"; + int n = (int)(Math.random()*sides)+1; + String url = "https://cdn.tylermurphy.net/ken/"+sided+"_"+n+".png"; + EmbedBuilder builder = Ken.getInstance().getDefaultEmbed() + .setAuthor("d"+sides+" - Rolled a "+n, sender.getAvatarUrl()) + .setImage(url); + return Response.success(builder.build()); + } + +} diff --git a/src/main/java/net/tylermurphy/ken/command/fun/Eject.java b/src/main/java/net/tylermurphy/ken/command/fun/Eject.java new file mode 100644 index 0000000..48a5991 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/command/fun/Eject.java @@ -0,0 +1,23 @@ +package net.tylermurphy.ken.command.fun; + +import net.dv8tion.jda.api.entities.Member; +import net.dv8tion.jda.api.interactions.commands.OptionType; +import net.tylermurphy.ken.command.Command; +import net.tylermurphy.ken.command.Option; +import net.tylermurphy.ken.command.Response; +import net.tylermurphy.ken.image.GifFactory; + +import java.io.File; +import java.util.List; + +public class Eject { + + @Command(name="eject", description="Eject a fellow crewmate") + @Option(name="member", description="Server member to eject", type=OptionType.USER, required=true) + public Response execute(Member sender, List<Object> args){ + Member ejected = (Member) args.get(0); + File file = GifFactory.generateEjectGif(ejected.getUser()); + return Response.success(ejected.getNickname() +" was ejected by "+sender.getNickname(), file); + } + +} diff --git a/src/main/java/net/tylermurphy/ken/command/music/ForceSkip.java b/src/main/java/net/tylermurphy/ken/command/music/ForceSkip.java new file mode 100644 index 0000000..656e3e9 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/command/music/ForceSkip.java @@ -0,0 +1,47 @@ +package net.tylermurphy.ken.command.music; + +import com.sedmelluq.discord.lavaplayer.player.AudioPlayer; +import com.sedmelluq.discord.lavaplayer.track.AudioTrack; +import net.dv8tion.jda.api.entities.*; +import net.dv8tion.jda.api.managers.AudioManager; +import net.tylermurphy.ken.Ken; +import net.tylermurphy.ken.command.Command; +import net.tylermurphy.ken.command.Response; +import net.tylermurphy.ken.music.GuildMusicManager; +import net.tylermurphy.ken.music.MusicPermissions; +import net.tylermurphy.ken.music.PlayerManager; +import net.tylermurphy.ken.music.TrackScheduler; + +public class ForceSkip { + + @Command(name="forceskip", description="Force Skip a song track") + public Response execute(Member sender, Guild guild) { + PlayerManager playerManager = Ken.getInstance().getPlayerManager(); + GuildMusicManager musicManager = playerManager.getGuildMusicManager(guild); + TrackScheduler scheduler = musicManager.scheduler; + AudioPlayer player = musicManager.player; + AudioManager audioManager = guild.getAudioManager(); + AudioChannel audioChannel = audioManager.getConnectedChannel(); + AudioTrack track = player.getPlayingTrack(); + + if (track == null) { + return Response.error("Nothing is currently playing."); + } + + if(audioChannel == null) { + return Response.error("Im not connected to a voice channel."); + } + + if (!audioChannel.getMembers().contains(sender)) { + return Response.error("You have to be in the same voice channel as me to use this command"); + } + + if(!MusicPermissions.hasDJ(sender)) { + return Response.error("You must have the `DJ` role to do this."); + } + + scheduler.nextTrack(); + return Response.success(":arrow_right: Skipping the current track"); + } + +} diff --git a/src/main/java/net/tylermurphy/ken/command/music/Join.java b/src/main/java/net/tylermurphy/ken/command/music/Join.java new file mode 100644 index 0000000..217e049 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/command/music/Join.java @@ -0,0 +1,48 @@ +package net.tylermurphy.ken.command.music; + +import net.dv8tion.jda.api.Permission; +import net.dv8tion.jda.api.entities.*; +import net.dv8tion.jda.api.managers.AudioManager; +import net.tylermurphy.ken.Ken; +import net.tylermurphy.ken.command.Command; +import net.tylermurphy.ken.command.Response; +import net.tylermurphy.ken.music.GuildMusicManager; +import net.tylermurphy.ken.music.MusicPermissions; +import net.tylermurphy.ken.music.PlayerManager; + +public class Join { + + @Command(name="join", description="Make the bot join your audio channel") + public Response execute(Member sender, Guild guild) { + + AudioManager audioManager = guild.getAudioManager(); + boolean hasDJ = MusicPermissions.hasDJ(sender); + + if (audioManager.isConnected() && !hasDJ) { + return Response.error("I'm already connected to a channel"); + } + + GuildVoiceState memberVoiceState = sender.getVoiceState(); + + assert memberVoiceState != null; + if (!memberVoiceState.inAudioChannel()) { + return Response.error("Please join a voice channel first"); + } + + AudioChannel audioChannel = memberVoiceState.getChannel(); + Member selfMember = guild.getSelfMember(); + + assert audioChannel != null; + if (!selfMember.hasPermission(audioChannel, Permission.VOICE_CONNECT)) { + return Response.error("I am missing permission to join " +audioChannel); + } + + audioManager.openAudioConnection(audioChannel); + PlayerManager playerManager = Ken.getInstance().getPlayerManager(); + GuildMusicManager musicManager = playerManager.getGuildMusicManager(guild); + musicManager.autoLeaveManager.startTimeout(guild); + + return Response.success("Joining your voice channel"); + } + +} diff --git a/src/main/java/net/tylermurphy/ken/command/music/Leave.java b/src/main/java/net/tylermurphy/ken/command/music/Leave.java new file mode 100644 index 0000000..1f07901 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/command/music/Leave.java @@ -0,0 +1,37 @@ +package net.tylermurphy.ken.command.music; + +import net.dv8tion.jda.api.entities.AudioChannel; +import net.dv8tion.jda.api.entities.Guild; +import net.dv8tion.jda.api.entities.Member; +import net.dv8tion.jda.api.managers.AudioManager; +import net.tylermurphy.ken.command.Command; +import net.tylermurphy.ken.command.Response; +import net.tylermurphy.ken.music.MusicPermissions; + +public class Leave { + + @Command(name="leave", description="Leaves the voice channel") + public Response execute(Member sender, Guild guild) { + + AudioManager audioManager = guild.getAudioManager(); + + if (!audioManager.isConnected()) { + return Response.error("I'm not connected to a voice channel"); + } + + AudioChannel audioChannel = audioManager.getConnectedChannel(); + + assert audioChannel != null; + if (!audioChannel.getMembers().contains(sender)) { + return Response.error("You have to be in the same voice channel as me to use this command"); + } + + if(MusicPermissions.hasPermission(sender, audioChannel)) { + audioManager.closeAudioConnection(); + return Response.success("Disconnected from your channel"); + } else { + return Response.error("You must be the only person in the VC or have the `DJ` role to do this"); + } + + } +} diff --git a/src/main/java/net/tylermurphy/ken/command/music/Loop.java b/src/main/java/net/tylermurphy/ken/command/music/Loop.java new file mode 100644 index 0000000..65b31d3 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/command/music/Loop.java @@ -0,0 +1,49 @@ +package net.tylermurphy.ken.command.music; + +import com.sedmelluq.discord.lavaplayer.player.AudioPlayer; +import net.dv8tion.jda.api.entities.AudioChannel; +import net.dv8tion.jda.api.entities.Guild; +import net.dv8tion.jda.api.entities.Member; +import net.dv8tion.jda.api.managers.AudioManager; +import net.tylermurphy.ken.Ken; +import net.tylermurphy.ken.command.Command; +import net.tylermurphy.ken.command.Response; +import net.tylermurphy.ken.music.GuildMusicManager; +import net.tylermurphy.ken.music.MusicPermissions; +import net.tylermurphy.ken.music.PlayerManager; + +public class Loop { + + @Command(name="loop", description="Loops the current track") + public Response execute(Member sender, Guild guild) { + + AudioManager audioManager = guild.getAudioManager(); + PlayerManager playerManager = Ken.getInstance().getPlayerManager(); + GuildMusicManager musicManager = playerManager.getGuildMusicManager(guild); + AudioPlayer player = musicManager.player; + + if (player.getPlayingTrack() == null) { + return Response.error("Nothing is currently playing"); + } + + AudioChannel audioChannel = audioManager.getConnectedChannel(); + + assert audioChannel != null; + if (!audioChannel.getMembers().contains(sender)) { + return Response.error("You have to be in the same voice channel as me to use this command"); + } + + if(MusicPermissions.hasPermission(sender, audioChannel)) { + boolean loop = !musicManager.scheduler.isLooped(); + musicManager.scheduler.setLooped(loop); + return Response.success(String.format( + "%s Looping %s.", + loop ? ":arrows_counterclockwise:" : ":arrow_forward:", + loop ? "enabled" : "disabled" + )); + } else { + return Response.error("You must be the only person in the VC or have the `DJ` role to do this"); + } + + } +} diff --git a/src/main/java/net/tylermurphy/ken/command/music/LoopQueue.java b/src/main/java/net/tylermurphy/ken/command/music/LoopQueue.java new file mode 100644 index 0000000..6cd79b7 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/command/music/LoopQueue.java @@ -0,0 +1,53 @@ +package net.tylermurphy.ken.command.music; + +import com.sedmelluq.discord.lavaplayer.player.AudioPlayer; +import net.dv8tion.jda.api.entities.AudioChannel; +import net.dv8tion.jda.api.entities.Guild; +import net.dv8tion.jda.api.entities.Member; +import net.dv8tion.jda.api.managers.AudioManager; +import net.tylermurphy.ken.Ken; +import net.tylermurphy.ken.command.Command; +import net.tylermurphy.ken.command.Response; +import net.tylermurphy.ken.music.GuildMusicManager; +import net.tylermurphy.ken.music.MusicPermissions; +import net.tylermurphy.ken.music.PlayerManager; + +public class LoopQueue { + + @Command(name="loopqueue", description="Loops the current track queue") + public Response execute(Member sender, Guild guild) { + + AudioManager audioManager = guild.getAudioManager(); + PlayerManager playerManager = Ken.getInstance().getPlayerManager(); + GuildMusicManager musicManager = playerManager.getGuildMusicManager(guild); + AudioPlayer player = musicManager.player; + + if (player.getPlayingTrack() == null) { + return Response.error("Nothing is currently playing"); + } + + AudioChannel audioChannel = audioManager.getConnectedChannel(); + + assert audioChannel != null; + if (!audioChannel.getMembers().contains(sender)) { + return Response.error("You have to be in the same voice channel as me to use this command"); + } + + if(MusicPermissions.hasPermission(sender, audioChannel)) { + boolean loop = !musicManager.scheduler.isQueueLooped(); + if(loop) { + musicManager.scheduler.loopQueue(); + } else { + musicManager.scheduler.unLoopQueue(); + } + return Response.success(String.format( + "%s Looping %s.", + loop ? ":arrows_counterclockwise:" : ":arrow_forward:", + loop ? "enabled" : "disabled" + )); + } else { + return Response.error("You must be the only person in the VC or have the `DJ` role to do this"); + } + + } +} diff --git a/src/main/java/net/tylermurphy/ken/command/music/NowPlaying.java b/src/main/java/net/tylermurphy/ken/command/music/NowPlaying.java new file mode 100644 index 0000000..97ebd38 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/command/music/NowPlaying.java @@ -0,0 +1,67 @@ +package net.tylermurphy.ken.command.music; + +import com.sedmelluq.discord.lavaplayer.player.AudioPlayer; +import com.sedmelluq.discord.lavaplayer.track.AudioTrackInfo; +import net.dv8tion.jda.api.EmbedBuilder; +import net.dv8tion.jda.api.entities.*; +import net.dv8tion.jda.api.managers.AudioManager; +import net.tylermurphy.ken.Ken; +import net.tylermurphy.ken.command.Command; +import net.tylermurphy.ken.command.Response; +import net.tylermurphy.ken.music.GuildMusicManager; +import net.tylermurphy.ken.music.PlayerManager; + +import java.util.concurrent.TimeUnit; + +public class NowPlaying { + + @Command(name="nowplaying", description="See whats currently playing in VC") + public Response execute(Member sender, Guild guild) { + + AudioManager audioManager = guild.getAudioManager(); + PlayerManager playerManager = Ken.getInstance().getPlayerManager(); + GuildMusicManager musicManager = playerManager.getGuildMusicManager(guild); + AudioPlayer player = musicManager.player; + + if (player.getPlayingTrack() == null) { + return Response.error("Nothing is currently playing"); + } + + AudioChannel audioChannel = audioManager.getConnectedChannel(); + + assert audioChannel != null; + if (!audioChannel.getMembers().contains(sender)) { + return Response.error("You have to be in the same voice channel as me to use this command"); + } + + AudioTrackInfo info = player.getPlayingTrack().getInfo(); + String videoURL = info.uri; + String videoID = videoURL.substring(videoURL.indexOf("=")+1); + String imageURL = String.format("https://img.youtube.com/vi/%s/default.jpg",videoID); + + EmbedBuilder builder = Ken.getInstance().getDefaultEmbed() + .setTitle("**Now Playing**") + .setDescription(String.format( + "[%s](%s)\n`[%s/%s]`\n\nRequested by %s", + info.title, + info.uri, + formatTime(player.getPlayingTrack().getPosition()), + formatTime(player.getPlayingTrack().getDuration()), + player.getPlayingTrack().getUserData() + )).setThumbnail(imageURL); + + return Response.success(builder.build()); + } + + private String formatTime(long timeInMillis) { + final long hours = timeInMillis / TimeUnit.HOURS.toMillis(1); + final long minutes = timeInMillis / TimeUnit.MINUTES.toMillis(1); + final long seconds = timeInMillis % TimeUnit.MINUTES.toMillis(1) / TimeUnit.SECONDS.toMillis(1); + + if(hours == 0) { + return String.format("%02d:%02d", minutes, seconds); + } else { + return String.format("%02d:%02d:%02d", hours, minutes, seconds); + } + } +} diff --git a/src/main/java/net/tylermurphy/ken/command/music/Pause.java b/src/main/java/net/tylermurphy/ken/command/music/Pause.java new file mode 100644 index 0000000..5077e2a --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/command/music/Pause.java @@ -0,0 +1,48 @@ +package net.tylermurphy.ken.command.music; + +import com.sedmelluq.discord.lavaplayer.player.AudioPlayer; +import net.dv8tion.jda.api.entities.AudioChannel; +import net.dv8tion.jda.api.entities.Guild; +import net.dv8tion.jda.api.entities.Member; +import net.dv8tion.jda.api.managers.AudioManager; +import net.tylermurphy.ken.Ken; +import net.tylermurphy.ken.command.Command; +import net.tylermurphy.ken.command.Response; +import net.tylermurphy.ken.music.GuildMusicManager; +import net.tylermurphy.ken.music.MusicPermissions; +import net.tylermurphy.ken.music.PlayerManager; + +public class Pause { + + @Command(name="pause", description="Pauses the current track") + public Response execute(Member sender, Guild guild) { + + AudioManager audioManager = guild.getAudioManager(); + PlayerManager playerManager = Ken.getInstance().getPlayerManager(); + GuildMusicManager musicManager = playerManager.getGuildMusicManager(guild); + AudioPlayer player = musicManager.player; + + if (player.getPlayingTrack() == null) { + return Response.error("Nothing is currently playing"); + } + + if (player.isPaused()) { + return Response.error("Track is already paused"); + } + + AudioChannel audioChannel = audioManager.getConnectedChannel(); + + assert audioChannel != null; + if (!audioChannel.getMembers().contains(sender)) { + return Response.error("You have to be in the same voice channel as me to use this command"); + } + + if(MusicPermissions.hasPermission(sender, audioChannel)) { + player.setPaused(true); + return Response.success(":pause_button: Paused current track"); + } else { + return Response.error("You must be the only person in the VC or have the `DJ` role to do this"); + } + + } +} diff --git a/src/main/java/net/tylermurphy/ken/command/music/Play.java b/src/main/java/net/tylermurphy/ken/command/music/Play.java new file mode 100644 index 0000000..e32333c --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/command/music/Play.java @@ -0,0 +1,94 @@ +package net.tylermurphy.ken.command.music; + +import com.google.api.services.youtube.model.SearchResult; +import net.dv8tion.jda.api.Permission; +import net.dv8tion.jda.api.entities.*; +import net.dv8tion.jda.api.interactions.commands.OptionType; +import net.dv8tion.jda.api.managers.AudioManager; +import net.tylermurphy.ken.Ken; +import net.tylermurphy.ken.command.Command; +import net.tylermurphy.ken.command.Option; +import net.tylermurphy.ken.command.Response; +import net.tylermurphy.ken.music.PlayerManager; + +import java.net.URL; +import java.util.List; + +public class Play { + + @Command(name="play", description="Plays a song in a voice channel") + @Option(name="query", description="YouTube video URL or search query", type=OptionType.STRING, required=true) + public Response execute(Member sender, GuildMessageChannel channel, Guild guild, List<Object> args) { + AudioManager audioManager = guild.getAudioManager(); + String input = (String) args.get(0); + if(!isUrl(input)){ + String ytSearched = searchYoutube(input); + if(ytSearched == null) { + return Response.error("Unable to find youtube video with a similar name"); + } + input = ytSearched; + } + + PlayerManager manager = Ken.getInstance().getPlayerManager(); + + if(!audioManager.isConnected()) { + GuildVoiceState memberVoiceState = sender.getVoiceState(); + if (memberVoiceState == null || !memberVoiceState.inAudioChannel()) { + return Response.error("Please join a voice channel first"); + } + AudioChannel audioChannel = memberVoiceState.getChannel(); + Member selfMember = guild.getSelfMember(); + assert audioChannel != null; + if (!selfMember.hasPermission(audioChannel, Permission.VOICE_CONNECT)) { + return Response.error("I am missing permission to join "+audioChannel); + } + audioManager.openAudioConnection(audioChannel); + manager.loadAndPlay(channel, input, sender.getUser()); + } else if(manager.getGuildMusicManager(guild).scheduler.isQueueLooped()) { + return Response.error("Queue is currently looped"); + } else { + GuildVoiceState memberVoiceState = sender.getVoiceState(); + assert memberVoiceState != null; + AudioChannel voiceChannel = memberVoiceState.getChannel(); + assert voiceChannel != null; + AudioChannel selfVoiceChannel = audioManager.getConnectedChannel(); + assert selfVoiceChannel != null; + if(voiceChannel.getIdLong() == selfVoiceChannel.getIdLong()) { + manager.loadAndPlay(channel, input, sender.getUser()); + } else { + return Response.error("You have to be in the same voice channel as me to use this command"); + } + } + return Response.success(":arrow_forward: Queueing Track"); + } + + private boolean isUrl(String input) { + try { + new URL(input); + return true; + } catch (Exception e) { + return false; + } + } + + private String searchYoutube(String input) { + try { + List<SearchResult> results = Ken.getInstance().getYouTube().search() + .list("id,snippet") + .setQ(input) + .setMaxResults(1L) + .setType("video") + .setFields("items(id/kind,id/videoId,snippet/title,snippet/thumbnails/default/url)") + .setKey(Ken.getInstance().getConfig().getString("youtubeAPIKey")) + .execute() + .getItems(); + if (!results.isEmpty()) { + String videoId = results.get(0).getId().getVideoId(); + return "https://www.youtube.com/watch?v=" + videoId; + } + } catch (Exception e) { + e.printStackTrace(); + } + return null; + } +} diff --git a/src/main/java/net/tylermurphy/ken/command/music/Queue.java b/src/main/java/net/tylermurphy/ken/command/music/Queue.java new file mode 100644 index 0000000..f96815f --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/command/music/Queue.java @@ -0,0 +1,85 @@ +package net.tylermurphy.ken.command.music; + +import com.sedmelluq.discord.lavaplayer.track.AudioTrack; +import com.sedmelluq.discord.lavaplayer.track.AudioTrackInfo; +import net.dv8tion.jda.api.EmbedBuilder; +import net.dv8tion.jda.api.entities.Guild; +import net.dv8tion.jda.api.entities.Message; +import net.dv8tion.jda.api.entities.MessageEmbed; +import net.dv8tion.jda.api.interactions.components.buttons.Button; +import net.tylermurphy.ken.Ken; +import net.tylermurphy.ken.command.ButtonCallback; +import net.tylermurphy.ken.command.Command; +import net.tylermurphy.ken.command.Response; +import net.tylermurphy.ken.music.GuildMusicManager; +import net.tylermurphy.ken.music.PlayerManager; + +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.BlockingQueue; + +public class Queue { + + @Command(name="queue", description="View the current song queue") + public Response execute(Guild guild){ + PlayerManager playerManager = Ken.getInstance().getPlayerManager(); + GuildMusicManager musicManager = playerManager.getGuildMusicManager(guild); + MessageEmbed queue = getQueuePage(musicManager, 1); + if(queue == null){ + return Response.success("Queue is empty"); + } + return Response.success(queue).addSecondaryButton("queue", "previous", "Previous").addSecondaryButton("queue", "next", "Next"); + } + + @ButtonCallback(name="queue") + public Response onButton(String id, Message message, Guild guild){ + PlayerManager playerManager = Ken.getInstance().getPlayerManager(); + GuildMusicManager musicManager = playerManager.getGuildMusicManager(guild); + int page, pages; + if (message != null && message.getEmbeds().get(0) != null) { + page = Integer.parseInt(message.getEmbeds().get(0).getFooter().getText().split("/")[0].substring(5)); + pages = Integer.parseInt(message.getEmbeds().get(0).getFooter().getText().split("/")[1]); + } else { + page = 0; + pages = (musicManager.scheduler.getQueue().size()-1)/10+1; + } + if(id.equals("previous")) + page = page - 1 < 1 ? pages : page - 1; + else + page = page + 1 > pages ? 1 : page + 1; + MessageEmbed queue = getQueuePage(musicManager, page); + if(queue == null){ + return Response.success("Queue is empty"); + } + return Response.success(queue); + } + + private MessageEmbed getQueuePage(GuildMusicManager musicManager, int page){ + BlockingQueue<AudioTrack> queue = musicManager.scheduler.getQueue(); + if(queue.isEmpty()) return null; + int startingIndex = (page-1)*10; + int size = queue.size(); + int pages = (size-1)/10+1; + if(startingIndex > size){ + startingIndex = 0; + page = 1; + } + EmbedBuilder builder = Ken.getInstance().getDefaultEmbed() + .setTitle("Current Queue (Total: "+size+")") + .setFooter("Page "+page+"/"+pages); + + List<AudioTrack> tracks = new ArrayList<>(queue); + for(int i = startingIndex; i < Math.min(startingIndex+10,size); i++) { + AudioTrack track = tracks.get(i); + AudioTrackInfo info = track.getInfo(); + builder.appendDescription(String.format( + "**%s.** %s - %s\n", + i+1, + info.title, + info.author + )); + } + return builder.build(); + } + +} diff --git a/src/main/java/net/tylermurphy/ken/command/music/Remove.java b/src/main/java/net/tylermurphy/ken/command/music/Remove.java new file mode 100644 index 0000000..3457767 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/command/music/Remove.java @@ -0,0 +1,54 @@ +package net.tylermurphy.ken.command.music; + +import com.sedmelluq.discord.lavaplayer.player.AudioPlayer; +import net.dv8tion.jda.api.entities.AudioChannel; +import net.dv8tion.jda.api.entities.Guild; +import net.dv8tion.jda.api.entities.Member; +import net.dv8tion.jda.api.interactions.commands.OptionType; +import net.dv8tion.jda.api.managers.AudioManager; +import net.tylermurphy.ken.Ken; +import net.tylermurphy.ken.command.Command; +import net.tylermurphy.ken.command.Option; +import net.tylermurphy.ken.command.Response; +import net.tylermurphy.ken.music.GuildMusicManager; +import net.tylermurphy.ken.music.MusicPermissions; +import net.tylermurphy.ken.music.PlayerManager; + +import java.util.List; + +public class Remove { + + @Command(name="remove", description="Removes a track from the queue") + @Option(name="index", description="Index in queue starting from 1 you wish to remove", type=OptionType.INTEGER, required=true) + public Response execute(Member sender, Guild guild, List<Object> args) { + + AudioManager audioManager = guild.getAudioManager(); + PlayerManager playerManager = Ken.getInstance().getPlayerManager(); + GuildMusicManager musicManager = playerManager.getGuildMusicManager(guild); + AudioPlayer player = musicManager.player; + + if (player.getPlayingTrack() == null) { + return Response.error("Nothing is currently playing"); + } + + AudioChannel audioChannel = audioManager.getConnectedChannel(); + + assert audioChannel != null; + if (!audioChannel.getMembers().contains(sender)) { + return Response.error("You have to be in the same voice channel as me to use this command"); + } + + if(MusicPermissions.hasPermission(sender, audioChannel)) { + int num = (int) args.get(0); + boolean success = musicManager.scheduler.removeFromQueue(num-1); + if(success) { + return Response.success(":white_check_mark: Removed track successfully"); + } else { + return Response.error("Track not found"); + } + } else { + return Response.error("You must be the only person in the VC or have the `DJ` role to do this"); + } + + } +} diff --git a/src/main/java/net/tylermurphy/ken/command/music/Resume.java b/src/main/java/net/tylermurphy/ken/command/music/Resume.java new file mode 100644 index 0000000..c74e909 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/command/music/Resume.java @@ -0,0 +1,49 @@ +package net.tylermurphy.ken.command.music; + +import com.sedmelluq.discord.lavaplayer.player.AudioPlayer; +import net.dv8tion.jda.api.entities.AudioChannel; +import net.dv8tion.jda.api.entities.Guild; +import net.dv8tion.jda.api.entities.Member; +import net.dv8tion.jda.api.managers.AudioManager; +import net.tylermurphy.ken.Ken; +import net.tylermurphy.ken.command.Command; +import net.tylermurphy.ken.command.Response; +import net.tylermurphy.ken.music.GuildMusicManager; +import net.tylermurphy.ken.music.MusicPermissions; +import net.tylermurphy.ken.music.PlayerManager; + +public class Resume { + + @Command(name="resume", description="Resumes the current track") + public Response execute(Member sender, Guild guild) { + + AudioManager audioManager = guild.getAudioManager(); + PlayerManager playerManager = Ken.getInstance().getPlayerManager(); + GuildMusicManager musicManager = playerManager.getGuildMusicManager(guild); + AudioPlayer player = musicManager.player; + + if (player.getPlayingTrack() == null) { + return Response.error("Nothing is currently playing"); + } + + if (!player.isPaused()) { + return Response.error("Track is already playing"); + } + + AudioChannel audioChannel = audioManager.getConnectedChannel(); + + assert audioChannel != null; + if (!audioChannel.getMembers().contains(sender)) { + return Response.error("You have to be in the same voice channel as me to use this command"); + } + + if(MusicPermissions.hasPermission(sender, audioChannel)) { + player.setPaused(false); + return Response.success(":arrow_forward: Resumed current track"); + } else { + return Response.error("You must be the only person in the VC or have the `DJ` role to do this"); + } + + } + +} diff --git a/src/main/java/net/tylermurphy/ken/command/music/Skip.java b/src/main/java/net/tylermurphy/ken/command/music/Skip.java new file mode 100644 index 0000000..a82e0d5 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/command/music/Skip.java @@ -0,0 +1,78 @@ +package net.tylermurphy.ken.command.music; + +import com.sedmelluq.discord.lavaplayer.player.AudioPlayer; +import com.sedmelluq.discord.lavaplayer.track.AudioTrack; +import net.dv8tion.jda.api.entities.AudioChannel; +import net.dv8tion.jda.api.entities.Guild; +import net.dv8tion.jda.api.entities.GuildMessageChannel; +import net.dv8tion.jda.api.entities.Member; +import net.dv8tion.jda.api.managers.AudioManager; +import net.tylermurphy.ken.Ken; +import net.tylermurphy.ken.command.Command; +import net.tylermurphy.ken.command.Response; +import net.tylermurphy.ken.music.GuildMusicManager; +import net.tylermurphy.ken.music.PlayerManager; +import net.tylermurphy.ken.music.TrackScheduler; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +public class Skip { + + private final Map<AudioTrack, List<String>> skips = new HashMap<>(); + + @Command(name="skip", description="Skips current track") + public Response execute(Member sender, GuildMessageChannel channel, Guild guild, List<Object> args) { + + AudioManager audioManager = guild.getAudioManager(); + PlayerManager playerManager = Ken.getInstance().getPlayerManager(); + GuildMusicManager musicManager = playerManager.getGuildMusicManager(guild); + TrackScheduler scheduler = musicManager.scheduler; + AudioPlayer player = musicManager.player; + AudioTrack track = player.getPlayingTrack(); + + if (player.getPlayingTrack() == null) { + return Response.error("Nothing is currently playing"); + } + + AudioChannel audioChannel = audioManager.getConnectedChannel(); + + if(skips.get(track) == null) { + List<String> users = new ArrayList<String>(); + users.add(sender.getUser().getDiscriminator()); + skips.put(track, users); + } else { + List<String> users = skips.get(track); + boolean found = false; + for(String s : users) { + if(sender.getUser().getDiscriminator().equals(s)) { + found = true; + break; + } + } + if(!found) { + users.add(sender.getUser().getDiscriminator()); + skips.put(track, users); + } + } + + int people = (int) audioChannel.getMembers().stream().filter(member -> !member.getUser().isBot()).count(); + int skipsNeeded = (int) Math.ceil(people/2.0); + + if(skips.get(track).size()>=skipsNeeded) { + skips.remove(track); + scheduler.nextTrack(); + return Response.success(":arrow_right: Skipping the current track"); + } else { + return Response.success(String.format( + ":arrow_right: Skips (%s/%s) for skipping current track. Use the command fskip to force skip.", + skips.get(track).size(), + skipsNeeded + )); + } + + } + +} diff --git a/src/main/java/net/tylermurphy/ken/command/music/Stop.java b/src/main/java/net/tylermurphy/ken/command/music/Stop.java new file mode 100644 index 0000000..b942561 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/command/music/Stop.java @@ -0,0 +1,49 @@ +package net.tylermurphy.ken.command.music; + +import com.sedmelluq.discord.lavaplayer.player.AudioPlayer; +import net.dv8tion.jda.api.entities.AudioChannel; +import net.dv8tion.jda.api.entities.Guild; +import net.dv8tion.jda.api.entities.Member; +import net.dv8tion.jda.api.managers.AudioManager; +import net.tylermurphy.ken.Ken; +import net.tylermurphy.ken.command.Command; +import net.tylermurphy.ken.command.Response; +import net.tylermurphy.ken.music.GuildMusicManager; +import net.tylermurphy.ken.music.MusicPermissions; +import net.tylermurphy.ken.music.PlayerManager; + +public class Stop { + + @Command(name="stop", description="Stops current track and clears queue") + public Response execute(Member sender, Guild guild) { + + AudioManager audioManager = guild.getAudioManager(); + PlayerManager playerManager = Ken.getInstance().getPlayerManager(); + GuildMusicManager musicManager = playerManager.getGuildMusicManager(guild); + AudioPlayer player = musicManager.player; + + if (player.getPlayingTrack() == null) { + return Response.error("Nothing is currently playing"); + } + + AudioChannel audioChannel = audioManager.getConnectedChannel(); + + assert audioChannel != null; + if (!audioChannel.getMembers().contains(sender)) { + return Response.error("You have to be in the same voice channel as me to use this command"); + } + + if(MusicPermissions.hasPermission(sender, audioChannel)) { + musicManager.scheduler.getQueue().clear(); + musicManager.player.stopTrack(); + musicManager.player.setPaused(false); + musicManager.scheduler.unLoopQueue(); + musicManager.scheduler.setLooped(false); + musicManager.autoLeaveManager.startTimeout(guild); + return Response.success("Stopped the music and cleared the song queue"); + } else { + return Response.error("You must be the only person in the VC or have the `DJ` role to do this"); + } + + } +} diff --git a/src/main/java/net/tylermurphy/ken/command/nsfw/E621.java b/src/main/java/net/tylermurphy/ken/command/nsfw/E621.java new file mode 100644 index 0000000..837cca9 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/command/nsfw/E621.java @@ -0,0 +1,36 @@ +package net.tylermurphy.ken.command.nsfw; + +import net.dv8tion.jda.api.entities.GuildMessageChannel; +import net.dv8tion.jda.api.entities.TextChannel; +import net.dv8tion.jda.api.interactions.commands.OptionType; +import net.tylermurphy.ken.Ken; +import net.tylermurphy.ken.api.E621API; +import net.tylermurphy.ken.command.Command; +import net.tylermurphy.ken.command.Option; +import net.tylermurphy.ken.command.Response; + +import java.util.List; + +public class E621 { + + @Command(name="e621",description=":underage: Searches for an image off of e621") + @Option(name="query",description="Search query for rule34",type= OptionType.STRING,required=true) + public Response execute(GuildMessageChannel channel, List<String> args){ + if(!(channel instanceof TextChannel)) { + return Response.error("This command can only be used in a text channel"); + } + TextChannel textChannel = (TextChannel) channel; + if(!textChannel.isNSFW()){ + return Response.error("This command can only be used in an NSFW channel"); + } + String url = E621API.request(args.get(0)); + if(url == null){ + return Response.error("Unable to find post with search: "+args.get(0)); + } else { + if(url.endsWith(".mp4") || url.endsWith(".webm")) + return Response.success(url); + return Response.success(Ken.getInstance().getDefaultEmbed().setImage(url).build()); + } + } + +} diff --git a/src/main/java/net/tylermurphy/ken/command/nsfw/Rule34.java b/src/main/java/net/tylermurphy/ken/command/nsfw/Rule34.java new file mode 100644 index 0000000..e16ec9b --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/command/nsfw/Rule34.java @@ -0,0 +1,36 @@ +package net.tylermurphy.ken.command.nsfw; + +import net.dv8tion.jda.api.entities.GuildMessageChannel; +import net.dv8tion.jda.api.entities.TextChannel; +import net.dv8tion.jda.api.interactions.commands.OptionType; +import net.tylermurphy.ken.Ken; +import net.tylermurphy.ken.api.Rule34API; +import net.tylermurphy.ken.command.Command; +import net.tylermurphy.ken.command.Option; +import net.tylermurphy.ken.command.Response; + +import java.util.List; + +public class Rule34 { + + @Command(name="rule34",description=":underage: Searches for an image off of rule34") + @Option(name="query",description="Search query for rule34",type=OptionType.STRING,required=true) + public Response execute(GuildMessageChannel channel, List<String> args){ + if(!(channel instanceof TextChannel)) { + return Response.error("This command can only be used in a text channel"); + } + TextChannel textChannel = (TextChannel) channel; + if(!textChannel.isNSFW()){ + return Response.error("This command can only be used in an NSFW channel"); + } + String url = Rule34API.request(args.get(0)); + if(url == null){ + return Response.error("Unable to find post with search: "+args.get(0)); + } else { + if(url.endsWith(".mp4") || url.endsWith(".webm")) + return Response.success(url); + return Response.success(Ken.getInstance().getDefaultEmbed().setImage(url).build()); + } + } + +} diff --git a/src/main/java/net/tylermurphy/ken/command/util/Help.java b/src/main/java/net/tylermurphy/ken/command/util/Help.java new file mode 100644 index 0000000..278eefb --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/command/util/Help.java @@ -0,0 +1,52 @@ +package net.tylermurphy.ken.command.util; + +import net.dv8tion.jda.api.EmbedBuilder; +import net.dv8tion.jda.api.entities.Member; +import net.tylermurphy.ken.Ken; +import net.tylermurphy.ken.command.Command; +import net.tylermurphy.ken.command.Response; + +public class Help { + + @Command(name="help", description="Gets information about all the commands in the plugin") + public Response execute(Member sender){ + String name = Ken.getInstance().getConfig().getString("botName"); + String supportServer = Ken.getInstance().getConfig().getString("supportServer"); + EmbedBuilder main = Ken.getInstance().getDefaultEmbed() + .setAuthor(name + " Command List", sender.getAvatarUrl()) + .appendDescription( + "These are all the commands that are included with "+name+"\n" + + "Read below to see what each command does, and what parameters the\n" + + "command requires. Any questions? Join our [discord support server](https://discord.gg/"+supportServer+")" + ); + EmbedBuilder essential = Ken.getInstance().getDefaultEmbed() + .setTitle(":pen_ballpoint: **Main Commands**") + .appendDescription("**/help** Gives a list of commands\n") + .appendDescription("**/purge <amount>** Purges an amount of messages from a channel\n"); + EmbedBuilder music = Ken.getInstance().getDefaultEmbed() + .setTitle(":musical_note: **Music Commands**") + .appendDescription("**/play <query>** Plays a song in a voice channel\n") + .appendDescription("**/join** Make the bot join your audio channel\n") + .appendDescription("**/leave** Make the bot leave your audio channel\n") + .appendDescription("**/pause** Pause the current playing track\n") + .appendDescription("**/resume** Resume the current paused track\n") + .appendDescription("**/stop** Stop the current playing track and clear queue\n") + .appendDescription("**/skip** Vote to skip the current track\n") + .appendDescription("**/forceskip** Force skip the current track\n") + .appendDescription("**/loop** Loop the current track\n") + .appendDescription("**/loopqueue** Loop the current song queue\n") + .appendDescription("**/remove <index>** Remove a song from the queue\n") + .appendDescription("**/nowplaying** See what track is currently playing\n") + .appendDescription("**/queue** View the current song queue\n"); + EmbedBuilder game = Ken.getInstance().getDefaultEmbed() + .setTitle(":game_die: **Game Commands**") + .appendDescription("**/d6** Roll a d6 die\n") + .appendDescription("**/d8** Roll a d8 die\n") + .appendDescription("**/d12** Roll a d12 die\n") + .appendDescription("**/d20** Roll a d20 die\n") + .appendDescription("**/dice <sides>** Roll a dice with set sides\n"); + sender.getUser().openPrivateChannel().complete().sendMessageEmbeds(main.build(), essential.build(), music.build(), game.build()).queue(); + return Response.success(":grey_question: Sent help message. Check your DMs!"); + } + +} diff --git a/src/main/java/net/tylermurphy/ken/command/util/Purge.java b/src/main/java/net/tylermurphy/ken/command/util/Purge.java new file mode 100644 index 0000000..416730f --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/command/util/Purge.java @@ -0,0 +1,33 @@ +package net.tylermurphy.ken.command.util; + +import net.dv8tion.jda.api.Permission; +import net.dv8tion.jda.api.entities.Guild; +import net.dv8tion.jda.api.entities.GuildMessageChannel; +import net.dv8tion.jda.api.entities.Message; +import net.dv8tion.jda.api.interactions.commands.OptionType; +import net.tylermurphy.ken.command.Command; +import net.tylermurphy.ken.command.Option; +import net.tylermurphy.ken.command.Requirement; +import net.tylermurphy.ken.command.Response; + +import java.util.List; + +public class Purge { + + @Command(name="purge", description="Purges an amount of messages from a channel") + @Option(name="amount", description="Amount of messages you wish to purge", type=OptionType.INTEGER, required=true) + @Requirement(Permission.MESSAGE_MANAGE) + public Response execute(GuildMessageChannel channel, Guild guild, List<Object> args){ + if(!guild.getSelfMember().hasPermission(Permission.MESSAGE_MANAGE)) { + return Response.error("I don't have permission to manage messages"); + } + int amount = (int)args.get(0); + if(amount < 2 || amount > 100) { + return Response.error("Amount must be at least 2 and at most 100."); + } + List<Message> messages = channel.getHistory().retrievePast(amount).complete(); + channel.deleteMessages(messages).queue(); + return Response.success(":white_check_mark: Deleted "+amount+" messages"); + } + +} diff --git a/src/main/java/net/tylermurphy/ken/image/GifFactory.java b/src/main/java/net/tylermurphy/ken/image/GifFactory.java new file mode 100644 index 0000000..f5c754b --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/image/GifFactory.java @@ -0,0 +1,132 @@ +package net.tylermurphy.ken.image; + +import java.awt.image.BufferedImage; +import java.io.File; +import java.io.IOException; +import java.util.Iterator; + +import javax.imageio.IIOException; +import javax.imageio.IIOImage; +import javax.imageio.ImageIO; +import javax.imageio.ImageTypeSpecifier; +import javax.imageio.ImageWriter; +import javax.imageio.metadata.IIOInvalidTreeException; +import javax.imageio.metadata.IIOMetadata; +import javax.imageio.metadata.IIOMetadataNode; +import javax.imageio.stream.ImageOutputStream; + +import net.dv8tion.jda.api.entities.User; + +public class GifFactory { + + public static File generateEjectGif(User u) { + String message; + if(Math.random() > .5) + message = u.getName() + " was An Impostor"; + else + message = u.getName() + " was not An Impostor"; + + BufferedImage space1 = ImageFactory.getImageFromURL("https://cdn.tylermurphy.net/ken/space.jpg"); + BufferedImage avatar = ImageFactory.getImageFromURL(u.getAvatarUrl()); + + BufferedImage[] frames = new BufferedImage[30]; + for(int i = 0; i < 30; i++) { + frames[i] = ImageFactory.GenerateEjectFrame(message, Math.min(i, 23), 24, space1, avatar); + } + + int rand = (int)(Math.random()*1000000000); + try { + return generateFromBI(frames, rand+".gif", 100/12, true); + } catch(Exception e) { + e.printStackTrace(); + return null; + } + + } + + private static File generateFromBI(BufferedImage[] images, String output, int delay, boolean loop) + throws IIOException, IOException + { + ImageWriter gifWriter = getWriter(); + File outfile = new File(output); + ImageOutputStream ios = ImageIO.createImageOutputStream(outfile); + IIOMetadata metadata = getMetadata(gifWriter, delay, loop); + + gifWriter.setOutput(ios); + gifWriter.prepareWriteSequence(null); + for (BufferedImage img: images) + { + IIOImage temp = new IIOImage(img, null, metadata); + gifWriter.writeToSequence(temp, null); + } + + gifWriter.endWriteSequence(); + ios.close(); + + return outfile; + + } + + private static ImageWriter getWriter() throws IIOException + { + Iterator<ImageWriter> itr = ImageIO.getImageWritersByFormatName("gif"); + if(itr.hasNext()) + return itr.next(); + + throw new IIOException("GIF writer doesn't exist on this JVM!"); + } + + private static IIOMetadata getMetadata(ImageWriter writer, int delay, boolean loop) + throws IIOInvalidTreeException + { + ImageTypeSpecifier img_type = ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_ARGB); + IIOMetadata metadata = writer.getDefaultImageMetadata(img_type, null); + String native_format = metadata.getNativeMetadataFormatName(); + IIOMetadataNode node_tree = (IIOMetadataNode)metadata.getAsTree(native_format); + + IIOMetadataNode graphics_node = getNode("GraphicControlExtension", node_tree); + graphics_node.setAttribute("delayTime", String.valueOf(delay)); + graphics_node.setAttribute("disposalMethod", "none"); + graphics_node.setAttribute("userInputFlag", "FALSE"); + + if(loop) + makeLoopy(node_tree); + + metadata.setFromTree(native_format, node_tree); + + return metadata; + } + + private static void makeLoopy(IIOMetadataNode root) + { + IIOMetadataNode app_extensions = getNode("ApplicationExtensions", root); + IIOMetadataNode app_node = getNode("ApplicationExtension", app_extensions); + + app_node.setAttribute("applicationID", "NETSCAPE"); + app_node.setAttribute("authenticationCode", "2.0"); + app_node.setUserObject(new byte[]{ 0x1, (byte) (0 & 0xFF), (byte) ((0 >> 8) & 0xFF)}); + + app_extensions.appendChild(app_node); + root.appendChild(app_extensions); + } + + private static IIOMetadataNode getNode(String node_name, IIOMetadataNode root) + { + IIOMetadataNode node = null; + + for (int i = 0; i < root.getLength(); i++) + { + if(root.item(i).getNodeName().compareToIgnoreCase(node_name) == 0) + { + node = (IIOMetadataNode) root.item(i); + return node; + } + } + + node = new IIOMetadataNode(node_name); + root.appendChild(node); + + return node; + } + +}
\ No newline at end of file diff --git a/src/main/java/net/tylermurphy/ken/image/ImageFactory.java b/src/main/java/net/tylermurphy/ken/image/ImageFactory.java new file mode 100644 index 0000000..d666fe1 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/image/ImageFactory.java @@ -0,0 +1,96 @@ +package net.tylermurphy.ken.image; + +import java.awt.AlphaComposite; + +import java.awt.Color; +import java.awt.Font; +import java.awt.FontMetrics; +import java.awt.Graphics2D; +import java.awt.RenderingHints; +import java.awt.geom.RoundRectangle2D; +import java.awt.image.BufferedImage; +import java.net.HttpURLConnection; +import java.net.URL; + +import javax.imageio.ImageIO; + +public class ImageFactory { + + public static BufferedImage GenerateEjectFrame(String message, int frame, float totalFrames, BufferedImage space1, BufferedImage avatar) { + try { + int w = 600; + int h = 400; + BufferedImage img = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB); + + Graphics2D g2d = img.createGraphics(); + g2d.drawImage(space1, (int) (-100+100/totalFrames*frame), 0, (int)(w*1.5), (int)(h*1.5), null); + + BufferedImage ravater = rotate(avatar, 180/24*frame); + g2d.drawImage(ravater, (w+2*avatar.getWidth()+100)/24*frame-avatar.getWidth()-50, h/2-avatar.getHeight()/2, 150, 150, null); + + if(frame > 12) { + int length = (message.length() * (frame-11)/12); + message = message.substring(0, length); + + g2d.setFont(new Font("Dialog", Font.BOLD, 25)); + FontMetrics fm = g2d.getFontMetrics(); + int x = w/2 - fm.stringWidth(message)/2; + int y = h/2; + g2d.drawString(message, x, y); + } + + return img; + + } catch (Exception e) { + e.printStackTrace(); + return null; + } + } + + public static BufferedImage rotate(BufferedImage bimg, double angle) { + + int w = bimg.getWidth()+50; + int h = bimg.getHeight()+50; + + BufferedImage rotated = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB); + Graphics2D graphic = rotated.createGraphics(); + graphic.rotate(Math.toRadians(angle), w/2, h/2); + graphic.drawImage(bimg, null, w/2-bimg.getWidth()/2, h/2-bimg.getHeight()/2); + graphic.dispose(); + return rotated; + } + + private static BufferedImage makeRoundedCorner(BufferedImage image, int cornerRadius) { + int w = image.getWidth(); + int h = image.getHeight(); + BufferedImage output = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB); + + Graphics2D g2 = output.createGraphics(); + + g2.setComposite(AlphaComposite.Src); + g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); + g2.setColor(Color.WHITE); + g2.fill(new RoundRectangle2D.Float(0, 0, w, h, cornerRadius, cornerRadius)); + + g2.setComposite(AlphaComposite.SrcAtop); + g2.drawImage(image, 0, 0, null); + + g2.dispose(); + + return output; + } + + public static BufferedImage getImageFromURL(String surl) { + try { + final URL url = new URL(surl); + final HttpURLConnection connection = (HttpURLConnection) url.openConnection(); + connection.setRequestProperty("User-Agent", "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:25.0) Gecko/20100101 Firefox/25.0"); + final BufferedImage image = ImageIO.read(connection.getInputStream()); + return image; + } catch (Exception e) { + e.printStackTrace(); + return null; + } + } + +}
\ No newline at end of file diff --git a/src/main/java/net/tylermurphy/ken/music/AudioPlayerSendHandler.java b/src/main/java/net/tylermurphy/ken/music/AudioPlayerSendHandler.java new file mode 100644 index 0000000..5adaa36 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/music/AudioPlayerSendHandler.java @@ -0,0 +1,40 @@ +package net.tylermurphy.ken.music; + +import java.nio.ByteBuffer; + +import com.sedmelluq.discord.lavaplayer.player.AudioPlayer; +import com.sedmelluq.discord.lavaplayer.track.playback.AudioFrame; + +import net.dv8tion.jda.api.audio.AudioSendHandler; + +public class AudioPlayerSendHandler implements AudioSendHandler { + private final AudioPlayer audioPlayer; + private AudioFrame lastFrame; + + public AudioPlayerSendHandler(AudioPlayer audioPlayer) { + this.audioPlayer = audioPlayer; + } + + public boolean canProvide() { + if (lastFrame == null) { + lastFrame = audioPlayer.provide(); + } + + return lastFrame != null; + } + + public ByteBuffer provide20MsAudio() { + if (lastFrame == null) { + lastFrame = audioPlayer.provide(); + } + + byte[] data = lastFrame != null ? lastFrame.getData() : null; + lastFrame = null; + + return ByteBuffer.wrap(data); + } + + public boolean isOpus() { + return true; + } +}
\ No newline at end of file diff --git a/src/main/java/net/tylermurphy/ken/music/AutoLeaveManager.java b/src/main/java/net/tylermurphy/ken/music/AutoLeaveManager.java new file mode 100644 index 0000000..7ddbb84 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/music/AutoLeaveManager.java @@ -0,0 +1,68 @@ +package net.tylermurphy.ken.music; + +import java.util.Timer; +import java.util.TimerTask; + +import net.dv8tion.jda.api.EmbedBuilder; +import net.dv8tion.jda.api.entities.Guild; +import net.dv8tion.jda.api.entities.MessageChannel; +import net.dv8tion.jda.api.entities.TextChannel; +import net.dv8tion.jda.api.hooks.ListenerAdapter; +import net.dv8tion.jda.api.managers.AudioManager; +import net.tylermurphy.ken.Ken; + +public class AutoLeaveManager extends ListenerAdapter { + + Timer timer; + TimeoutTask task; + Guild guild; + + public AutoLeaveManager() { + Ken.getInstance().addEventListener(this); + } + + public void startTimeout(Guild guild) { + task = new TimeoutTask(guild); + timer = new Timer(); + timer.schedule(task, 0, 5000); + } + + public void stopTimeout() { + if(task == null) return; + timer.cancel(); + timer = null; + task = null; + } + +} + +class TimeoutTask extends TimerTask { + + public TimeoutTask(Guild guild) { + + PlayerManager manager = Ken.getInstance().getPlayerManager(); + GuildMusicManager musicManager = manager.getGuildMusicManager(guild); + + this.channel = musicManager.boundChannel; + this.manager = guild.getAudioManager(); + } + + private AudioManager manager; + private long lastTime = 0; + private MessageChannel channel; + + public void run() { + if(lastTime == 0) { + lastTime = System.nanoTime(); + } + if( (System.nanoTime() - lastTime) / 1_000_000_000L > 5 * 60) { + EmbedBuilder builder = Ken.getInstance().getDefaultEmbed() + .setDescription("Left voice channel due to bot inactivity."); + channel.sendMessageEmbeds(builder.build()).queue(); + manager.closeAudioConnection(); + this.cancel(); + } + } + + +}
\ No newline at end of file diff --git a/src/main/java/net/tylermurphy/ken/music/BotLeaveListener.java b/src/main/java/net/tylermurphy/ken/music/BotLeaveListener.java new file mode 100644 index 0000000..05186da --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/music/BotLeaveListener.java @@ -0,0 +1,38 @@ +package net.tylermurphy.ken.music; + +import net.dv8tion.jda.api.entities.Member; +import net.dv8tion.jda.api.events.guild.voice.GuildVoiceLeaveEvent; +import net.dv8tion.jda.api.hooks.ListenerAdapter; +import net.tylermurphy.ken.Ken; + +public class BotLeaveListener extends ListenerAdapter { + + public void onGuildVoiceLeave(GuildVoiceLeaveEvent event) { + + PlayerManager manager = Ken.getInstance().getPlayerManager(); + GuildMusicManager musicManager = manager.getGuildMusicManager(event.getGuild()); + + if(event.getMember().getIdLong() == event.getGuild().getSelfMember().getIdLong()) { + musicManager.player.stopTrack(); + musicManager.player.setPaused(false); + musicManager.boundChannel = null; + musicManager.scheduler.unLoopQueue(); + musicManager.scheduler.setLooped(false); + musicManager.scheduler.getQueue().clear(); + return; + } else if(event.getGuild().getSelfMember().getVoiceState().getChannel() == null) { + return; + } + + int users = 0; + for(Member m : event.getChannelLeft().getMembers()) { + if(!m.getUser().isBot()) + users++; + } + if(users == 0 && musicManager.autoLeaveManager.task != null) { + musicManager.autoLeaveManager.startTimeout(event.getGuild()); + } + + } + +}
\ No newline at end of file diff --git a/src/main/java/net/tylermurphy/ken/music/GuildMusicManager.java b/src/main/java/net/tylermurphy/ken/music/GuildMusicManager.java new file mode 100644 index 0000000..b96c5dd --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/music/GuildMusicManager.java @@ -0,0 +1,28 @@ +package net.tylermurphy.ken.music; + +import com.sedmelluq.discord.lavaplayer.player.AudioPlayer; +import com.sedmelluq.discord.lavaplayer.player.AudioPlayerManager; + +import net.dv8tion.jda.api.entities.Guild; +import net.dv8tion.jda.api.entities.GuildMessageChannel; + +public class GuildMusicManager { + + public final AudioPlayer player; + public final TrackScheduler scheduler; + public GuildMessageChannel boundChannel; + public final AutoLeaveManager autoLeaveManager; + public final Guild guild; + + public GuildMusicManager(Guild guild, AudioPlayerManager manager) { + player = manager.createPlayer(); + scheduler = new TrackScheduler(player, guild); + player.addListener(scheduler); + this.guild = guild; + autoLeaveManager = new AutoLeaveManager(); + } + + public AudioPlayerSendHandler getSendHandler() { + return new AudioPlayerSendHandler(player); + } +}
\ No newline at end of file diff --git a/src/main/java/net/tylermurphy/ken/music/MusicPermissions.java b/src/main/java/net/tylermurphy/ken/music/MusicPermissions.java new file mode 100644 index 0000000..4513ab7 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/music/MusicPermissions.java @@ -0,0 +1,27 @@ +package net.tylermurphy.ken.music; + +import java.util.List; + +import net.dv8tion.jda.api.entities.AudioChannel; +import net.dv8tion.jda.api.entities.Member; +import net.dv8tion.jda.api.entities.Role; + +public class MusicPermissions { + + public static boolean hasDJ(Member member){ + List<Role> roles = member.getRoles(); + for(Role role : roles) { + if(role.getName().equalsIgnoreCase("dj")) { + return true; + } + } + return false; + } + + public static boolean hasPermission(Member sender, AudioChannel channel) { + boolean hasDJRole = hasDJ(sender); + int people = (int) channel.getMembers().stream().filter(member -> !member.getUser().isBot()).count(); + return people == 1 || hasDJRole; + } + +}
\ No newline at end of file diff --git a/src/main/java/net/tylermurphy/ken/music/PlayerManager.java b/src/main/java/net/tylermurphy/ken/music/PlayerManager.java new file mode 100644 index 0000000..f3615f9 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/music/PlayerManager.java @@ -0,0 +1,157 @@ +package net.tylermurphy.ken.music; + +import com.sedmelluq.discord.lavaplayer.player.AudioLoadResultHandler; +import com.sedmelluq.discord.lavaplayer.player.AudioPlayerManager; +import com.sedmelluq.discord.lavaplayer.player.DefaultAudioPlayerManager; +import com.sedmelluq.discord.lavaplayer.source.AudioSourceManagers; +import com.sedmelluq.discord.lavaplayer.tools.FriendlyException; +import com.sedmelluq.discord.lavaplayer.track.AudioPlaylist; +import com.sedmelluq.discord.lavaplayer.track.AudioTrack; +import com.sedmelluq.discord.lavaplayer.track.AudioTrackInfo; + +import net.dv8tion.jda.api.EmbedBuilder; +import net.dv8tion.jda.api.entities.Guild; +import net.dv8tion.jda.api.entities.GuildMessageChannel; +import net.dv8tion.jda.api.entities.User; +import net.tylermurphy.ken.Ken; + +import java.awt.Color; +import java.util.HashMap; +import java.util.Map; + +public class PlayerManager { + private final AudioPlayerManager playerManager; + private final Map<Long, GuildMusicManager> musicManagers; + + public PlayerManager() { + this.musicManagers = new HashMap<>(); + + this.playerManager = new DefaultAudioPlayerManager(); + AudioSourceManagers.registerRemoteSources(playerManager); + AudioSourceManagers.registerLocalSource(playerManager); + } + + public synchronized GuildMusicManager getGuildMusicManager(Guild guild) { + long guildId = guild.getIdLong(); + GuildMusicManager musicManager = musicManagers.get(guildId); + + if (musicManager == null) { + musicManager = new GuildMusicManager(guild, playerManager); + musicManagers.put(guildId, musicManager); + musicManager.scheduler.musicManager = musicManager; + } + + guild.getAudioManager().setSendingHandler(musicManager.getSendHandler()); + + return musicManager; + } + + public void loadAndPlay(GuildMessageChannel channel, String trackUrl, User u) { + GuildMusicManager musicManager = getGuildMusicManager(channel.getGuild()); + playerManager.loadItemOrdered(musicManager, trackUrl, new AudioLoadResultHandler() { + @Override + public void trackLoaded(AudioTrack track) { + if(musicManager.boundChannel == null) { + musicManager.boundChannel = channel; + EmbedBuilder builder = Ken.getInstance().getDefaultEmbed() + .setTitle("**Bound Text Channel**") + .setDescription(String.format( + "Bound music messages to text channel %s", + channel + )) + .setColor(Color.DARK_GRAY); + channel.sendMessageEmbeds(builder.build()).queue(); + } + + AudioTrackInfo info = track.getInfo(); + String videoURL = info.uri; + String videoID = videoURL.substring(videoURL.indexOf("=")+1); + String imageURL = String.format("https://img.youtube.com/vi/%s/default.jpg",videoID); + + EmbedBuilder builder = Ken.getInstance().getDefaultEmbed() + .setTitle("**Queued**") + .setDescription(String.format( + "[%s](%s)", + info.title, + info.uri + )) + .setFooter(String.format( + "In position #%s", + musicManager.scheduler.getLength()+1 + )) + .setThumbnail(imageURL) + .setColor(Color.DARK_GRAY); + channel.sendMessageEmbeds(builder.build()).queue(); + track.setUserData(u); + play(musicManager, track); + + } + + @Override + public void playlistLoaded(AudioPlaylist playlist) { + + if(musicManager.boundChannel == null) { + musicManager.boundChannel = channel; + EmbedBuilder builder = Ken.getInstance().getDefaultEmbed() + .setTitle("**Bound Text Channel**") + .setDescription(String.format( + "Bound music messages to text channel %s", + channel + )) + .setColor(Color.DARK_GRAY); + channel.sendMessageEmbeds(builder.build()).queue(); + } + + AudioTrack firstTrack = playlist.getSelectedTrack(); + if (firstTrack == null) { + firstTrack = playlist.getTracks().remove(0); + } else { + firstTrack.setUserData(u); + } + + String videoURL = firstTrack.getInfo().uri; + String videoID = videoURL.substring(videoURL.indexOf("=")+1); + String imageURL = String.format("https://img.youtube.com/vi/%s/default.jpg",videoID); + + EmbedBuilder builder = Ken.getInstance().getDefaultEmbed() + .setTitle("**Queued**") + .setDescription(String.format( + "[%s](%s)", + playlist.getName(), + playlist.getTracks().get(0).getInfo().uri + )) + .setFooter(String.format( + "First track of playlist in position #%s", + musicManager.scheduler.getLength()-playlist.getTracks().size()+1 + )) + .setThumbnail(imageURL) + .setColor(Color.DARK_GRAY); + + channel.sendMessageEmbeds(builder.build()).queue(); + + play(musicManager, firstTrack); + + for(AudioTrack track : playlist.getTracks().subList(1, playlist.getTracks().size())) { + track.setUserData(u); + musicManager.scheduler.queue(track); + } + } + + @Override + public void noMatches() { + channel.sendMessage("Nothing found by " + trackUrl).queue(); + } + + @Override + public void loadFailed(FriendlyException exception) { + channel.sendMessage("Could not play: " + exception.getMessage()).queue(); + } + }); + + } + + private void play(GuildMusicManager musicManager, AudioTrack track) { + musicManager.scheduler.queue(track); + } + +}
\ No newline at end of file diff --git a/src/main/java/net/tylermurphy/ken/music/TrackScheduler.java b/src/main/java/net/tylermurphy/ken/music/TrackScheduler.java new file mode 100644 index 0000000..0a73272 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/music/TrackScheduler.java @@ -0,0 +1,161 @@ +package net.tylermurphy.ken.music; + +import com.sedmelluq.discord.lavaplayer.player.AudioPlayer; +import com.sedmelluq.discord.lavaplayer.player.event.AudioEventAdapter; +import com.sedmelluq.discord.lavaplayer.track.AudioTrack; +import com.sedmelluq.discord.lavaplayer.track.AudioTrackEndReason; +import com.sedmelluq.discord.lavaplayer.track.AudioTrackInfo; + +import net.dv8tion.jda.api.EmbedBuilder; +import net.dv8tion.jda.api.entities.Guild; +import net.dv8tion.jda.api.entities.User; +import net.tylermurphy.ken.Ken; + +import java.util.Iterator; +import java.util.concurrent.BlockingQueue; +import java.util.concurrent.LinkedBlockingQueue; +import java.util.concurrent.TimeUnit; + +public class TrackScheduler extends AudioEventAdapter { + private final AudioPlayer player; + private final Guild guild; + private final BlockingQueue<AudioTrack> queue; + private boolean looping,queueLooped; + private AudioTrack trackToBeLooped; + public GuildMusicManager musicManager; + + public TrackScheduler(AudioPlayer player, Guild guild) { + this.player = player; + this.guild = guild; + this.queue = new LinkedBlockingQueue<>(); + looping = false; + queueLooped = false; + } + + private boolean play(AudioTrack track, boolean dontForce) { + boolean success = player.startTrack(track, dontForce); + trackToBeLooped = track; + if(queueLooped) queue.offer(track.makeClone()); + if(success) { + AudioTrackInfo info = player.getPlayingTrack().getInfo(); + + String videoURL = track.getInfo().uri; + String videoID = videoURL.substring(videoURL.indexOf("=")+1); + String imageURL = String.format("https://img.youtube.com/vi/%s/default.jpg",videoID); + + musicManager.autoLeaveManager.stopTimeout(); + + EmbedBuilder builder = Ken.getInstance().getDefaultEmbed() + .setTitle("**Now Playing**") + .setDescription(String.format( + "[%s](%s)\n`[%s/%s]`\n\nRequested by %s", + info.title, + info.uri, + formatTime(player.getPlayingTrack().getPosition()), + formatTime(player.getPlayingTrack().getDuration()), + (User)player.getPlayingTrack().getUserData() + )).setThumbnail(imageURL); + musicManager.boundChannel.sendMessageEmbeds(builder.build()).queue(); + + } + return success; + } + + public boolean queue(AudioTrack track) { + if (!play(track, true)) { + queue.offer(track); + return false; + } + return true; + } + + public BlockingQueue<AudioTrack> getQueue() { + return queue; + } + + public void loopQueue() { + queueLooped = true; + } + + public void unLoopQueue() { + queueLooped = false; + } + + public void nextTrack() { + + if(looping) { + repeatTrack(); return; + } + + AudioTrack nextTrack = queue.poll(); + + player.stopTrack(); + if(nextTrack == null) { + looping = false; + queueLooped = false; + + PlayerManager manager = Ken.getInstance().getPlayerManager(); + GuildMusicManager musicManager = manager.getGuildMusicManager(guild); + musicManager.autoLeaveManager.startTimeout(guild); + + return; + } + + play(nextTrack.makeClone(), false); + } + + public void repeatTrack() { + play(trackToBeLooped.makeClone(), false); + } + + public boolean removeFromQueue(int num) { + int i = 0; + Iterator<AudioTrack> itr = queue.iterator(); + while(itr.hasNext()) { + AudioTrack t = itr.next(); + if(num == i) { + return queue.remove(t); + } + i++; + } + return false; + } + + public void setLooped(boolean value) { + looping = value; + } + + public boolean isLooped() { + return looping; + } + + public boolean isQueueLooped() { + return queueLooped; + } + + public void onTrackEnd(AudioPlayer player, AudioTrack track, AudioTrackEndReason endReason) { + if (endReason.mayStartNext) { + if(looping) { + repeatTrack(); + } else { + nextTrack(); + } + } + } + + public int getLength() { + return queue.size(); + } + + private String formatTime(long timeInMillis) { + final long hours = timeInMillis / TimeUnit.HOURS.toMillis(1); + final long minutes = timeInMillis / TimeUnit.MINUTES.toMillis(1); + final long seconeds = timeInMillis % TimeUnit.MINUTES.toMillis(1) / TimeUnit.SECONDS.toMillis(1); + + if(hours == 0) { + return String.format("%02d:%02d", minutes, seconeds); + } else { + return String.format("%02d:%02d:%02d", hours, minutes, seconeds); + } + } +}
\ No newline at end of file |