Initial commit

src/main/java/cf/sobrooms/DiscordWebhook.java

@@ -0,0 +1,388 @@
+package cf.sobrooms;
+
+import javax.net.ssl.HttpsURLConnection;
+import java.awt.*;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.lang.reflect.Array;
+import java.net.URL;
+import java.util.List;
+import java.util.*;
+
+/**
+ * Class used to execute Discord Webhooks with low effort
+ */
+public class DiscordWebhook {
+
+    private final String url;
+    private String content;
+    private String username;
+    private String avatarUrl;
+    private boolean tts;
+    private final List<EmbedObject> embeds = new ArrayList<>();
+
+    /**
+     * Constructs a new DiscordWebhook instance
+     *
+     * @param url The webhook_notify URL obtained in Discord
+     */
+    public DiscordWebhook(String url) {
+        this.url = url;
+    }
+
+    public void setContent(String content) {
+        this.content = content;
+    }
+
+    public void setUsername(String username) {
+        this.username = username;
+    }
+
+    public void setAvatarUrl(String avatarUrl) {
+        this.avatarUrl = avatarUrl;
+    }
+
+    public void setTts(boolean tts) {
+        this.tts = tts;
+    }
+
+    public void addEmbed(EmbedObject embed) {
+        this.embeds.add(embed);
+    }
+
+    public void execute() throws IOException {
+        if (this.content == null && this.embeds.isEmpty()) {
+            throw new IllegalArgumentException("Set content or add at least one EmbedObject");
+        }
+
+        JSONObject json = new JSONObject();
+
+        json.put("content", this.content);
+        json.put("username", this.username);
+        json.put("avatar_url", this.avatarUrl);
+        json.put("tts", this.tts);
+
+        if (!this.embeds.isEmpty()) {
+            List<JSONObject> embedObjects = new ArrayList<>();
+
+            for (EmbedObject embed : this.embeds) {
+                JSONObject jsonEmbed = new JSONObject();
+
+                jsonEmbed.put("title", embed.getTitle());
+                jsonEmbed.put("description", embed.getDescription());
+                jsonEmbed.put("url", embed.getUrl());
+
+                if (embed.getColor() != null) {
+                    Color color = embed.getColor();
+                    int rgb = color.getRed();
+                    rgb = (rgb << 8) + color.getGreen();
+                    rgb = (rgb << 8) + color.getBlue();
+
+                    jsonEmbed.put("color", rgb);
+                }
+
+                EmbedObject.Footer footer = embed.getFooter();
+                EmbedObject.Image image = embed.getImage();
+                EmbedObject.Thumbnail thumbnail = embed.getThumbnail();
+                EmbedObject.Author author = embed.getAuthor();
+                List<EmbedObject.Field> fields = embed.getFields();
+
+                if (footer != null) {
+                    JSONObject jsonFooter = new JSONObject();
+
+                    jsonFooter.put("text", footer.getText());
+                    jsonFooter.put("icon_url", footer.getIconUrl());
+                    jsonEmbed.put("footer", jsonFooter);
+                }
+
+                if (image != null) {
+                    JSONObject jsonImage = new JSONObject();
+
+                    jsonImage.put("url", image.getUrl());
+                    jsonEmbed.put("image", jsonImage);
+                }
+
+                if (thumbnail != null) {
+                    JSONObject jsonThumbnail = new JSONObject();
+
+                    jsonThumbnail.put("url", thumbnail.getUrl());
+                    jsonEmbed.put("thumbnail", jsonThumbnail);
+                }
+
+                if (author != null) {
+                    JSONObject jsonAuthor = new JSONObject();
+
+                    jsonAuthor.put("name", author.getName());
+                    jsonAuthor.put("url", author.getUrl());
+                    jsonAuthor.put("icon_url", author.getIconUrl());
+                    jsonEmbed.put("author", jsonAuthor);
+                }
+
+                List<JSONObject> jsonFields = new ArrayList<>();
+                for (EmbedObject.Field field : fields) {
+                    JSONObject jsonField = new JSONObject();
+
+                    jsonField.put("name", field.getName());
+                    jsonField.put("value", field.getValue());
+                    jsonField.put("inline", field.isInline());
+
+                    jsonFields.add(jsonField);
+                }
+
+                jsonEmbed.put("fields", jsonFields.toArray());
+                embedObjects.add(jsonEmbed);
+            }
+
+            json.put("embeds", embedObjects.toArray());
+        }
+
+        URL url = new URL(this.url);
+        HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
+        connection.addRequestProperty("Content-Type", "application/json");
+        connection.addRequestProperty("User-Agent", "Java-DiscordWebhook-BY-Gelox_");
+        connection.setDoOutput(true);
+        connection.setRequestMethod("POST");
+
+        OutputStream stream = connection.getOutputStream();
+        stream.write(json.toString().getBytes());
+        stream.flush();
+        stream.close();
+
+        connection.getInputStream().close(); //I'm not sure why but it doesn't work without getting the InputStream
+        connection.disconnect();
+    }
+
+    public static class EmbedObject {
+        private String title;
+        private String description;
+        private String url;
+        private Color color;
+
+        private Footer footer;
+        private Thumbnail thumbnail;
+        private Image image;
+        private Author author;
+        private final List<Field> fields = new ArrayList<>();
+
+        public String getTitle() {
+            return title;
+        }
+
+        public EmbedObject setTitle(String title) {
+            this.title = title;
+            return this;
+        }
+
+        public String getDescription() {
+            return description;
+        }
+
+        public EmbedObject setDescription(String description) {
+            this.description = description;
+            return this;
+        }
+
+        public String getUrl() {
+            return url;
+        }
+
+        public EmbedObject setUrl(String url) {
+            this.url = url;
+            return this;
+        }
+
+        public Color getColor() {
+            return color;
+        }
+
+        public EmbedObject setColor(Color color) {
+            this.color = color;
+            return this;
+        }
+
+        public Footer getFooter() {
+            return footer;
+        }
+
+        public Thumbnail getThumbnail() {
+            return thumbnail;
+        }
+
+        public EmbedObject setThumbnail(String url) {
+            this.thumbnail = new Thumbnail(url);
+            return this;
+        }
+
+        public Image getImage() {
+            return image;
+        }
+
+        public EmbedObject setImage(String url) {
+            this.image = new Image(url);
+            return this;
+        }
+
+        public Author getAuthor() {
+            return author;
+        }
+
+        public List<Field> getFields() {
+            return fields;
+        }
+
+        public EmbedObject setFooter(String text, String icon) {
+            this.footer = new Footer(text, icon);
+            return this;
+        }
+
+        public EmbedObject setAuthor(String name, String url, String icon) {
+            this.author = new Author(name, url, icon);
+            return this;
+        }
+
+        public EmbedObject addField(String name, String value, boolean inline) {
+            this.fields.add(new Field(name, value, inline));
+            return this;
+        }
+
+        private class Footer {
+            private final String text;
+            private final String iconUrl;
+
+            private Footer(String text, String iconUrl) {
+                this.text = text;
+                this.iconUrl = iconUrl;
+            }
+
+            private String getText() {
+                return text;
+            }
+
+            private String getIconUrl() {
+                return iconUrl;
+            }
+        }
+
+        private class Thumbnail {
+            private final String url;
+
+            private Thumbnail(String url) {
+                this.url = url;
+            }
+
+            private String getUrl() {
+                return url;
+            }
+        }
+
+        private class Image {
+            private final String url;
+
+            private Image(String url) {
+                this.url = url;
+            }
+
+            private String getUrl() {
+                return url;
+            }
+        }
+
+        private class Author {
+            private final String name;
+            private final String url;
+            private final String iconUrl;
+
+            private Author(String name, String url, String iconUrl) {
+                this.name = name;
+                this.url = url;
+                this.iconUrl = iconUrl;
+            }
+
+            private String getName() {
+                return name;
+            }
+
+            private String getUrl() {
+                return url;
+            }
+
+            private String getIconUrl() {
+                return iconUrl;
+            }
+        }
+
+        private class Field {
+            private final String name;
+            private final String value;
+            private final boolean inline;
+
+            private Field(String name, String value, boolean inline) {
+                this.name = name;
+                this.value = value;
+                this.inline = inline;
+            }
+
+            private String getName() {
+                return name;
+            }
+
+            private String getValue() {
+                return value;
+            }
+
+            private boolean isInline() {
+                return inline;
+            }
+        }
+    }
+
+    private class JSONObject {
+
+        private final HashMap<String, Object> map = new HashMap<>();
+
+        void put(String key, Object value) {
+            if (value != null) {
+                map.put(key, value);
+            }
+        }
+
+        @Override
+        public String toString() {
+            StringBuilder builder = new StringBuilder();
+            Set<Map.Entry<String, Object>> entrySet = map.entrySet();
+            builder.append("{");
+
+            int i = 0;
+            for (Map.Entry<String, Object> entry : entrySet) {
+                Object val = entry.getValue();
+                builder.append(quote(entry.getKey())).append(":");
+
+                if (val instanceof String) {
+                    builder.append(quote(String.valueOf(val)));
+                } else if (val instanceof Integer) {
+                    builder.append(Integer.valueOf(String.valueOf(val)));
+                } else if (val instanceof Boolean) {
+                    builder.append(val);
+                } else if (val instanceof JSONObject) {
+                    builder.append(val);
+                } else if (val.getClass().isArray()) {
+                    builder.append("[");
+                    int len = Array.getLength(val);
+                    for (int j = 0; j < len; j++) {
+                        builder.append(Array.get(val, j).toString()).append(j != len - 1 ? "," : "");
+                    }
+                    builder.append("]");
+                }
+
+                builder.append(++i == entrySet.size() ? "}" : ",");
+            }
+
+            return builder.toString();
+        }
+
+        private String quote(String string) {
+            return "\"" + string + "\"";
+        }
+    }
+
+}

src/main/java/cf/sobrooms/Main.java

@@ -0,0 +1,187 @@
+package cf.sobrooms;
+
+import cf.sobrooms.commands.InfoCommand;
+import cf.sobrooms.commands.PingCommand;
+import cf.sobrooms.commands.SendMessageCommand;
+import cf.sobrooms.commands.SetLoggingModeCommand;
+import cf.sobrooms.events.enchantment.EnchantItem;
+import cf.sobrooms.events.enchantment.PrepareItemEnchant;
+import cf.sobrooms.events.player.*;
+import cf.sobrooms.events.server.ServerStart;
+import cf.sobrooms.events.weather.LightningStrike;
+import cf.sobrooms.events.weather.ThunderChange;
+import cf.sobrooms.events.weather.WeatherChange;
+import cf.sobrooms.events.world.WorldInit;
+import cf.sobrooms.events.world.WorldLoad;
+import cf.sobrooms.events.world.WorldSave;
+import cf.sobrooms.events.world.WorldUnload;
+import com.google.gson.Gson;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonParser;
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.io.*;
+import java.util.Objects;
+
+public class Main extends JavaPlugin {
+    public static File isLoggingConfig;
+    public static File notifyWebhookConfig;
+    public static File pubMessageWebhookConfig;
+    public static String serverAddress = "mc-srv2-singapore.rrryfoo.cf";
+    private static boolean webhooksAreValidUrls;
+
+    public static void main(String... args) {
+        System.out.printf("Initializing using server address: %s...%n", serverAddress);
+    }
+
+    @Override
+    public void onEnable() {
+        String loggingDir = "./NoS";
+        File directory = new File(loggingDir);
+        if (!directory.exists()) {
+            if (directory.mkdir()) {
+                System.out.println("Config dir created: " + loggingDir);
+            } else {
+                System.out.println("Failed to create config directory: " + loggingDir);
+            }
+        }
+        isLoggingConfig = new File("./NoS/willLogCommands.bool");
+        notifyWebhookConfig = new File("./NoS/notifyWebhook.json");
+        pubMessageWebhookConfig = new File("./NoS/pubMessageWebhook.json");
+        try {
+            if (isLoggingConfig.createNewFile() || notifyWebhookConfig.createNewFile() || pubMessageWebhookConfig.createNewFile()) {
+                System.out.println("Config created: " + isLoggingConfig.getName());
+                FileWriter notifyWebhookConfigWriter = new FileWriter(notifyWebhookConfig);
+                FileWriter pubMessageWebhookConfigWriter = new FileWriter(pubMessageWebhookConfig);
+                notifyWebhookConfigWriter.write("{\"url\": \"default-ns\"}");
+                pubMessageWebhookConfigWriter.write("{\"url\": \"default-ns\"}");
+                pubMessageWebhookConfigWriter.close();
+                notifyWebhookConfigWriter.close();
+            } else {
+                System.out.println("Created config even while it already exists, skipping step...");
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+        // post
+        Bukkit.getConsoleSender().sendMessage("Note: This Spigot/Bukkit plugin is highly verbose, so it will log a lot of events...");
+        // register commands
+        try {
+            Objects.requireNonNull(this.getCommand("info")).setExecutor(new InfoCommand());
+            Objects.requireNonNull(this.getCommand("send-message")).setExecutor(new SendMessageCommand());
+            Objects.requireNonNull(this.getCommand("set-logging")).setExecutor(new SetLoggingModeCommand());
+            Objects.requireNonNull(this.getCommand("ping-server")).setExecutor(new PingCommand());
+        } catch (NullPointerException e) {
+            throw new RuntimeException(e);
+        }
+
+        // register events
+        ServerStart serverStart = new ServerStart();
+        getServer().getPluginManager().registerEvents(serverStart, this);
+        if (getLoggingConfig().equals("true") && webhooksAreValidUrls)
+            registerEvents();
+        if (webhooksAreValidUrls) {
+            PlayerJoin playerJoin = new PlayerJoin();
+            PlayerQuit playerQuit = new PlayerQuit();
+            getServer().getPluginManager().registerEvents(playerJoin, this);
+            getServer().getPluginManager().registerEvents(playerQuit, this);
+        }
+
+    }
+    public static String getPublicMessageWebhook() {
+        try {
+            BufferedReader brfmsg = new BufferedReader(new FileReader(pubMessageWebhookConfig));
+            JsonParser jsonReader = new JsonParser();
+            JsonElement MsgParse = jsonReader.parse(brfmsg.readLine());
+            String lineMsg = MsgParse.getAsJsonObject().get("url").getAsString();
+            // validate url being url
+            // but this won't validate the url being an actual webhook
+            // i can try but lazy :sob:
+            if (lineMsg.equals("default-ns")) {
+                System.out.printf("Please set the webhook URL in %s and restart the server", pubMessageWebhookConfig.getAbsolutePath());
+                webhooksAreValidUrls = false;
+                return lineMsg;
+            } else if (lineMsg.startsWith("https://") || lineMsg.startsWith("http://")) {
+                return lineMsg;
+            } else {
+                System.out.printf("Please set the webhook URL in %s and restart the server", pubMessageWebhookConfig.getAbsolutePath());
+                webhooksAreValidUrls = false;
+                return lineMsg;
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+    public static String getNotifyWebhook() {
+        try {
+            BufferedReader brfntfy = new BufferedReader(new FileReader(notifyWebhookConfig));
+            JsonParser jsonReader = new JsonParser();
+            JsonElement NtfyParse = jsonReader.parse(brfntfy.readLine());
+            String lineNtfy = NtfyParse.getAsJsonObject().get("url").getAsString();
+            // validate url being url
+            // but this won't validate the url being an actual webhook
+            // i can try but lazy :sob:
+            if (lineNtfy.equals("default-ns")) {
+                System.out.printf("Please set the webhook URL in %s and restart the server", notifyWebhookConfig.getAbsolutePath());
+                webhooksAreValidUrls = false;
+                return lineNtfy;
+            } else if (lineNtfy.startsWith("https://") || lineNtfy.startsWith("http://")) {
+                return lineNtfy;
+            } else {
+                System.out.printf("Please set the webhook URL in %s and restart the server", notifyWebhookConfig.getAbsolutePath());
+                webhooksAreValidUrls = false;
+                return lineNtfy;
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+    public static String getLoggingConfig() {
+        try {
+            File file = new File("./NoS/willLogCommands.bool");
+            BufferedReader reader = new BufferedReader(new FileReader(file));
+            String line;
+            while ((line = reader.readLine()) != null) {
+                if (line.equals("true") || line.equals("false"))
+                    return line;
+                else
+                    return "Content is not a boolean";
+            }
+            reader.close();
+        } catch (IOException e) {
+            System.out.println("An error occurred while reading the configuration file.");
+            e.printStackTrace();
+            return "err";
+        }
+        return "err";
+    }
+    public void registerEvents() {
+        PlayerChat playerChat = new PlayerChat();
+        PlayerCommandPreprocess playerCommandPreprocess = new PlayerCommandPreprocess();
+        EnchantItem enchantItemEvent = new EnchantItem();
+        PrepareItemEnchant prepareItemEnchant = new PrepareItemEnchant();
+        PlayerBedEnter playerBedEnter = new PlayerBedEnter();
+        PlayerBedLeave playerBedLeave = new PlayerBedLeave();
+        LightningStrike lightningStrike = new LightningStrike();
+        ThunderChange thunderChange = new ThunderChange();
+        WeatherChange weatherChange = new WeatherChange();
+        WorldInit worldInit = new WorldInit();
+        WorldLoad worldLoad = new WorldLoad();
+        WorldSave worldSave = new WorldSave();
+        WorldUnload worldUnload = new WorldUnload();
+        getServer().getPluginManager().registerEvents(playerChat, this);
+        getServer().getPluginManager().registerEvents(playerCommandPreprocess, this);
+        getServer().getPluginManager().registerEvents(enchantItemEvent, this);
+        getServer().getPluginManager().registerEvents(prepareItemEnchant, this);
+        getServer().getPluginManager().registerEvents(playerBedEnter, this);
+        getServer().getPluginManager().registerEvents(playerBedLeave, this);
+        getServer().getPluginManager().registerEvents(lightningStrike, this);
+        getServer().getPluginManager().registerEvents(thunderChange, this);
+        getServer().getPluginManager().registerEvents(weatherChange, this);
+        getServer().getPluginManager().registerEvents(worldInit, this);
+        getServer().getPluginManager().registerEvents(worldLoad, this);
+        getServer().getPluginManager().registerEvents(worldSave, this);
+        getServer().getPluginManager().registerEvents(worldUnload, this);
+    }
+}

src/main/java/cf/sobrooms/ServerUtils.java

@@ -0,0 +1,58 @@
+package cf.sobrooms;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Server;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.Socket;
+
+public class ServerUtils {
+    public static int port = 25565;
+    public static String address = "http://mc-srv2-singapore.rrryfoo.cf";
+    public static String address_fallback = Utils.getServerHostPublicIP();
+    public static String webhook_notify = Main.getNotifyWebhook();
+    public static String webhook_messages = Main.getPublicMessageWebhook();
+
+    public static boolean serverIsUp(String serverAddress, Integer serverPort) {
+        /*Socket socket;
+        try {
+            socket = new Socket(address, port);
+            socket.close();
+            return true;
+        } catch (Exception e) {
+            try {
+                System.out.println("Server is inactive on default address. Pinging on fallback address (" + address_fallback + ")...");
+                Socket socket2 = new Socket(address_fallback, port);
+                socket2.close();
+                return true;
+            } catch (Exception exception) {
+                System.out.println("Server is inactive on fallback address. No longer pinging...");
+                return false;
+            }
+        }*/
+        try {
+            Server server = Bukkit.getServer();
+            Socket s = new Socket();
+            s.connect(new InetSocketAddress(serverAddress.toString(), Integer.parseInt(serverPort.toString())), 15);
+            s.close();
+            System.out.println("Server is online. Sending message to webhook_notify... (Pinged " + Utils.getServerHostPublicIP() + ":" + server.getPort() + ")");
+            return true;
+        } catch (Exception e) {
+            System.out.println("Server is inactive. Pinging fallback address...");
+            try {
+                Server server = Bukkit.getServer();
+                Socket s = new Socket();
+                s.connect(new InetSocketAddress(address_fallback, Integer.parseInt(serverPort.toString())), 15);
+                s.close();
+            } catch (Exception err) {
+                System.out.println("Fallback address is inactive. No longer pinging...");
+            }
+            return false;
+        }
+    }
+
+}

src/main/java/cf/sobrooms/Utils.java

@@ -0,0 +1,60 @@
+package cf.sobrooms;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.InetAddress;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.UnknownHostException;
+
+public class Utils {
+    public static String getActivePlayers() {
+        var players = Bukkit.getServer().getOnlinePlayers();
+        String activePlayers;
+        if (players.size() < 1) {
+            activePlayers = "None.";
+        } else {
+            activePlayers = "";
+            int playersCounted = 0;
+            for (Player player : players) {
+                playersCounted++;
+                activePlayers = "%s\n%s) %s".formatted(activePlayers, playersCounted, player.getName());
+            }
+        }
+        return activePlayers;
+    }
+
+    public static String getServerHostPublicIP() {
+        String urlString = "http://myexternalip.com/raw";
+        try {
+            URL url = new URL(urlString);
+            try (BufferedReader br = new BufferedReader(new InputStreamReader(url.openStream()))) {
+                return br.readLine();
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static String getServerPing(String address) {
+        try {
+            int timeout = 3000;
+            long startTime = System.currentTimeMillis();
+            InetAddress serverAddress = InetAddress.getByName(address);
+            boolean reachable = serverAddress.isReachable(timeout);
+            long endTime = System.currentTimeMillis();
+            long latency = endTime - startTime;
+            if (reachable) {
+                return String.valueOf(latency);
+            } else {
+                return "404svh";
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/main/java/cf/sobrooms/commands/InfoCommand.java

@@ -0,0 +1,32 @@
+package cf.sobrooms.commands;
+
+
+import cf.sobrooms.Utils;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+
+public class InfoCommand implements CommandExecutor {
+
+    // This method is called, when somebody uses our command
+    @Override
+    public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
+        sender.sendMessage((ChatColor.YELLOW + """
+                Server Info
+                
+                """ + ChatColor.WHITE +
+                """
+                Server name/type: %s
+                Server IP: %s
+                Server Port: %s
+                Server Version: %s
+                Active Players:""" + ChatColor.GOLD +
+                " %s\n" + ChatColor.WHITE + "Plugin made by sobrooms (rrryfoo, AnonCYTO)\n" + ChatColor.MAGIC + ":sob: all day" + ChatColor.WHITE)
+                .formatted(Bukkit.getServer().getName(), Utils.getServerHostPublicIP(), Bukkit.getServer().getPort(), Bukkit.getServer().getVersion(), Utils.getActivePlayers()));
+
+        // If the player (or console) uses our command correct, we can return true
+        return true;
+    }
+}

src/main/java/cf/sobrooms/commands/PingCommand.java

@@ -0,0 +1,34 @@
+package cf.sobrooms.commands;
+
+import cf.sobrooms.Utils;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class PingCommand implements CommandExecutor {
+    public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
+        try {
+            String ping_host = Utils.getServerPing(Utils.getServerHostPublicIP());
+            Player player;
+            if (sender instanceof Player) {
+                // Sender is a player
+                player = (Player) sender;
+            } else {
+                // Sender is not a player
+                sender.sendMessage("You must be a player to use this command.");
+                return true;
+            }
+            if (ping_host.equals("404svh")) {
+                sender.sendMessage("Failed to fetch ping.");
+            } else {
+                sender.sendMessage(ChatColor.ITALIC + "Server ping: %sms".formatted(ping_host));
+                sender.sendMessage(ChatColor.ITALIC + "Player ping: %sms".formatted(player.getPing()));
+            }
+            return true;
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/main/java/cf/sobrooms/commands/SendMessageCommand.java

@@ -0,0 +1,41 @@
+package cf.sobrooms.commands;
+
+import cf.sobrooms.DiscordWebhook;
+import cf.sobrooms.ServerUtils;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+
+import java.awt.*;
+import java.io.IOException;
+import java.util.Date;
+
+public class SendMessageCommand implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (args.length == 0) {
+            sender.sendMessage("Please input a message to send...");
+            return false;
+        } else {
+            sender.sendMessage("Sending public message to discord server...");
+            DiscordWebhook discordWebhook = new DiscordWebhook(ServerUtils.webhook_messages);
+            discordWebhook.setUsername("Public Messages");
+            String message = String.join(" ", args);
+            DiscordWebhook.EmbedObject embedObject = new DiscordWebhook.EmbedObject()
+                    .setTitle("New public message")
+                    .setDescription(message)
+                    .setAuthor(sender.getName(), "", "")
+                    .setFooter(new Date().toString(), "")
+                    .setColor(Color.darkGray);
+            discordWebhook.addEmbed(embedObject);
+            try {
+                discordWebhook.execute();
+                sender.sendMessage("Sent public message.");
+                return true;
+            } catch (IOException e) {
+                sender.sendMessage("An error occurred while sending your message...");
+                throw new RuntimeException(e);
+            }
+        }
+    }
+}

src/main/java/cf/sobrooms/commands/SetLoggingModeCommand.java

@@ -0,0 +1,35 @@
+package cf.sobrooms.commands;
+
+import cf.sobrooms.Main;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.ChatColor;
+
+import java.io.FileWriter;
+import java.io.IOException;
+
+public class SetLoggingModeCommand implements CommandExecutor {
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (args[0].isBlank()) {
+            sender.sendMessage("Please provide a boolean and make sure you only provided one argument. (true/false)");
+            return false;
+        } else {
+            if (args[0].equals("true") || args[0].equals("false")) {
+                try {
+                    FileWriter writer = new FileWriter(Main.isLoggingConfig);
+                    writer.write(args[0]);
+                    writer.close();
+                    System.out.println("Wrote to config, closing writer...");
+                    sender.sendMessage(ChatColor.RED + "" + ChatColor.ITALIC + "Changes will only apply once the server has restarted.");
+                    sender.sendMessage(ChatColor.RED + "" + ChatColor.ITALIC + "Please restart the server manually.");
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+                return true;
+            } else {
+                return false;
+            }
+        }
+    }
+}

src/main/java/cf/sobrooms/events/enchantment/EnchantItem.java

@@ -0,0 +1,36 @@
+package cf.sobrooms.events.enchantment;
+
+import cf.sobrooms.ServerUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.enchantment.EnchantItemEvent;
+
+import cf.sobrooms.DiscordWebhook;
+
+import java.awt.*;
+import java.io.IOException;
+import java.util.Date;
+
+public class EnchantItem implements Listener {
+    @EventHandler
+    public void onEnchantItem(EnchantItemEvent event) {
+        Player player = event.getEnchanter();
+        Bukkit.getConsoleSender().sendMessage("Triggered EnchantItem event");
+        DiscordWebhook notify = new DiscordWebhook(ServerUtils.webhook_notify);
+        DiscordWebhook.EmbedObject embedObject = new DiscordWebhook.EmbedObject().setTitle("Enchant item").setDescription("A player has enchanted an item...")
+                .addField("Datetime", new Date().toString(), false)
+                .addField("Player name", player.getName(), true)
+                .addField("Enchantment", event.getEnchantsToAdd().toString(), true)
+                .addField("Item name", event.getItem().toString(), true)
+                .addField("Amount", String.valueOf(event.getItem().getAmount()), true)
+                .setColor(Color.BLUE);
+        notify.addEmbed(embedObject);
+        try {
+            notify.execute();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/main/java/cf/sobrooms/events/enchantment/PrepareItemEnchant.java

@@ -0,0 +1,33 @@
+package cf.sobrooms.events.enchantment;
+
+import cf.sobrooms.DiscordWebhook;
+import cf.sobrooms.ServerUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.enchantment.PrepareItemEnchantEvent;
+
+import java.awt.*;
+import java.io.IOException;
+import java.util.Date;
+
+public class PrepareItemEnchant implements Listener {
+    @EventHandler
+    public void onPrepareItemEnchant(PrepareItemEnchantEvent event) {
+        Bukkit.getConsoleSender().sendMessage("Triggered PrepareItemEnchant event.");
+        Player player = event.getEnchanter();
+        DiscordWebhook notify = new DiscordWebhook(ServerUtils.webhook_notify);
+        DiscordWebhook.EmbedObject embedObject = new DiscordWebhook.EmbedObject().setTitle("Enchantment prepare").setDescription("A player is about to enchant an item...")
+                .addField("Date of preparation", new Date().toString(), false)
+                .addField("Player name", player.getName(), true)
+                .addField("Item to be enchanted", event.getItem().toString(), true)
+                .setColor(Color.BLUE);
+        notify.addEmbed(embedObject);
+        try {
+            notify.execute();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/main/java/cf/sobrooms/events/player/PlayerBedEnter.java

@@ -0,0 +1,32 @@
+package cf.sobrooms.events.player;
+
+import cf.sobrooms.DiscordWebhook;
+import cf.sobrooms.ServerUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerBedEnterEvent;
+
+import java.awt.*;
+import java.io.IOException;
+import java.util.Date;
+
+public class PlayerBedEnter implements Listener {
+    @EventHandler
+    public void onPlayerBedEnter(PlayerBedEnterEvent event) {
+        Bukkit.getConsoleSender().sendMessage("Triggered PlayerBedEnter event.");
+        Player player = event.getPlayer();
+        DiscordWebhook notify = new DiscordWebhook(ServerUtils.webhook_notify);
+        DiscordWebhook.EmbedObject embedObject = new DiscordWebhook.EmbedObject().setTitle("Player slep").setDescription("Player is sleping")
+                .addField("Time", new Date().toString(), false)
+                .addField("Player name", player.getName(), true)
+                .setColor(Color.BLUE);
+        notify.addEmbed(embedObject);
+        try {
+            notify.execute();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/main/java/cf/sobrooms/events/player/PlayerBedLeave.java

@@ -0,0 +1,32 @@
+package cf.sobrooms.events.player;
+
+import cf.sobrooms.DiscordWebhook;
+import cf.sobrooms.ServerUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerBedLeaveEvent;
+
+import java.awt.*;
+import java.io.IOException;
+import java.util.Date;
+
+public class PlayerBedLeave implements Listener {
+    @EventHandler
+    public void onPlayerBedLeave(PlayerBedLeaveEvent event) {
+        Bukkit.getConsoleSender().sendMessage("Triggered PlayerBedLeave event.");
+        Player player = event.getPlayer();
+        DiscordWebhook notify = new DiscordWebhook(ServerUtils.webhook_notify);
+        DiscordWebhook.EmbedObject embedObject = new DiscordWebhook.EmbedObject().setTitle("Player no longe slep...").setDescription("Player is no slep")
+                .addField("Time", new Date().toString(), false)
+                .addField("Player name", player.getName(), true)
+                .setColor(Color.BLUE);
+        notify.addEmbed(embedObject);
+        try {
+            notify.execute();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/main/java/cf/sobrooms/events/player/PlayerChat.java

@@ -0,0 +1,35 @@
+package cf.sobrooms.events.player;
+
+import cf.sobrooms.DiscordWebhook;
+import cf.sobrooms.ServerUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.AsyncPlayerChatEvent;
+
+import java.awt.*;
+import java.io.IOException;
+import java.util.Date;
+
+public class PlayerChat implements Listener {
+    public PlayerChat() {
+    }
+
+    @EventHandler
+    public void onPlayerChat(AsyncPlayerChatEvent event) {
+        Bukkit.getConsoleSender().sendMessage("Triggered chat event.");
+        Player player = event.getPlayer();
+        DiscordWebhook notify = new DiscordWebhook(ServerUtils.webhook_notify);
+        DiscordWebhook.EmbedObject embedObject = new DiscordWebhook.EmbedObject().setTitle("A message was sent").setDescription(String.format("A message sent by %s was sent.", player.getName()))
+                .addField("Date of message", new Date().toString(), false)
+                .addField("Message content", event.getMessage(), true)
+                .setColor(Color.BLUE);
+        notify.addEmbed(embedObject);
+        try {
+            notify.execute();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/main/java/cf/sobrooms/events/player/PlayerCommandPreprocess.java

@@ -0,0 +1,34 @@
+package cf.sobrooms.events.player;
+
+import cf.sobrooms.DiscordWebhook;
+import cf.sobrooms.ServerUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerCommandPreprocessEvent;
+
+import java.awt.*;
+import java.io.IOException;
+import java.util.Date;
+
+public class PlayerCommandPreprocess implements Listener {
+    @EventHandler
+    public void onPlayerCommandPreprocess(PlayerCommandPreprocessEvent event) {
+        Bukkit.getConsoleSender().sendMessage("PlayerCommandPreprocess event triggered");
+        Player player = event.getPlayer();
+        String[] command = event.getMessage().split(" "); // get the command name
+        DiscordWebhook notify = new DiscordWebhook(ServerUtils.webhook_notify);
+        DiscordWebhook.EmbedObject embedObject = new DiscordWebhook.EmbedObject().setTitle("Command used").setDescription("A player has used a command.")
+                .addField("Date of usage", new Date().toString(), false)
+                .addField("Player name", player.getName(), false)
+                .addField("Command", command[0], true)
+                .setColor(Color.BLUE);
+        notify.addEmbed(embedObject);
+        try {
+            notify.execute();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/main/java/cf/sobrooms/events/player/PlayerJoin.java

@@ -0,0 +1,32 @@
+package cf.sobrooms.events.player;
+
+import cf.sobrooms.DiscordWebhook;
+import cf.sobrooms.ServerUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+
+import java.awt.*;
+import java.io.IOException;
+import java.util.Date;
+
+public class PlayerJoin implements Listener {
+    @EventHandler
+    public void onPlayerJoin(PlayerJoinEvent event) {
+        Bukkit.getConsoleSender().sendMessage("Triggered PlayerJoinEvent.");
+        Player player = event.getPlayer();
+        DiscordWebhook notify = new DiscordWebhook(ServerUtils.webhook_notify);
+        DiscordWebhook.EmbedObject embedObject = new DiscordWebhook.EmbedObject().setTitle("Player join").setDescription("A player has joined the game.")
+                .addField("Date of join", new Date().toString(), false)
+                .addField("Player name", player.getName(), true)
+                .setColor(Color.BLUE);
+        notify.addEmbed(embedObject);
+        try {
+            notify.execute();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/main/java/cf/sobrooms/events/player/PlayerQuit.java

@@ -0,0 +1,31 @@
+package cf.sobrooms.events.player;
+
+import cf.sobrooms.DiscordWebhook;
+import cf.sobrooms.ServerUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerQuitEvent;
+
+import java.awt.*;
+import java.io.IOException;
+import java.util.Date;
+public class PlayerQuit implements Listener {
+    @EventHandler
+    public void onPlayerQuit(PlayerQuitEvent event) {
+        Bukkit.getConsoleSender().sendMessage("PlayerQuit event triggered");
+        Player player = event.getPlayer();
+        DiscordWebhook.EmbedObject embedObject = new DiscordWebhook.EmbedObject().setTitle("A player has left the server").setDescription(String.format("A player left the server..", player.getName()))
+                .addField("Date of quit", new Date().toString(), false)
+                .addField("Player name", event.getPlayer().getName(), true)
+                .setColor(Color.BLUE);
+        DiscordWebhook notify = new DiscordWebhook(ServerUtils.webhook_notify);
+        notify.addEmbed(embedObject);
+        try {
+            notify.execute();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/main/java/cf/sobrooms/events/server/ServerStart.java

@@ -0,0 +1,51 @@
+package cf.sobrooms.events.server;
+
+import cf.sobrooms.DiscordWebhook;
+import cf.sobrooms.Main;
+import cf.sobrooms.ServerUtils;
+import cf.sobrooms.Utils;
+import org.bukkit.Bukkit;
+import org.bukkit.Server;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.server.ServerLoadEvent;
+
+import java.awt.*;
+import java.io.IOException;
+import java.util.Date;
+
+import cf.sobrooms.DiscordWebhook.EmbedObject;
+
+public class ServerStart implements Listener {
+    public static int timesCalled = 0;
+    @EventHandler
+    public void onServerStart(ServerLoadEvent event) {
+        Bukkit.getConsoleSender().sendMessage("Triggered ServerLoad event.");
+        if (timesCalled < 1) {
+            Bukkit.getConsoleSender().sendMessage("Checking if server is up on " + ServerUtils.address + " with port " + ServerUtils.port + "...");
+            if (ServerUtils.serverIsUp(Main.serverAddress, 25565)) {
+                System.out.println(ServerUtils.webhook_messages);
+                System.out.println(ServerUtils.webhook_notify);
+                DiscordWebhook notify = new DiscordWebhook(Main.getNotifyWebhook());
+                EmbedObject embedObject = new EmbedObject().setTitle("Server started up successfully").setDescription(String.format("The server at %s:%d has started successfully.", Utils.getServerHostPublicIP(), Bukkit.getServer().getPort()))
+                        .addField("Date of start", new Date().toString(), false)
+                        .setColor(Color.GREEN);
+                if (Main.getLoggingConfig().equals("false"))
+                    embedObject.addField("Extra notes", "The server will not try to log any events.", false);
+                notify.addEmbed(embedObject);
+                try {
+                    notify.execute();
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+                timesCalled++;
+            } else {
+                Bukkit.getConsoleSender().sendMessage("OnServerStart was called, but the server is currently offline... This may trigger more than once.");
+            }
+        } else {
+            Bukkit.getConsoleSender().sendMessage("(debug) server start event was called more than 1 time");
+        }
+    }
+
+
+}

src/main/java/cf/sobrooms/events/weather/LightningStrike.java

@@ -0,0 +1,32 @@
+package cf.sobrooms.events.weather;
+
+import cf.sobrooms.DiscordWebhook;
+import cf.sobrooms.ServerUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.weather.LightningStrikeEvent;
+
+import java.awt.*;
+import java.io.IOException;
+import java.util.Date;
+
+public class LightningStrike implements Listener {
+    @EventHandler
+    public void onLightningStrike(LightningStrikeEvent event) {
+        Bukkit.getConsoleSender().sendMessage("Triggered LightningStrike event.");
+        DiscordWebhook notify = new DiscordWebhook(ServerUtils.webhook_notify);
+        DiscordWebhook.EmbedObject embedObject = new DiscordWebhook.EmbedObject().setTitle("LightningStrike").setDescription("lightning striked")
+                .addField("Time", new Date().toString(), false)
+                .addField("World in which event was triggered in", event.getWorld().getName(), true)
+                .addField("Cause of strike", event.getCause().name(), true)
+                .setColor(Color.BLUE);
+        notify.addEmbed(embedObject);
+        try {
+            notify.execute();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/main/java/cf/sobrooms/events/weather/ThunderChange.java

@@ -0,0 +1,31 @@
+package cf.sobrooms.events.weather;
+
+import cf.sobrooms.DiscordWebhook;
+import cf.sobrooms.ServerUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.weather.ThunderChangeEvent;
+
+import java.awt.*;
+import java.io.IOException;
+import java.util.Date;
+
+public class ThunderChange implements Listener {
+    @EventHandler
+    public void onThunderChange(ThunderChangeEvent event) {
+        Bukkit.getConsoleSender().sendMessage("Triggered ThunderChange event.");
+        DiscordWebhook notify = new DiscordWebhook(ServerUtils.webhook_notify);
+        DiscordWebhook.EmbedObject embedObject = new DiscordWebhook.EmbedObject().setTitle("ThunderChange").setDescription("Tf is this")
+                .addField("Time", new Date().toString(), false)
+                .addField("Occurred in world", event.getWorld().getName(), true)
+                .setColor(Color.BLUE);
+        notify.addEmbed(embedObject);
+        try {
+            notify.execute();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/main/java/cf/sobrooms/events/weather/WeatherChange.java

@@ -0,0 +1,30 @@
+package cf.sobrooms.events.weather;
+
+import cf.sobrooms.DiscordWebhook;
+import cf.sobrooms.ServerUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.weather.WeatherChangeEvent;
+
+import java.awt.*;
+import java.io.IOException;
+import java.util.Date;
+
+public class WeatherChange implements Listener {
+    @EventHandler
+    public void onWeatherChange(WeatherChangeEvent event) {
+        Bukkit.getConsoleSender().sendMessage("Triggered WeatherChange event.");
+        DiscordWebhook notify = new DiscordWebhook(ServerUtils.webhook_notify);
+        DiscordWebhook.EmbedObject embedObject = new DiscordWebhook.EmbedObject().setTitle("WeatherChange").setDescription("Weather was changed")
+                .addField("Time", new Date().toString(), false)
+                .addField("Occurred in world", event.getWorld().getName(), true)
+                .setColor(Color.BLUE);
+        notify.addEmbed(embedObject);
+        try {
+            notify.execute();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/main/java/cf/sobrooms/events/world/WorldInit.java

@@ -0,0 +1,30 @@
+package cf.sobrooms.events.world;
+
+import cf.sobrooms.DiscordWebhook;
+import cf.sobrooms.ServerUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.world.WorldInitEvent;
+
+import java.awt.*;
+import java.io.IOException;
+import java.util.Date;
+
+public class WorldInit implements Listener {
+    @EventHandler
+    public void onWorldInit(WorldInitEvent event) {
+        Bukkit.getConsoleSender().sendMessage("Triggered WorldInit event.");
+        DiscordWebhook notify = new DiscordWebhook(ServerUtils.webhook_notify);
+        DiscordWebhook.EmbedObject embedObject = new DiscordWebhook.EmbedObject().setTitle("WorldInit").setDescription("World initialized")
+                .addField("Time", new Date().toString(), false)
+                .addField("World name", event.getWorld().getName(), true)
+                .setColor(Color.BLUE);
+        notify.addEmbed(embedObject);
+        try {
+            notify.execute();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/main/java/cf/sobrooms/events/world/WorldLoad.java

@@ -0,0 +1,30 @@
+package cf.sobrooms.events.world;
+
+import cf.sobrooms.DiscordWebhook;
+import cf.sobrooms.ServerUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.world.WorldLoadEvent;
+
+import java.awt.*;
+import java.io.IOException;
+import java.util.Date;
+
+public class WorldLoad implements Listener {
+    @EventHandler
+    public void onWorldLoad(WorldLoadEvent event) {
+        Bukkit.getConsoleSender().sendMessage("Triggered WorldLoad event.");
+        DiscordWebhook notify = new DiscordWebhook(ServerUtils.webhook_notify);
+        DiscordWebhook.EmbedObject embedObject = new DiscordWebhook.EmbedObject().setTitle("WorldLoad").setDescription("World in server was loaded")
+                .addField("Time", new Date().toString(), false)
+                .addField("World name", event.getWorld().getName(), true)
+                .setColor(Color.BLUE);
+        notify.addEmbed(embedObject);
+        try {
+            notify.execute();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/main/java/cf/sobrooms/events/world/WorldSave.java

@@ -0,0 +1,30 @@
+package cf.sobrooms.events.world;
+
+import cf.sobrooms.DiscordWebhook;
+import cf.sobrooms.ServerUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.world.WorldSaveEvent;
+
+import java.awt.*;
+import java.io.IOException;
+import java.util.Date;
+
+public class WorldSave implements Listener {
+    @EventHandler
+    public void onWorldSave(WorldSaveEvent event) {
+        Bukkit.getConsoleSender().sendMessage("Triggered WorldSave event.");
+        DiscordWebhook notify = new DiscordWebhook(ServerUtils.webhook_notify);
+        DiscordWebhook.EmbedObject embedObject = new DiscordWebhook.EmbedObject().setTitle("WorldSave").setDescription("World in the server was saved")
+                .addField("Time", new Date().toString(), false)
+                .addField("World name", event.getWorld().getName(), true)
+                .setColor(Color.BLUE);
+        notify.addEmbed(embedObject);
+        try {
+            notify.execute();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/main/java/cf/sobrooms/events/world/WorldUnload.java

@@ -0,0 +1,30 @@
+package cf.sobrooms.events.world;
+
+import cf.sobrooms.DiscordWebhook;
+import cf.sobrooms.ServerUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.world.WorldUnloadEvent;
+
+import java.awt.*;
+import java.io.IOException;
+import java.util.Date;
+
+public class WorldUnload implements Listener {
+    @EventHandler
+    public void onWorldUnload(WorldUnloadEvent event) {
+        Bukkit.getConsoleSender().sendMessage("Triggered WorldUnload event.");
+        DiscordWebhook notify = new DiscordWebhook(ServerUtils.webhook_notify);
+        DiscordWebhook.EmbedObject embedObject = new DiscordWebhook.EmbedObject().setTitle("WorldUnload").setDescription("A world was unloaded...")
+                .addField("Time", new Date().toString(), false)
+                .addField("World name", event.getWorld().getName(), true)
+                .setColor(Color.BLUE);
+        notify.addEmbed(embedObject);
+        try {
+            notify.execute();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/main/resources/plugin.yml

@@ -0,0 +1,20 @@
+main: cf.sobrooms.Main
+version: 1.0.0
+name: notifyOnStart
+description: Sends webhook_notify to sobrooms when the server starts successfully
+api-version: 1.19
+authors: [rrryfoo, sobrooms]
+commands:
+  info:
+    description: Shows info about this server.
+    usage: /info
+  send-message:
+    description: Sends a message to the server's main discord server.
+    usage: /send-message <message content>
+  set-logging:
+    description: Toggles event logging in the server, may greatly increase performance and reduce lag.
+    usage: /set-logging <true|false>
+    permission: op
+  ping-server:
+    description: Pings the server...
+    usage: /ping-server