diff --git a/README.md b/README.md
index c304239..5c37baa 100644
--- a/README.md
+++ b/README.md
@@ -9,7 +9,12 @@ Bridges chat between Discord and Minecraft (Bukkit/Spigot).
 
 ## Installation
 
-<<Coming soon!>>
+
+1. Download the latest release from GitHub
+2. Add it to your plugins folder
+3. Either run Bukkit/Spigot once to generate DiscordBridge/config.yml or create it using the guide below.
+4. All done!
+
 
 ## Configuration
 
@@ -32,8 +37,13 @@ username: 'DiscordBridge'
 # Use '&' in place of the formatting symbol.
 username-color: ''
 
+# (Optional) Define an alternate prefix for all of the bot's commands. These will work in addition to @mentions.
+# Will also work in Minecraft if the sender has the required permission for the command they try.
+# Leave blank to only allow @mentions to prefix commands
+command-prefix: ''
+
 # (Optional) Set this value with a valid Cleverbot API key to enable chatting with Cleverbot
-# Look at https://www.cleverbot.com/JDA/ for more info
+# Look at https://www.cleverbot.com/api/ for more info
 cleverbot-key: ''
 
 # If true, prints verbose log messages to the server console for every action
@@ -59,22 +69,23 @@ if-vanished:
   player-leave: false
   player-death: false
 
-# Set the templates for relayed messages
-# %u - The sender's username
-# %m - The sender's message
-# %w - The name of the world the sender is in (Multiverse alias compatible)
-# %r - The death message (Death event only)
-# Use '&' in place of the formatting symbol to apply formatting codes.
+# Set the templates for various message types
+# %u - The username of the one who sent the message or invoked a command, if applicable
+# %m - The raw message that would normally display, if applicable
+# %w - The name of the world the sender is in
+#   - Applicable to messages from Minecraft only
+#   - Multiverse alias compatible
+# Use '&' in place of the formatting symbol to apply formatting codes to messages sent to Minecraft
 templates:
   discord:
     chat-message: '<**%u**> %m'
     player-join: '**%u** joined the server'
     player-leave: '**%u** left the server'
-    player-death: '%r'
+    player-death: '%m'
     server-start: 'Server started!'
     server-stop: 'Shutting down...'
   minecraft:
-    chat-message: '[&b&lDiscord&r]<%u> %m'
+    chat-message: '[&b&l%w&r]<%u> %m'
 ```
 
 * `token` is the access token for the Discord bot. Without this, the bot will not function at all.
@@ -91,51 +102,64 @@ templates:
 
 **Templates**
 
-- `%u` will be replaced with the username 
-- `%d` will be replaced with the user's display name
+- `%u` will be replaced with the player/user's username
 - `%m` will be replaced with the message
 - `%w` will be replaced with the world name
-- `%r` will be replaced with Minecraft's standard death message
 - Color codes, prefixed with `&`, will be translated on the Minecraft end
 
 ## Features
 
 * Anything said in Minecraft chat will be sent to your chosen Discord channel
-* Anything said in your chosen Discord channel will be sent to your Minecraft chat (with a `(discord)` suffix added to usernames)
+* If Multiverse-Core is installed and the `%w` tag is specified in your relay message syntax, the alias assigned to your Multiverse worlds will be displayed
+* Anything said in your chosen Discord channel will be sent to your Minecraft chat (if the `%w` tag is used in your relay message syntax, Discord messages will display `Discord`)
+* If Dynmap is installed, anything said over Dynmap chat will be relayed to your chosen Discord channel (if the `%w` tag is used in your relay messag syntax, Dynmap messages will display `Dynmap`)
 * You can link Minecraft accounts to Discord accounts and the bot will translate display names to match where the message appears
 * Join / leave messages can be sent to Discord
 * Death messages can be sent to Discord
 * Server start and stop messages can be sent to Discord
 * All of the above messages can be toggled if you don't want them to appear
-* Message templates are customized
-* Prefixing usernames with `@` in the Minecraft chat will be converted to mentions in the Discord chat if the user exists (you can use their Discord display name with spaces removed, or their Minecraft username if the accounts are linked)
-* Image attachments sent in the Discord channel will relay their URLs to Minecraft
-* Add scripted responses for the bot to say when it detects a trigger phrase
+* Message templates are customizeable
+* Prefixing usernames with `@` in the Minecraft chat will be converted to tag mentions in the Discord chat if the user exists (you can use their Discord display name with spaces removed, or their Minecraft username if the accounts are linked)
+* Add customizeable scripted responses for the bot to say when it detects a trigger phrase
 * A handful of fun and shitposting commands for the full Discord Bot experience both in and out of game
-* Cleverbot integration - chat with the bot using `@<name>`. Works in Discord AND Minecraft!
+* Cleverbot integration - chat with the bot using `@<bot name>` or `/talk`. Works in Discord AND Minecraft! (requires Cleverbot API key)
 * The bot can use any of its commands in any channel it can read (including DMs!) allowing it to function as a general-purpose Discord bot on the side
+* Command permissions affect both Minecraft slash command and Minecraft in-chat commands
 
 ## Permissions
 
-- `discordbridge.cleverbot` - ability to talk to Cleverbot
-- `discordbridge.f` - ability to pay respects with /f
-- `discordbridge.reload` - ability to reload data and reconnect the Discord connection
-- `discordbridge.eightball` - ability to consult the Magic 8-Ball with /8ball
-- `discordbridge.rate` - ability to ask for an out-of-10 rating with /rate
-- `discordbridge.insult` - ability to make the bot insult something with /insult
+- `discordbridge.discord` - ability to use any command in of the /discord subcommand tree
+- `discordbridge.discord.reload` - ability to reload configs and JDA
+- `discordbridge.discord.listmembers` - abiliyt to receive a list of members in the Discord channel
+- `discordbridge.discord.linkalias` - abiliy to send a request to a Discord member to set up alias translation
+- `discordbridge.talk` - ability to talk to Cleverbot
+- `discordbridge.f` - ability to use the f command
+- `discordbridge.rate` - ability to use the rate command
+- `discordbridge.eightball` - ability to use the 8ball command
+- `discordbridge.insult` - ability to use the insult command
+- `discordbridge.choose` - ability to use the choose command
+- `discordbridge.roll` - ability to use the roll command
 
 ## Commands
 
-- `/discord reload` - reloads data and reconnects to Discord
-- `/discord get online` - provides a list of all Discord users in the relay channel who are Online, Do Not Disturb, and Idle
-- `/discord get ids` - provides a list of the Discord IDs of all users in the relay channel, which is useful for...
-- `/discord register <discord-id>` - this command will send a DM to the corresponding user asking if that user wishes to link their Discord account with the Minecraft user who issued the command
-- `/f` - press F to pay respects
-- `/8ball <query>` - consults the Magic 8-Ball to answer your yes/no questions (messages configurable in `botmemory.yml`)
-- `/rate <thing to rate>` - asks the bot to rate something on a 0-10 scale
-- `/insult <thing to insult>` - makes the bot insult something (messages configurable in `insults.yml`) (*WARNING: The supplied insults are quite offensive! Remove permissions for this command or replace the insults if you intend to use this bot on cleaner servers!*)
+- `8ball <question>` - consult the Magic 8-Ball to answer your yes/no questions (messages configurable in `botmemory.yml`)
+- `discord reload` - refreshes the JDA connection and reloads configs
+- `discord linkalias` - sends a request to a specified Discord user to link aliases for username translation
+- `discord listmembers all` - lists all the members in the Discord relay channel
+- `discord listmembers online` - lists all the members in the Discord relay channel who are online along with their statuses
+- `discord unlinkalias ` - silently breaks an alias link with a Discord user, if one exists
+- `f` - press F to pay respects (messages configurable in `f.yml`)
+- `rate <thing to be rated>` - have the bot rate something for you (rating scale and messages configurable in `rate.yml`)
+- `insult <thing to insult>` - makes the bot insult something (messages configurable in `insults.yml`) (*WARNING: The supplied insults are quite offensive! Remove permissions for this command or replace the insults if you intend to use this bot on cleaner servers!*)
+- `choose <choiceA or choiceB || choiceC, choice D...>` - have the bot make a choice for you
+- `roll <sides>` - roll a die with a specified number of sides (up to 100)
+- `talk <message` - talk to Cleverbot!
 
 ## Upcoming Features
 
+* Vanilla Minecraft admin commands (kick, ban, start, stop, give, etc) usable from Discord
 * Add support for a URL shortening service so attachment URLs aren't so flipping long
-* Some of the 'fun' commands that literally every Discord bot has (with matching Minecraft commands!)
+* Add support for relaying embeds
+* Make Discord responses for certain commands return in pretty embeds
+* More of the 'fun' commands that literally every Discord bot has (with matching Minecraft commands!)
+* Multiple Discord channel support?
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/Config.kt b/src/main/kotlin/gg/obsidian/discordbridge/Config.kt
index 72f47d9..abdd864 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/Config.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/Config.kt
@@ -3,6 +3,9 @@ package gg.obsidian.discordbridge
 import gg.obsidian.discordbridge.utils.UtilFunctions.noSpace
 import org.bukkit.ChatColor
 
+/**
+ * Caches primary config information
+ */
 object Config {
 
     var SERVER_ID: String = ""
@@ -42,6 +45,10 @@ object Config {
     // misc
     var BOT_MC_USERNAME = ""
 
+    /**
+     * Load values into memory from the config file
+     * @param plugin the base Plugin object
+     */
     fun load(plugin: Plugin) {
         plugin.reloadConfig()
 
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/DataConfigAccessor.kt b/src/main/kotlin/gg/obsidian/discordbridge/DataConfigAccessor.kt
index 77391da..e3004e6 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/DataConfigAccessor.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/DataConfigAccessor.kt
@@ -20,6 +20,8 @@ package gg.obsidian.discordbridge
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
+*
+* NOTE: This code has been modified from Java to Kotlin. The functionality is largely identical.
 */
 
 import org.bukkit.configuration.file.FileConfiguration
@@ -29,6 +31,13 @@ import java.io.IOException
 import java.io.InputStreamReader
 import java.util.logging.Level
 
+/**
+ * Acts as an interface between the plugin and a target config file
+ *
+ * @param plugin a reference to the base Plugin object
+ * @param filepath the path to the config file
+ * @param fileName the name of the config file plus its extension
+ */
 class DataConfigAccessor(val plugin: Plugin, filepath: File, private val fileName: String) {
 
     private val configFile: File?
@@ -39,6 +48,11 @@ class DataConfigAccessor(val plugin: Plugin, filepath: File, private val fileNam
         this.configFile = File(filepath, fileName)
     }
 
+    /**
+     * Reloads the data from the config file into memory
+     *
+     * If the file is null, the default file from within the jar file is loaded instead
+     */
     fun reloadConfig() {
         try {
             fileConfiguration = YamlConfiguration.loadConfiguration(configFile)
@@ -59,6 +73,9 @@ class DataConfigAccessor(val plugin: Plugin, filepath: File, private val fileNam
             return fileConfiguration!!
         }
 
+    /**
+     * Writes the current memory contents of the config back to file
+     */
     fun saveConfig() {
         if (fileConfiguration == null || configFile == null)
             return
@@ -71,6 +88,9 @@ class DataConfigAccessor(val plugin: Plugin, filepath: File, private val fileNam
         }
     }
 
+    /**
+     * Saves the default config file within the jar to its own file, if it does not already exist
+     */
     @Suppress("unused")
     fun saveDefaultConfig() {
         if (!configFile!!.exists())
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/Plugin.kt b/src/main/kotlin/gg/obsidian/discordbridge/Plugin.kt
index 19d6769..adf5411 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/Plugin.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/Plugin.kt
@@ -19,6 +19,9 @@ import java.io.File
 import java.util.logging.Level
 import org.bukkit.ChatColor as CC
 
+/**
+ * The primary Plugin class that maintains the plugin's connection with Bukkit
+ */
 class Plugin : JavaPlugin() {
 
     // Configs
@@ -36,12 +39,17 @@ class Plugin : JavaPlugin() {
     // Temporary storage for alias linking requests
     var requests: MutableList<UserAlias> = mutableListOf()
 
-    // Detects if Multiverse-Core is installed
+    /**
+     * Returns whether Multiverse-Core is installed
+     */
     val isMultiverseInstalled: Boolean
         get() = server.pluginManager.getPlugin("Multiverse-Core") != null
 
+    /**
+     * Runs at plugin startup
+     */
     override fun onEnable() {
-
+        // Register data class types to the config deserializer
         ConfigurationSerialization.registerClass(Respect::class.java, "Respect")
         ConfigurationSerialization.registerClass(Rating::class.java, "Rating")
         ConfigurationSerialization.registerClass(Script::class.java, "Script")
@@ -68,6 +76,9 @@ class Plugin : JavaPlugin() {
         getCommand("roll").executor = CommandListener(this)
     }
 
+    /**
+     * Runs cleanup when the plugin is disabled
+     */
     override fun onDisable() {
         if (Config.ANNOUNCE_SERVER_START_STOP)
             Connection.send(Config.TEMPLATES_DISCORD_SERVER_STOP, Connection.getRelayChannel())
@@ -81,13 +92,22 @@ class Plugin : JavaPlugin() {
       Messaging Functions
     ===================================== */
 
-    // Send a message to Discord
+    /**
+     * Sends a message to the specified Discord channel
+     *
+     * @param message the message to send
+     * @param channel the channel to send the message to
+     */
     fun sendToDiscord(message: String, channel: MessageChannel?) {
         logDebug("Sending message to Discord - $message")
         Connection.send(message, channel)
     }
 
-    // Send a message to Minecraft
+    /**
+     * Broadcast a message on the Minecraft server
+     *
+     * @param message the message to send
+     */
     fun sendToMinecraft(message: String) {
         server.broadcastMessage(message)
     }
@@ -96,7 +116,9 @@ class Plugin : JavaPlugin() {
       Util
     ===========================================*/
 
-    // Reloads everything
+    /**
+     * Reloads all configs and the JDA connection
+     */
     fun reload(callback: Runnable) {
         reloadConfig()
         users.reloadConfig()
@@ -111,7 +133,9 @@ class Plugin : JavaPlugin() {
         Connection.reconnect(callback)
     }
 
-    // Save default config
+    /**
+     * Saves all default configs where configs do not exist and reloads data from file into memory
+     */
     fun updateConfig(version: String) {
         this.saveDefaultConfig()
         config.options().copyDefaults(true)
@@ -129,13 +153,17 @@ class Plugin : JavaPlugin() {
         UserAliasConfig.load(this)
     }
 
-    // Log only if debug config is true
+    /**
+     * Sends a log message to console if the DEBUG flag in config.yml is true
+     */
     fun logDebug(msg: String) {
         if (!Config.DEBUG) return
-        logger.info(msg)
+        logger.info("[DiscordBridge] $msg")
     }
 
-    // Get a list of usernames of players who are online
+    /**
+     * @return a list of names of all players currently on the Minecraft server
+     */
     fun getOnlinePlayers(): List<String> {
         val names: MutableList<String> = mutableListOf()
         val players = server.onlinePlayers.toTypedArray()
@@ -143,7 +171,13 @@ class Plugin : JavaPlugin() {
         return names.toList()
     }
 
-    // Open a request to link a Minecraft user with a Discord user
+    /**
+     * Opens an alias link request and sends it to the target Discord user
+     *
+     * @param player the Minecraft player that initiated the request
+     * @param discriminator the Discord username+discriminator of the target Discord user
+     * @return a Discord Member object, or null if no matching member was found
+     */
     fun registerUserRequest(player: Player, discriminator: String): Member? {
         val users = Connection.listUsers()
         val found: Member = users.find { it.user.name + "#" + it.user.discriminator == discriminator } ?: return null
@@ -158,7 +192,9 @@ class Plugin : JavaPlugin() {
         return found
     }
 
-    // Return a formatted string listing the Discord IDs of all Discord users in the relay channel
+    /**
+     * @return a formatted string listing the Discord IDs of all Discord users in the relay channel
+     */
     fun getDiscordMembersAll(): String {
         val users = Connection.listUsers()
 
@@ -173,7 +209,9 @@ class Plugin : JavaPlugin() {
         return response.trim()
     }
 
-    // Return a formatted string listing all Discord users in the relay channel who are visibly available
+    /**
+     * @return a formatted string listing all Discord users in the relay channel who are online along with their statuses
+     */
     fun getDiscordMembersOnline(): String {
         val onlineUsers = Connection.listOnline()
         if (onlineUsers.isEmpty())
@@ -210,8 +248,18 @@ class Plugin : JavaPlugin() {
       Message Formatting Functions
     ===================================== */
 
-    // Converts attempted @mentions to real ones wherever possible
-    // Mentionable names MUST NOT contain spaces!
+    /**
+     * Attempts to convert all instances of "@name" into Discord @tag mentions
+     *
+     * This should work for "@<Discord server name>", "@<Minecraft username>" (if an alias is linked),
+     * and "@<Discord name + #discrminator>"
+     *
+     * NOTE: If the Discord name contains spaces, that name must be typed in this string without spaces.
+     * e.g. a member named "Discord Bridge" must be tagged as "@DiscordBridge"
+     *
+     * @param message the message to format
+     * @return the formatted message
+     */
     fun convertAtMentions(message: String): String {
         var newMessage = message
 
@@ -239,6 +287,12 @@ class Plugin : JavaPlugin() {
         return newMessage
     }
 
+    /**
+     * Attempts to de-convert all instances of Discord @tag mentions back into simple "@name" syntax
+     *
+     * @param message the message to format
+     * @return the formatted message
+     */
     fun deconvertAtMentions(message: String): String {
         var modifiedMessage = message
         for (match in Regex("""<@!(\d+)>|<@(\d+)>""").findAll(message)) {
@@ -248,8 +302,13 @@ class Plugin : JavaPlugin() {
         return modifiedMessage
     }
 
-    // Scans the string for occurrences of Minecraft names and attempts to translate them
-    // to registered Discord names, if they exist
+    /**
+     * Scans the input string for occurrences of Minecraft names in the alias registry and replaces them with
+     * their corresponding Discord aliases
+     *
+     * @param message the message to format
+     * @return the formatted message
+     */
     fun translateAliasesToDiscord(message: String): String {
         var modifiedMessage = message
         for ((mcUuid, discordId) in UserAliasConfig.aliases) {
@@ -261,8 +320,13 @@ class Plugin : JavaPlugin() {
         return modifiedMessage
     }
 
-    // Scans the string for occurrences of Discord names and attempts to translate them
-    // to registered Minecraft names, if they exist
+    /**
+     * Scans the input string for occurrences of Discord names in the alias registry and replaces them with
+     * their corresponding Minecraft aliases
+     *
+     * @param message the message to format
+     * @return the formatted message
+     */
     fun translateAliasesToMinecraft(message: String): String {
         var modifiedMessage = message
         for ((mcUuid, discordId) in UserAliasConfig.aliases) {
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/UserAliasConfig.kt b/src/main/kotlin/gg/obsidian/discordbridge/UserAliasConfig.kt
index 4186c39..2398afa 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/UserAliasConfig.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/UserAliasConfig.kt
@@ -2,9 +2,15 @@ package gg.obsidian.discordbridge
 
 import gg.obsidian.discordbridge.utils.UserAlias
 
+/**
+ * An accessor object for the users config file
+ */
 object UserAliasConfig {
     var aliases: List<UserAlias> = mutableListOf()
 
+    /**
+     * Load the stored aliases from file into memory
+     */
     fun load(plugin: Plugin) {
         val list = plugin.users.data.getList("aliases")
         if (list != null) aliases = list.checkItemsAre<UserAlias>() ?:
@@ -12,6 +18,9 @@ object UserAliasConfig {
         else mutableListOf<UserAlias>()
     }
 
+    /**
+     * Adds a new alias to the list and saves the updated list to file
+     */
     fun add(plugin: Plugin, ua: UserAlias) {
         aliases = aliases.plus(ua)
         plugin.users.data.set("aliases", aliases)
@@ -19,6 +28,9 @@ object UserAliasConfig {
         plugin.users.reloadConfig()
     }
 
+    /**
+     * Removes an alias from the list and saves the updated list to file
+     */
     fun remove(plugin: Plugin, ua: UserAlias) {
         aliases = aliases.minus(ua)
         plugin.users.data.set("aliases", aliases)
@@ -26,6 +38,9 @@ object UserAliasConfig {
         plugin.users.reloadConfig()
     }
 
+    /**
+     * A function to assert that all the items in a given list are of a specific type
+     */
     @Suppress("UNCHECKED_CAST")
     inline fun <reified T : Any> List<*>.checkItemsAre() = if (all { it is T }) this as List<T> else null
 }
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/commands/AsyncPlayerChatEventWrapper.kt b/src/main/kotlin/gg/obsidian/discordbridge/commands/AsyncPlayerChatEventWrapper.kt
index 4d36576..9166b38 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/commands/AsyncPlayerChatEventWrapper.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/commands/AsyncPlayerChatEventWrapper.kt
@@ -4,19 +4,48 @@ import gg.obsidian.discordbridge.discord.Connection
 import net.dv8tion.jda.core.entities.MessageChannel
 import org.bukkit.event.player.AsyncPlayerChatEvent
 
+/**
+ * A wrapper for Bukkit's AsyncPlayerChatEvent class
+ *
+ * @param event the underlying AsyncPlayerChatEvent instance
+ */
 class AsyncPlayerChatEventWrapper(val event: AsyncPlayerChatEvent) : IEventWrapper {
+    /**
+     * The Minecraft username of the event author
+     */
     override val senderName: String
         get() = event.player.name
+    /**
+     * The message of this event
+     */
     override val message: String
         get() = event.message
+    /**
+     * The raw message of this event
+     *
+     * This is identical to the message property for this wrapper type
+     */
     override val rawMessage: String
         get() = event.message
+    /**
+     * The Minecraft username of the sender in "@name" format
+     */
     override val senderAsMention: String
         get() = "@" + event.player.name
+    /**
+     * Returns the value at Connection.getRelayChannel()
+     * @see Connection.getRelayChannel
+     */
     override val channel: MessageChannel
         get() = Connection.getRelayChannel()!!
+    /**
+     * The message author's Minecraft UUID
+     */
     override val senderId: String
         get() = event.player.uniqueId.toString()
+    /**
+     * Always returns true for this wrapper type
+     */
     override val isFromRelayChannel: Boolean
         get() = true
 
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/commands/IBotController.kt b/src/main/kotlin/gg/obsidian/discordbridge/commands/IBotController.kt
index 52756b7..2acf55e 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/commands/IBotController.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/commands/IBotController.kt
@@ -1,5 +1,11 @@
 package gg.obsidian.discordbridge.commands
 
+/**
+ * Controls a number of commands that can be bulk applied to a BotControllerManager
+ */
 interface IBotController {
+    /**
+     * @return a short description of this IBotController's methods as seen in the Help command
+     */
     fun getDescription(): String
 }
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/commands/IEventWrapper.kt b/src/main/kotlin/gg/obsidian/discordbridge/commands/IEventWrapper.kt
index 8f586e3..5116f7c 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/commands/IEventWrapper.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/commands/IEventWrapper.kt
@@ -2,12 +2,63 @@ package gg.obsidian.discordbridge.commands
 
 import net.dv8tion.jda.core.entities.MessageChannel
 
+/**
+ * Interface for wrappers of various message event types
+ */
 interface IEventWrapper {
+    /**
+     * The name of the event author
+     */
     val senderName : String
+    /**
+     * The message in the event
+     *
+     * For MessageWrapper instances, this calls getContent()
+     *
+     * Otherwise, this is identical to rawMessage
+     */
     val message : String
+    /**
+     * The raw message in the event
+     *
+     * For MessageWrapper instances, this calls getRawContent()
+     *
+     * Otherwise, this is identical to message
+     */
     val rawMessage : String
+    /**
+     * The name of the author of the event in @tag format
+     *
+     * For MessageWrapper instances, this will return a mention tag in the form <@##########>
+     *
+     * Otherwise, this will return the player's username prefixed with '@'
+     */
     val senderAsMention : String
+    /**
+     * The originating channel of the message
+     *
+     * For MessageWrapper instances, this returns the origin channel or private channel of the message
+     *
+     * Otherwise, this returns Connection.getRelayChannel()
+     * @see gg.obsidian.discordbridge.discord.Connection.getRelayChannel
+     */
     val channel : MessageChannel
+    /**
+     * The ID string of the message author
+     *
+     * For MessageWrapper instances, this returns the author's Discord ID
+     *
+     * Otherwise, this returns the author's Minecraft UUID
+     */
     val senderId : String
+    /**
+     * Whether this message is from the channel that is relayed to Minecraft
+     *
+     * For MessageWrapper instances, this is true if the inner event's getChannel() is equal to
+     * Connection.getRelayChannel(), and false otherwise
+     * @see gg.obsidian.discordbridge.discord.Connection.getRelayChannel
+     *
+     * Otherwise, this always returns true
+     */
     val isFromRelayChannel: Boolean
 }
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/commands/MessageWrapper.kt b/src/main/kotlin/gg/obsidian/discordbridge/commands/MessageWrapper.kt
index 65be83e..c00ff01 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/commands/MessageWrapper.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/commands/MessageWrapper.kt
@@ -5,29 +5,63 @@ import net.dv8tion.jda.core.entities.ChannelType
 import net.dv8tion.jda.core.entities.Message
 import net.dv8tion.jda.core.entities.MessageChannel
 
+/**
+ * A wrapper for JDA's Message class
+ *
+ * @param originalMessage the underlying Message instance
+ */
 class MessageWrapper(val originalMessage: Message) : IEventWrapper {
 
+    /**
+     * Returns a formatted mention tag in the form <@##########>
+     */
     override val senderAsMention: String
         get() = originalMessage.author.asMention
 
+    /**
+     * Returns the channel in which this event was sent
+     */
     override val channel: MessageChannel
         get() = originalMessage.channel
 
+    /**
+     * Whether this message was sent from the relay channel
+     *
+     * Returns true if the underlying message's getChannel() is equal to
+     * Connection.getRelayChannel(), false otherwise
+     * @see gg.obsidian.discordbridge.discord.Connection.getRelayChannel
+     */
     override val isFromRelayChannel: Boolean
         get() = if (originalMessage.isFromType(ChannelType.PRIVATE)) false
                 else originalMessage.guild.id == Config.SERVER_ID
                 && originalMessage.isFromType(ChannelType.TEXT)
                 && originalMessage.textChannel.name.equals(Config.CHANNEL, true)
 
+    /**
+     * The message of this event
+     *
+     * This is equivalent to Message.getContent()
+     */
     override val message: String
         get() = originalMessage.content
 
+    /**
+     * The raw message of this event
+     *
+     * This is equivalent to Message.getRawContent()
+     */
     override val rawMessage: String
         get() = originalMessage.rawContent
 
+    /**
+     * The visible server name of the author of the event
+     */
     override val senderName: String
         get() = originalMessage.author.name
 
+    /**
+     * The Discord ID of the author
+     */
     override val senderId: String
         get() = originalMessage.author.id
 
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/commands/MinecraftCommandWrapper.kt b/src/main/kotlin/gg/obsidian/discordbridge/commands/MinecraftCommandWrapper.kt
index 9a863ca..141817b 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/commands/MinecraftCommandWrapper.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/commands/MinecraftCommandWrapper.kt
@@ -6,20 +6,55 @@ import org.bukkit.command.Command
 import org.bukkit.command.CommandSender
 import org.bukkit.entity.Player
 
+/**
+ * A wrapper for the parameters passed to onCommand() in Bukkit's CommandExecutor class
+ *
+ * @param sender the sender of the command
+ * @param command the command that was invoked
+ * @param args an array of argument strings passed to the command
+ */
 class MinecraftCommandWrapper(val sender: CommandSender, val command: Command,
                               val args: Array<out String>) : IEventWrapper {
+    /**
+     * The Minecraft username of the command sender
+     *
+     * Returns "Console" if the command was sent from the server console
+     */
     override val senderName: String
         get() = if (sender is Player) sender.name else "Console"
+    /**
+     * Returns a space-delimited string of all the arguments passed with the command
+     *
+     * This is identical to rawMessage
+     */
     override val message: String
         get() = args.joinToString(separator = " ")
+    /**
+     * Returns a space-delimited string of all the arguments passed with the command
+     *
+     * This is identical to message
+     */
     override val rawMessage: String
         get() = args.joinToString(separator = " ")
+    /**
+     * The Minecraft username of the command sender in "@name" format
+     */
     override val senderAsMention: String
         get() = "@${sender.name}"
+    /**
+     * Returns the value at Connection.getRelayChannel()
+     * @see Connection.getRelayChannel
+     */
     override val channel: MessageChannel
         get() = Connection.getRelayChannel()!!
+    /**
+     * The command sender's Minecraft UUID
+     */
     override val senderId: String
         get() = (sender as? Player)?.uniqueId?.toString() ?: ""
+    /**
+     * Always returns true for this wrapper type
+     */
     override val isFromRelayChannel: Boolean
         get() = true
 
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/FunCommandsController.kt b/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/FunCommandsController.kt
index a63f777..1214aa5 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/FunCommandsController.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/FunCommandsController.kt
@@ -11,11 +11,24 @@ import gg.obsidian.discordbridge.utils.Rating
 import gg.obsidian.discordbridge.utils.Respect
 import java.util.*
 
+/**
+ * Controller for fun commands that have no purpose outside of amusement
+ *
+ * @param plugin a reference to the base Plugin object
+ */
 class FunCommandsController(val plugin: Plugin) : IBotController {
 
+    /**
+     * @return a description of this class of commands, used in the Help command
+     */
     override fun getDescription(): String = ":balloon:  **FUN** - Every bot has to have them!"
 
-    // 8BALL - consult the Magic 8-Ball to answer your yes or no questions
+    /**
+     * Answers a yes/no question
+     *
+     * @param event the incoming event object
+     * @return the response string
+     */
     @BotCommand(name = "8ball", usage = "<question>", description = "Consult the Magic 8 Ball")
     @TaggedResponse
     private fun eightBall(event: IEventWrapper): String {
@@ -25,7 +38,13 @@ class FunCommandsController(val plugin: Plugin) : IBotController {
         return responses[rand]
     }
 
-    // CHOOSE - chooses between some number of options
+    /**
+     * Makes a selection among an arbitrary number of supplied choices
+     *
+     * @param event the incoming event object
+     * @param query a delimited string of the options to choose from
+     * @return the response string
+     */
     @BotCommand(name = "choose", usage = "<option>, <option>, ... (delimiters include ',', 'or', '|')",
             description = "Have the bot choose between given options")
     @TaggedResponse
@@ -36,7 +55,12 @@ class FunCommandsController(val plugin: Plugin) : IBotController {
         return "I pick '${choices[rand]}'"
     }
 
-    // F - press F to pay respects!
+    /**
+     * Press F to pay respects
+     *
+     * @param event the incoming event object
+     * @return the response string
+     */
     @BotCommand(usage="", description = "Press F to pay respects")
     private fun f(event: IEventWrapper): String {
         plugin.logDebug("user ${event.senderName}} pays respects")
@@ -69,7 +93,13 @@ class FunCommandsController(val plugin: Plugin) : IBotController {
         return msg
     }
 
-    // INSULT - the bot insults something
+    /**
+     * Insult someone or something
+     *
+     * @param event the incoming event object
+     * @param thingToInsult the target of the insult
+     * @return the response string
+     */
     @BotCommand(usage="<thing to insult>", description = "Make the bot insult something for you")
     private fun insult(event: IEventWrapper, thingToInsult: String): String {
         plugin.logDebug("user ${event.senderName} requests an insult against '$thingToInsult'")
@@ -78,7 +108,13 @@ class FunCommandsController(val plugin: Plugin) : IBotController {
         return "${event.senderAsMention} \u27A4 $thingToInsult | ${responses[rand]}"
     }
 
-    // RATE - the bot rates something
+    /**
+     * Rate something on a scale specified by the config
+     *
+     * @param event the incoming event object
+     * @param thingToRate the thing that will receive the rating
+     * @return the response string
+     */
     @BotCommand(usage="<thing to be rated>", description = "Have the bot rate something for you")
     @TaggedResponse
     private fun rate(event: IEventWrapper, thingToRate: String): String {
@@ -119,7 +155,13 @@ class FunCommandsController(val plugin: Plugin) : IBotController {
         return found.message.replace("%m", thingToBeRated).replace("%r", "$rating/$rateOutOf")
     }
 
-    // ROLL - roll a die for a random number
+    /**
+     * Roll a die with a specified number of sides
+     *
+     * @param event the incoming event object
+     * @param sides the number of sides of the die
+     * @return the response string
+     */
     @BotCommand(name = "roll", usage = "<sides>", description = "Roll a die for a random number")
     @TaggedResponse
     private fun roll(event: IEventWrapper, sides: Int): String {
@@ -132,7 +174,13 @@ class FunCommandsController(val plugin: Plugin) : IBotController {
         return "You rolled... $rand"
     }
 
-    // TALK - directly speak to Cleverbot (useful for not accidentally invoking other commands)
+    /**
+     * Talk to Cleverbot
+     *
+     * @param event the incoming event object
+     * @param query the message to send to Cleverbot
+     * @return the response string
+     */
     @TaggedResponse
     @BotCommand(usage="<say something>", description = "Say something to Cleverbot")
     private fun talk(event: IEventWrapper, query: String): String {
@@ -145,6 +193,9 @@ class FunCommandsController(val plugin: Plugin) : IBotController {
         return bot.response
     }
 
+    /**
+     * Shortcut method for adding "or <prefix>help " to the CommandNotFound output if a COMMAND_PREFIX is set in config
+     */
     @Suppress("UNCHECKED_CAST")
     private inline fun <reified T : Any> List<*>.checkItemsAre() = if (all { it is T }) this as List<T> else null
 }
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/UtilCommandsController.kt b/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/UtilCommandsController.kt
index 63a8f25..e495b86 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/UtilCommandsController.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/UtilCommandsController.kt
@@ -11,11 +11,24 @@ import net.dv8tion.jda.core.entities.ChannelType
 import org.bukkit.entity.Player
 import org.bukkit.ChatColor as CC
 
+/**
+ * Controller for utility commands that configure the way the bot works
+ *
+ * @param plugin a reference to the base Plugin object
+ */
 class UtilCommandsController(val plugin: Plugin) : IBotController {
 
+    /**
+     * @return a short description of this IBotController's methods as seen in the Help command
+     */
     override fun getDescription(): String = ":wrench:  **UTIL** - Utility commands"
 
-    // CONFIRM - Confirm an alias request
+    /**
+     * Confirms an open request to link aliases with a Minecraft account
+     *
+     * @param event the incoming event object
+     * @return a status message if the event is type MessageWrapper and is sent via DM, null otherwise
+     */
     @BotCommand(usage="", description="Confirm an alias link request", relayTriggerMessage = false)
     @DiscordExclusiveCommand
     @PrivateResponse
@@ -34,7 +47,12 @@ class UtilCommandsController(val plugin: Plugin) : IBotController {
         return "Successfully linked aliases!"
     }
 
-    // DENY - Deny an alias request
+    /**
+     * Denies an open request to link aliases with a Minecraft account
+     *
+     * @param event the incoming event object
+     * @return a status message if the event is type MessageWrapper and is sent via DM, null otherwise
+     */
     @BotCommand(usage="", description="Deny an alias link request", relayTriggerMessage = false)
     @DiscordExclusiveCommand
     @PrivateResponse
@@ -52,7 +70,23 @@ class UtilCommandsController(val plugin: Plugin) : IBotController {
         return "The alias link request has been cancelled."
     }
 
-    @BotCommand(usage="<reload|get|alias> [args...]", description = "For in-game functions", relayTriggerMessage = false)
+    /**
+     * A supercommand for utility functions available within Minecraft
+     *
+     * reload - Refreshes the JDA connection and reloads configs
+     *
+     * linkalias - sends a request to a specified Discord user to link aliases for username translation
+     *
+     * listmembers - lists all the members in the Discord relay channel. Can specify "all" to get all members, or
+     * "online" to list only online members and their availability statuses
+     *
+     * unlinkalias - silently breaks an alias link with a Discord user if one exists
+     *
+     * @param event the incoming event object
+     * @param argString a space-delimited string of subcommands to execute
+     * @return this command always returns null
+     */
+    @BotCommand(usage="<reload|linkalias|listmembers|unlinkalias> [args...]", description = "For in-game functions", relayTriggerMessage = false)
     @MinecraftExclusiveCommand
     @PrivateResponse
     private fun discord(event: IEventWrapper, argString: String): String? {
@@ -146,6 +180,13 @@ class UtilCommandsController(val plugin: Plugin) : IBotController {
         return null
     }
 
+    /**
+     * Displays a pretty list of available commands to the invoker
+     *
+     * @param event the incoming event object
+     * @param commands a map of all commands that can be called by the invoker in the given medium indexed by name
+     * @param instances a map of IBotController instances accessed by their Java classes
+     */
     @BotCommand(usage="", description="You just used it", relayTriggerMessage = false)
     @ChatExclusiveCommand
     @PrivateResponse
@@ -187,7 +228,11 @@ class UtilCommandsController(val plugin: Plugin) : IBotController {
         }
     }
 
-    // SERVERLIST - List all players currently online on the server
+    /**
+     * Displays a pretty list of all currently logged-in Minecraft players
+     *
+     * @param event the incoming event object
+     */
     @DiscordExclusiveCommand
     @BotCommand(usage="", description = "List all Minecraft players currently online on the server",
             relayTriggerMessage = false)
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/discord/Connection.kt b/src/main/kotlin/gg/obsidian/discordbridge/discord/Connection.kt
index dcff0d4..41de582 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/discord/Connection.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/discord/Connection.kt
@@ -7,6 +7,11 @@ import net.dv8tion.jda.core.JDA
 import net.dv8tion.jda.core.JDABuilder
 import net.dv8tion.jda.core.entities.*
 
+/**
+ * Maintains the connection to Discord's servers. All calls to and from the Discord API are passed through this object.
+ *
+ * This object is designed to run asynchronously on its own thread.
+ */
 object Connection: Runnable {
     lateinit var plugin: Plugin
     lateinit var JDA: JDA
@@ -14,6 +19,9 @@ object Connection: Runnable {
     var server: Guild? = null
     var channel: TextChannel? = null
 
+    /**
+     * Starts the connection
+     */
     override fun run() {
         try {
             connect()
@@ -22,12 +30,23 @@ object Connection: Runnable {
         }
     }
 
+    /**
+     * Gets the channel instance of the designated relay channel specified in the config
+     *
+     * @return the relay TextChannel, null if the value could not be read
+     */
     fun getRelayChannel(): TextChannel? {
         server = if (server == null) getServerById(Config.SERVER_ID) else server
         channel = if (channel == null) getGroupByName(server!!, Config.CHANNEL) else channel
         return channel
     }
 
+    /**
+     * Sends a message to Discord
+     *
+     * @param message the message to send
+     * @param toChannel the channel to send the message to
+     */
     fun send(message: String, toChannel: MessageChannel?) {
         if (toChannel == null) {
             plugin.logger.severe("Could not send message to Discord: Channel is not defined")
@@ -36,6 +55,9 @@ object Connection: Runnable {
         toChannel.sendMessage(message).queue()
     }
 
+    /**
+     * Shuts down the current JDA instance and creates a new one
+     */
     fun reconnect(callback: Runnable) {
         //disconnect
         if (Config.ANNOUNCE_SERVER_START_STOP)
@@ -50,18 +72,31 @@ object Connection: Runnable {
         callback.run()
     }
 
+    /**
+     * Gets a list of users in the relay channel
+     *
+     * @return a List of Member objects
+     */
     fun listUsers(): List<Member> {
         channel = getRelayChannel()
         if (channel == null) return mutableListOf()
         return channel!!.members
     }
 
+    /**
+     * Gets a list of members in the relay channel who are not offline
+     *
+     * @return a List of Member objects
+     */
     fun listOnline(): List<Member> {
         channel = getRelayChannel()
         if (channel != null) return channel!!.members
         return mutableListOf()
     }
 
+    /**
+     * Builds a JDA instance to connect to the Discord API
+     */
     private fun connect() {
         var builder = JDABuilder(AccountType.BOT).setAudioEnabled(true)
         builder = builder.setToken(Config.TOKEN)
@@ -73,10 +108,23 @@ object Connection: Runnable {
         JDA.presence.game = Game.of("Minecraft ${plugin.server.bukkitVersion.split("-")[0]}")
     }
 
+    /**
+     * Fetches a text channel given its Guild and its name
+     *
+     * @param server the Guild object of the server the channel is on
+     * @param name the name of the channel
+     * @return the channel's TextChannel object, or null if it couldn't be found
+     */
     private fun getGroupByName(server: Guild, name: String): TextChannel? {
         return server.textChannels.firstOrNull { it.name == name }
     }
 
+    /**
+     * Fetches a server given its unique ID
+     *
+     * @param id the unique ID of the server
+     * @return the server's Guild object, or null if it couldn't be found
+     */
     private fun getServerById(id: String): Guild? {
         return JDA.guilds.firstOrNull { it.id.equals(id, true) }
     }
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/discord/Listener.kt b/src/main/kotlin/gg/obsidian/discordbridge/discord/Listener.kt
index 1c316eb..adce7a5 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/discord/Listener.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/discord/Listener.kt
@@ -8,6 +8,11 @@ import gg.obsidian.discordbridge.commands.controllers.UtilCommandsController
 import net.dv8tion.jda.core.events.message.MessageReceivedEvent
 import net.dv8tion.jda.core.hooks.ListenerAdapter
 
+/**
+ * Listens for events from Discord
+ *
+ * @param plugin a reference to the base Plugin object
+ */
 class Listener(val plugin: Plugin) : ListenerAdapter() {
 
     val controllerManager = BotControllerManager(plugin)
@@ -17,6 +22,11 @@ class Listener(val plugin: Plugin) : ListenerAdapter() {
         controllerManager.registerController(UtilCommandsController(plugin), discordExclusive = true, chatExclusive = true)
     }
 
+    /**
+     * Callback for captured messages
+     *
+     * @param event the MessageReceivedEvent object
+     */
     override fun onMessageReceived(event: MessageReceivedEvent) {
         plugin.logDebug("Received message ${event.message.id} from Discord - ${event.message.rawContent}")
 
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/minecraft/CommandListener.kt b/src/main/kotlin/gg/obsidian/discordbridge/minecraft/CommandListener.kt
index 0deee23..ce806d9 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/minecraft/CommandListener.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/minecraft/CommandListener.kt
@@ -9,6 +9,11 @@ import org.bukkit.command.Command
 import org.bukkit.command.CommandExecutor
 import org.bukkit.command.CommandSender
 
+/**
+ * Listens for commands sent to the Minecraft server
+ *
+ * @param plugin a reference to the base Plugin object
+ */
 class CommandListener(val plugin: Plugin) : CommandExecutor {
 
     val controllerManager = BotControllerManager(plugin)
@@ -18,6 +23,15 @@ class CommandListener(val plugin: Plugin) : CommandExecutor {
         controllerManager.registerController(UtilCommandsController(plugin), minecraftExclusive = true)
     }
 
+    /**
+     * Callback for a captured command event
+     *
+     * @param sender the sender of the command
+     * @param command the command that was captured
+     * @param label no idea lol
+     * @param args an array of argument strings passed to the command
+     * @return whether the command "succeeded". this returns false, the default usage message will be sent to the sender
+     */
     override fun onCommand(sender: CommandSender, command: Command, label: String, args: Array<out String>): Boolean {
         return controllerManager.dispatchMessage(MinecraftCommandWrapper(sender, command, args))
     }
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/minecraft/EventListener.kt b/src/main/kotlin/gg/obsidian/discordbridge/minecraft/EventListener.kt
index 0a2cfb2..72c1c13 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/minecraft/EventListener.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/minecraft/EventListener.kt
@@ -21,8 +21,14 @@ import org.bukkit.event.player.AsyncPlayerChatEvent
 import org.bukkit.event.player.PlayerJoinEvent
 import org.bukkit.event.player.PlayerQuitEvent
 import org.dynmap.DynmapWebChatEvent
+import java.lang.reflect.Method
 import org.bukkit.ChatColor as CC
 
+/**
+ * Listens for the various event triggers passed through Bukkit
+ *
+ * @param plugin a reference to the base Plugin object
+ */
 class EventListener(val plugin: Plugin): Listener {
 
     val controllerManager = BotControllerManager(plugin)
@@ -32,6 +38,11 @@ class EventListener(val plugin: Plugin): Listener {
         controllerManager.registerController(UtilCommandsController(plugin), chatExclusive = true)
     }
 
+    /**
+     * Callback for when a chat event is received
+     *
+     * @param event the AsyncPlayerChatEvent
+     */
     @EventHandler(priority = EventPriority.MONITOR)
     fun onChat(event: AsyncPlayerChatEvent) {
         plugin.logDebug("Received a chat event from ${event.player.name}: ${event.message}")
@@ -40,6 +51,7 @@ class EventListener(val plugin: Plugin): Listener {
         if (event.player.hasMetadata("vanished") && event.player.getMetadata("vanished")[0].asBoolean() &&
                 !Config.IF_VANISHED_CHAT) return
 
+        // Emoticons!
         event.message = event.message.replace(":lenny:", "( \u0361\u00B0 \u035C\u0296 \u0361\u00B0)")
                 .replace(":tableflip:", "(\u256F\u00B0\u25A1\u00B0\uFF09\u256F\uFE35 \u253B\u2501\u253B")
                 .replace(":unflip:", "\u252C\u2500\u2500\u252C \u30CE( \u309C-\u309C\u30CE)")
@@ -64,53 +76,103 @@ class EventListener(val plugin: Plugin): Listener {
         plugin.logger.info("Seralized! (synchronous)")
     }
 
+    /**
+     * Callback for when a chat event is received from Dynmap, if a Dynmap is running
+     *
+     * @param event the DynmapWebChatEvent
+     */
     @EventHandler(priority = EventPriority.MONITOR)
     fun onDynmapCatEvent(event: DynmapWebChatEvent) {
         plugin.sendToDiscord(plugin.translateAliasesToDiscord(event.message.toDiscordChatMessage(event.name, "Dynmap")), Connection.getRelayChannel())
     }
 
+    /**
+     * Callback for when a player logs in to the server
+     *
+     * @param event the PlayerJoinEvent
+     */
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     fun onPlayerJoin(event: PlayerJoinEvent) {
         val player = event.player
         val username = event.player.name.stripColor()
+        var worldname = event.player.world.name
 
         plugin.logDebug("Received a join event for $username")
         if (!Config.MESSAGES_JOIN) return
         if (player.hasMetadata("vanished") && player.getMetadata("vanished")[0].asBoolean() &&
                 !Config.IF_VANISHED_JOIN) return
 
-        var formattedMessage = player.toDiscordPlayerJoin()
+        // Get world alias if Multiverse is installed
+        if (plugin.isMultiverseInstalled) {
+            val worldProperties = plugin.worlds!!.data.get("worlds.$worldname")
+            val cls = Class.forName("com.onarandombox.MultiverseCore.WorldProperties")
+            val meth: Method = cls.getMethod("getAlias")
+            val alias = meth.invoke(worldProperties)
+            if (alias is String) worldname = alias
+        }
+
+        var formattedMessage = player.toDiscordPlayerJoin(worldname)
         formattedMessage = plugin.translateAliasesToDiscord(formattedMessage)
         plugin.sendToDiscord(formattedMessage, Connection.getRelayChannel())
     }
 
+    /**
+     * Callback for when a player logs out of the server
+     *
+     * @param event the PlayerQuitEvent
+     */
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     fun onPlayerQuit(event: PlayerQuitEvent) {
         val player = event.player
         val username = event.player.name.stripColor()
+        var worldname = event.player.world.name
 
         plugin.logDebug("Received a leave event for $username")
         if (!Config.MESSAGES_LEAVE) return
         if (player.hasMetadata("vanished") && player.getMetadata("vanished")[0].asBoolean() &&
                 !Config.IF_VANISHED_LEAVE) return
 
-        var formattedMessage = player.toDiscordPlayerLeave()
+        // Get world alias if Multiverse is installed
+        if (plugin.isMultiverseInstalled) {
+            val worldProperties = plugin.worlds!!.data.get("worlds.$worldname")
+            val cls = Class.forName("com.onarandombox.MultiverseCore.WorldProperties")
+            val meth: Method = cls.getMethod("getAlias")
+            val alias = meth.invoke(worldProperties)
+            if (alias is String) worldname = alias
+        }
+
+        var formattedMessage = player.toDiscordPlayerLeave(worldname)
         formattedMessage = plugin.translateAliasesToDiscord(formattedMessage)
         plugin.sendToDiscord(formattedMessage, Connection.getRelayChannel())
     }
 
+    /**
+     * Callback for when a player dies
+     *
+     * @param event the PlayerDeathEvent
+     */
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     fun onPlayerDeath(event: PlayerDeathEvent) {
         val player = event.entity
         val username = event.entity.name.stripColor()
         val deathMessage = event.deathMessage
+        var worldname = event.entity.world.name
 
         plugin.logDebug("Received a death event for $username")
         if (!Config.MESSAGES_DEATH) return
         if (player.hasMetadata("vanished") && player.getMetadata("vanished")[0].asBoolean() &&
                 !Config.IF_VANISHED_DEATH) return
 
-        var formattedMessage = deathMessage.toDiscordPlayerDeath(username)
+        // Get world alias if Multiverse is installed
+        if (plugin.isMultiverseInstalled) {
+            val worldProperties = plugin.worlds!!.data.get("worlds.$worldname")
+            val cls = Class.forName("com.onarandombox.MultiverseCore.WorldProperties")
+            val meth: Method = cls.getMethod("getAlias")
+            val alias = meth.invoke(worldProperties)
+            if (alias is String) worldname = alias
+        }
+
+        var formattedMessage = deathMessage.toDiscordPlayerDeath(username, worldname)
         formattedMessage = plugin.translateAliasesToDiscord(formattedMessage)
         plugin.sendToDiscord(formattedMessage, Connection.getRelayChannel())
     }
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/utils/MarkdownToMinecraftSeralizer.kt b/src/main/kotlin/gg/obsidian/discordbridge/utils/MarkdownToMinecraftSeralizer.kt
index 722277e..f56f1a7 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/utils/MarkdownToMinecraftSeralizer.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/utils/MarkdownToMinecraftSeralizer.kt
@@ -4,10 +4,20 @@ import org.parboiled.common.Preconditions
 import org.pegdown.Printer
 import org.pegdown.ast.*
 
+/**
+ * This class will descend the parse tree created by pegdown and convert basic Discord Markdown syntax into equivalent
+ * Minecraft formatting codes
+ */
 class MarkdownToMinecraftSeralizer : Visitor {
 
     private var printer = Printer()
 
+    /**
+     * Descends a parse tree and returns a formatted string
+     *
+     * @param astRoot = the root node of the parse tree
+     * @return a string formatted with Minecraft formatting symbols
+     */
     fun toMinecraft(astRoot: RootNode): String {
         Preconditions.checkArgNotNull<Any>(astRoot, "astRoot")
         astRoot.accept(this)
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/utils/Rating.kt b/src/main/kotlin/gg/obsidian/discordbridge/utils/Rating.kt
index f329f89..2c9dc98 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/utils/Rating.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/utils/Rating.kt
@@ -4,6 +4,13 @@ import org.bukkit.configuration.serialization.ConfigurationSerializable
 import org.bukkit.configuration.serialization.SerializableAs
 
 //TODO: Make null safe
+/**
+ * Represents a Rating entry in rate.yml
+ *
+ * @param message the rating message template
+ * @param low the lower bound of ratings that will trigger this message
+ * @param high the upper bound of ratings that will trigger this message
+ */
 @SerializableAs("Rating")
 data class Rating(val message: String = "%u - I rate %m %r", val low: Double = 0.0, val high: Double = 0.0): ConfigurationSerializable {
     @Suppress("unused")
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/utils/Respect.kt b/src/main/kotlin/gg/obsidian/discordbridge/utils/Respect.kt
index ed0a6e8..9313bb2 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/utils/Respect.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/utils/Respect.kt
@@ -4,6 +4,13 @@ import org.bukkit.configuration.serialization.ConfigurationSerializable
 import org.bukkit.configuration.serialization.SerializableAs
 
 //TODO: make null safe
+/**
+ * Represents a Respect entry in f.yml
+ *
+ * @param message the respects message template
+ * @param count the number of respects that will be paid
+ * @param weight the probability weight that this entry will be selected
+ */
 @SerializableAs("Respect")
 data class Respect(val message: String = "%u solemnly pays respect!", val count: Int = 1, val weight: Int = 1): ConfigurationSerializable {
     @Suppress("unused")
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/utils/Script.kt b/src/main/kotlin/gg/obsidian/discordbridge/utils/Script.kt
index 6406471..b46d7cb 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/utils/Script.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/utils/Script.kt
@@ -3,6 +3,17 @@ package gg.obsidian.discordbridge.utils
 import org.bukkit.configuration.serialization.ConfigurationSerializable
 import org.bukkit.configuration.serialization.SerializableAs
 
+/**
+ * Represents a Script entry in script.yml
+ *
+ * @param triggerMC the string that, if sent from Minecraft, will trigger this response
+ * @param triggerDis the string that, if sent from Discord, will trigger this response
+ * @param responseMC the response that will be broadcast to Minecraft if this script is triggered
+ * @param responseDis the response that will be broadcast to Discord if this script is triggered
+ * @param caseSensitive whether the trigger strings are case sensitive
+ * @param requiresMention whether the trigger strings can only be activated by @tag mentioning the bot
+ * @param startsWith whether the trigger strings only need to match the start of the string
+ */
 @SerializableAs("Script")
 data class Script(val triggerMC: String?, val triggerDis: String?, val responseMC: String?, val responseDis: String?,
                   val caseSensitive: Boolean?, val requiresMention: Boolean?,
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/utils/UserAlias.kt b/src/main/kotlin/gg/obsidian/discordbridge/utils/UserAlias.kt
index 8837eb4..8331546 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/utils/UserAlias.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/utils/UserAlias.kt
@@ -5,6 +5,12 @@ import org.bukkit.configuration.serialization.SerializableAs
 import java.util.*
 
 //TODO: make null safe
+/**
+ * Represents a UserAlias entry in usernames.yml
+ *
+ * @param mcUuid the UUID of the Minecraft account linked to this alias
+ * @param discordId the unique Discord ID of the Discord account linked to this alias
+ */
 @SerializableAs("UserAlias")
 data class UserAlias(val mcUuid: UUID, val discordId: String): ConfigurationSerializable {
     @Suppress("unused")
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/utils/UtilFunctions.kt b/src/main/kotlin/gg/obsidian/discordbridge/utils/UtilFunctions.kt
index b36d33c..ca4668c 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/utils/UtilFunctions.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/utils/UtilFunctions.kt
@@ -4,39 +4,88 @@ import gg.obsidian.discordbridge.Config
 import org.bukkit.ChatColor
 import org.bukkit.entity.Player
 
+/**
+ * Various utility functions
+ */
 object UtilFunctions {
 
+    /**
+     * @return the input string with all whitespace removed
+     */
     @JvmStatic
     fun String.noSpace() = this.replace(Regex("""\s+"""), "")
 
+    /**
+     * @return the input string with any Minecraft formatting codes removed
+     */
     @JvmStatic
     fun String.stripColor(): String = ChatColor.stripColor(this)
 
+    /**
+     * Converts a string to the Minecraft chat message template defined in config.yml
+     *
+     * @param alias the name of the message author
+     * @return the formatted string
+     */
     @JvmStatic
     fun String.toMinecraftChatMessage(alias: String): String {
-        return formatMessage(Config.TEMPLATES_MINECRAFT_CHAT_MESSAGE, msg = this, u = alias)
+        return formatMessage(Config.TEMPLATES_MINECRAFT_CHAT_MESSAGE, msg = this, u = alias, w = "Discord")
     }
 
+    /**
+     * Converts a string to the Discord chat message template defined in config.yml
+     *
+     * @param username the username of the message author
+     * @param worldName the name of the world the author was in when the message was sent
+     * @return the formatted string
+     */
     @JvmStatic
     fun String.toDiscordChatMessage(username: String, worldName: String): String {
         return formatMessage(Config.TEMPLATES_DISCORD_CHAT_MESSAGE, msg = this, u = username, w = worldName)
     }
 
+    /**
+     * Converts a string to the Discord player join message template defined in config.yml
+     *
+     * @param worldName the name of the world where the player joined
+     * @return the formatted string
+     */
     @JvmStatic
-    fun Player.toDiscordPlayerJoin(): String {
-        return formatMessage(Config.TEMPLATES_DISCORD_PLAYER_JOIN, u = this.name.stripColor())
+    fun Player.toDiscordPlayerJoin(worldName: String): String {
+        return formatMessage(Config.TEMPLATES_DISCORD_PLAYER_JOIN, u = this.name.stripColor(), w = worldName)
     }
 
+    /**
+     * Converts a string to the Discord player leave message template defined in config.yml
+     *
+     * @param worldName the name of the world the player has left
+     * @return the formatted string
+     */
     @JvmStatic
-    fun Player.toDiscordPlayerLeave(): String {
-        return formatMessage(Config.TEMPLATES_DISCORD_PLAYER_LEAVE, u = this.name.stripColor())
+    fun Player.toDiscordPlayerLeave(worldName: String): String {
+        return formatMessage(Config.TEMPLATES_DISCORD_PLAYER_LEAVE, u = this.name.stripColor(), w = worldName)
     }
 
+    /**
+     * Converts a string to the Discord player death message template defined in config.yml
+     *
+     * @param username the name of the player that died
+     * @param worldName the world where the player died
+     * @return the formatted string
+     */
     @JvmStatic
-    fun String.toDiscordPlayerDeath(username: String): String {
-        return formatMessage(Config.TEMPLATES_DISCORD_CHAT_MESSAGE, msg = this, u = username)
+    fun String.toDiscordPlayerDeath(username: String, worldName: String): String {
+        return formatMessage(Config.TEMPLATES_DISCORD_CHAT_MESSAGE, msg = this, u = username, w = worldName)
     }
 
+    /**
+     * Performs all the replacements for the "to" conversion functions
+     *
+     * @param template the template string
+     * @param msg the raw message
+     * @param u the name of the author or target player
+     * @param w the world name
+     */
     @JvmStatic
     private fun formatMessage(template: String, msg: String = "N/A", u: String = "N/A", w: String = "N/A"): String {
         var out = org.bukkit.ChatColor.translateAlternateColorCodes('&', template)
diff --git a/todo b/todo
index 536245b..34b9406 100644
--- a/todo
+++ b/todo
@@ -1,8 +1,10 @@
-Attempt to add Minecraft in-chat formatting
-Unfuck !!help in Minecraft
-Consider making !!help and !!serverlist reply using embeds
+Things to fix:
+- Unfuck !!help in Minecraft
+- Make util data classes null safe
 
-markdown parser is sending selector symbols to Discord
-markdown parser is removing the square brackets from "[Discord]" when relaying Discord chat messages
+Things to try:
+- Consider making !!help and !!serverlist reply using embeds
 
-remove logging when done
\ No newline at end of file
+Things to add:
+- Fix image embeds
+- Admin commands
\ No newline at end of file