From b270cde4ca7c7b5f8df34389bdd97df4cbb7c53b Mon Sep 17 00:00:00 2001 From: ryandw11 <> Date: Mon, 25 Mar 2019 19:40:37 -0700 Subject: [PATCH] Init Intital Commit --- channel.yml | 31 + config.yml | 167 +++++ lang.yml | 29 + plugin.yml | 34 + src/me/ryandw11/ultrachat/UltraChat.java | 393 +++++++++++ src/me/ryandw11/ultrachat/api/ChatMode.java | 10 + .../ultrachat/api/GlobalChatEvent.java | 50 ++ src/me/ryandw11/ultrachat/api/JSON.java | 78 ++ .../ryandw11/ultrachat/api/JsonChatEvent.java | 67 ++ src/me/ryandw11/ultrachat/api/Lang.java | 84 +++ .../ryandw11/ultrachat/api/UltraChatAPI.java | 312 ++++++++ src/me/ryandw11/ultrachat/api/Util.java | 49 ++ .../ultrachat/api/WorldChatEvent.java | 67 ++ .../ultrachat/commands/ChannelCmd.java | 84 +++ .../ultrachat/commands/ChatCommand.java | 284 ++++++++ .../commands/CommandTabCompleter.java | 50 ++ .../ryandw11/ultrachat/commands/Global.java | 71 ++ .../ultrachat/commands/SpyCommand.java | 78 ++ .../ultrachat/commands/StaffChat.java | 60 ++ .../ultrachat/commands/StaffChatToggle.java | 44 ++ src/me/ryandw11/ultrachat/commands/World.java | 74 ++ .../ultrachat/formatting/Channels.java | 44 ++ .../ultrachat/formatting/Chat_Json.java | 99 +++ .../ryandw11/ultrachat/formatting/Normal.java | 67 ++ .../formatting/PlayerFormatting.java | 65 ++ .../ryandw11/ultrachat/formatting/Range.java | 71 ++ src/me/ryandw11/ultrachat/gui/ColorGUI.java | 355 ++++++++++ .../ultrachat/listner/ConsoleLogChat.java | 21 + .../ultrachat/listner/JoinListner.java | 125 ++++ .../ryandw11/ultrachat/listner/NoSwear.java | 73 ++ src/me/ryandw11/ultrachat/listner/Notify.java | 49 ++ src/me/ryandw11/ultrachat/listner/Spy.java | 38 + .../ryandw11/ultrachat/listner/StopChat.java | 48 ++ .../pluginhooks/AdvancedBanMute.java | 38 + .../ultrachat/pluginhooks/EssentialsMute.java | 41 ++ src/me/ryandw11/ultrachat/util/Metrics.java | 668 ++++++++++++++++++ 36 files changed, 3918 insertions(+) create mode 100644 channel.yml create mode 100644 config.yml create mode 100644 lang.yml create mode 100644 plugin.yml create mode 100644 src/me/ryandw11/ultrachat/UltraChat.java create mode 100644 src/me/ryandw11/ultrachat/api/ChatMode.java create mode 100644 src/me/ryandw11/ultrachat/api/GlobalChatEvent.java create mode 100644 src/me/ryandw11/ultrachat/api/JSON.java create mode 100644 src/me/ryandw11/ultrachat/api/JsonChatEvent.java create mode 100644 src/me/ryandw11/ultrachat/api/Lang.java create mode 100644 src/me/ryandw11/ultrachat/api/UltraChatAPI.java create mode 100644 src/me/ryandw11/ultrachat/api/Util.java create mode 100644 src/me/ryandw11/ultrachat/api/WorldChatEvent.java create mode 100644 src/me/ryandw11/ultrachat/commands/ChannelCmd.java create mode 100644 src/me/ryandw11/ultrachat/commands/ChatCommand.java create mode 100644 src/me/ryandw11/ultrachat/commands/CommandTabCompleter.java create mode 100644 src/me/ryandw11/ultrachat/commands/Global.java create mode 100644 src/me/ryandw11/ultrachat/commands/SpyCommand.java create mode 100644 src/me/ryandw11/ultrachat/commands/StaffChat.java create mode 100644 src/me/ryandw11/ultrachat/commands/StaffChatToggle.java create mode 100644 src/me/ryandw11/ultrachat/commands/World.java create mode 100644 src/me/ryandw11/ultrachat/formatting/Channels.java create mode 100644 src/me/ryandw11/ultrachat/formatting/Chat_Json.java create mode 100644 src/me/ryandw11/ultrachat/formatting/Normal.java create mode 100644 src/me/ryandw11/ultrachat/formatting/PlayerFormatting.java create mode 100644 src/me/ryandw11/ultrachat/formatting/Range.java create mode 100644 src/me/ryandw11/ultrachat/gui/ColorGUI.java create mode 100644 src/me/ryandw11/ultrachat/listner/ConsoleLogChat.java create mode 100644 src/me/ryandw11/ultrachat/listner/JoinListner.java create mode 100644 src/me/ryandw11/ultrachat/listner/NoSwear.java create mode 100644 src/me/ryandw11/ultrachat/listner/Notify.java create mode 100644 src/me/ryandw11/ultrachat/listner/Spy.java create mode 100644 src/me/ryandw11/ultrachat/listner/StopChat.java create mode 100644 src/me/ryandw11/ultrachat/pluginhooks/AdvancedBanMute.java create mode 100644 src/me/ryandw11/ultrachat/pluginhooks/EssentialsMute.java create mode 100644 src/me/ryandw11/ultrachat/util/Metrics.java diff --git a/channel.yml b/channel.yml new file mode 100644 index 0000000..b4395c3 --- /dev/null +++ b/channel.yml @@ -0,0 +1,31 @@ +#---------------------------------------------------------------------# +# UltraChat # +# Channels # +#---------------------------------------------------------------------# +# +#Channel name {Note: it is better pratice to use lowercase} +# +#Notice: Turn the server off then edit ths config! +# +global: + #Channel prefix. + prefix: '&a[Global]&r' + #Channel permission, Use none for no permission. + permission: 'none' + #Messages from this channel will always appear no matter what channel the player is in. + always_appear: false + #This is the chat format ***Note the channel prefix is added by default. + format: '%prefix% %player% %suffix%&7>> ' + #This is the JSON format: + JSON: + - 'Wow' + - 'No Way!' +#Example Channel: +vip: + prefix: '&a[&6VIP&a]&r' + permission: 'channel.vip' + always_appear: false + format: '%prefix% %player% %suffix%&7>> ' + JSON: + - '&3Money: $&b%vault_eco_balance_fixed%' + - '&3Username: &f%player_name%' \ No newline at end of file diff --git a/config.yml b/config.yml new file mode 100644 index 0000000..7adabb2 --- /dev/null +++ b/config.yml @@ -0,0 +1,167 @@ +############################################## +# Ultra Chat # +############################################## +#Color GUI Settings: +#If true the command will be /chat color instead of /color +ChatColor_Command: false + +#Used for assistance in development. Read more about it here: +# https://bstats.org/getting-started +bstats: true +#Restrict plugins from changing things in the config. +apirestrict: false +#Some of the chat formats break the mute function in plugins. +#This plugin hooks into ban/mute plugins and allow it to work. +#If set to true then the plugin will hook into that plugin. +#Suggest more ban plugins here: https://github.com/ryandw11/Ultra-Chat/issues ! +#Or ask the ban plugin author. +pluginhooks: + Essentials: true + AdvancedBan: true +#Join / Leave messages: +Join_Message: '&e %player% has joined the server!' +Leave_Message: '&e %player% has left the server!' + +############################################# +# Anti - Swear # +############################################# + +Anti_Swear_Enabled: false + +Blocked_Words: + - fuck + - fu + - shit + - f*ck + - crap + - ass + - jackass + - sh*t + - asshole + - fucker +############################################## +# Chat Format Type # +############################################## +# Vailed types: normal, channel, channel_json, json, range. +# Set to nothing to not format the chat. +# Check the wiki for an explenation of each type! +chat_format: 'normal' + +#The default color that opped players chat in. Do &r for none. +Op_Chat_Color: '&c' +############################################## +# Channels # +############################################## +#Note: Custom Chat must be enabled for this to work! +#Edit the channels.yml when the server is stopped! +#Default Channel. This is the channel the player first joins the server. It is also given when the channel the player is on does not exsist. +Default_Channel: 'global' +#This is a list for the channels. It will only affect the list of channels. (Name should match the same as the one in the channels.yml) +Channel_List: +- global +- vip + +############################################## +# Range # +############################################## +#If json should be enabled on the range chat or not. +Range_Json: false +#The global channel which everyone can see. +Global: + format: '&6[Global]&r %prefix% %player% %suffix% &7>>' + json: + - Example + - Text +World: + format: '&d[World]&r %prefix% %player% %suffix% &7>>' + json: + - Example + - Text +Local: + format: '&b[Local]&r %prefix% %player% %suffix% &7>>' + json: + - Example + - Text + range: 100 +############################################## +# Chat # +# Json / Normal # +############################################## + +#Console Chat Log: (JSON chat only!) +#With json on the chat no longer prints to the console. This option fixes that issue! Set to true if you want it enabled! +console_log: false + + +#New player join. If the player hasn't joined the server before then this message will play. If you don't want it put none. +New_Player: '&d%player% has just joined the server for the first time! Welcome!' + +#Moto of the day. You can use chat colors. +#If you have PlaceholderAPI installed you can use these placeholders: https://www.spigotmc.org/wiki/placeholderapi-placeholders/! +Motd_Enabled: true +Motd: + - '&6Welcome to the server,&r %player_name%&6.' + - '&6There are currently&b %server_online% &6players online!' + +#Variables: %prefix% - Gives you the players prefix. %suffix% - gives you the player suffix! +#You can use PlaceHolderAPI here! Check out the placeholders here: https://www.spigotmc.org/wiki/placeholderapi-placeholders/ +#You can have unlimited custom chat formats. +#Note: If PlaceHolderAPI placeholders are not showing up please check to make sure you have the extension installed and that you reloaded the plugin. +#Notice: The JSON is only if the JSON above is set to true. JSON can also use PlaceHolderAPI! +######################## +# Important Note! # +######################## +# If you give a player the '*' permission they will have every single custom chat. +# When json is enabled the message is sent several times based on the number of custom formats you have! +# To advoid this give them the permission -(yourpermission). Ex: -ultrachat.chat.1 +Custom_Chat: + #The Chat_Count number must represent how many custom chats you have. + Chat_Count: 5 + #Each new custom chat must be a single number and all of them must go 1 - (what ever number you have last). There can't be any numbers skipped. + 1: + #The permission node you want to give it. *Does not need to match up with the number above* + Permission: 'ultrachat.chat.1' + #The custom format in the chat. The message is added after the end of the string. + Format: '%prefix% %player% %suffix%&7>> ' + #JSON formating if enabled. In order to use color codes surround the message in single quotes. '' + JSON: + - Example + - Example 2 + #You can now also suggest a command to a player who clicks it. %player% is the only valid placeholder. + 2: + Permission: 'ultrachat.chat.2' + Format: '%prefix% %player% %suffix% &7>> ' + JSON: + - Example + - Example 2 + 3: + Permission: 'ultrachat.chat.3' + Format: '%prefix% %player% %suffix%&7>> ' + JSON: + - '&cNotice' + - '&7Use colorcodes in quotes' + 4: + Permission: 'ultrachat.chat.4' + Format: '%prefix% %player% %suffix%&7>> ' + JSON: + - '45' + - Same with numbers + 5: + Permission: 'ultrachat.chat.5' + Format: '%prefix% %player% %suffix%&7>> ' + JSON: + - Example + - Example 2 + #For any player opped. + Op_Chat: + #The format. + Format: '%prefix% %player% %suffix%&c>> ' + JSON: + - Example + - Example 2 + #The default chat when a player does not have a custom one. + Default_Chat: + Format: '<%prefix% %player% %suffix%&f>' + JSON: + - Example + - Example 2 \ No newline at end of file diff --git a/lang.yml b/lang.yml new file mode 100644 index 0000000..8d4c5eb --- /dev/null +++ b/lang.yml @@ -0,0 +1,29 @@ +# %p represents player. (Not applicable to all messages) +# %s represents a message if there is one. (Not applicable to all messages) +plugin-prefix: '&7[&aUltraChat&7]' +no-perm: '&cYou do not have permission for this command.' +error-channel-enabled: '&cError: Chat channels are not enabled on this server!' +error-channel-usage: '&cError: Use /channel {channel}!' +channel-json-hover: '&5Click to join the channel!' +chat-stop-off: '&eThe chat has been &2Enabled &eby:&5 %p&e!' +chat-stop-on: '&eThe chat has been &4disabled 7eby:&5 %p&e!' +stop-chat-message: '&cThe chat is currently not active.' +broadcast-prefix: '&7[&4UltraChat&7] ' +chat-clear: '&3The chat has been cleared by &9%p&3!' +config-reload: '&aThe config has been reloaded!' +chat-cmd-not-valid: '&cThat is not a valid command. Do /chat help for help!' +cmd-spy-on: '&bCommand Spy Enabled!' +cmd-spy-off: '&bCommand Spy Disabled!' +cmd-spy-format: '&3[&6CommandSpy&3]&b %p: &3%s' +oth-cmd-spy-on: '&a%p&b''s command spy has been enabled!' +oth-cmd-spy-off:'&a%p&b''s command spy has ben disabled!' +staff-chat-on: '&dStaff chat has been enabled!' +staff-chat-off: '&dStaff chat has been disabled!' +staff-chat-format: '&7[&dStaff Chat&7] &9%p: &3%s' +color-gui: '&aChat Color' +silent-join-message: '%p &7has joined the game silently!' +silent-leave-message: '%p &7has left the game silently!' +no-swear: '&cSwearing is not allowed on this server!' +mention: '&aSomeone has mentioned you!' +conosle-chat-log: '%p: %s' + diff --git a/plugin.yml b/plugin.yml new file mode 100644 index 0000000..4c72258 --- /dev/null +++ b/plugin.yml @@ -0,0 +1,34 @@ +name: UltraChat +version: 2.2.1 +main: me.ryandw11.ultrachat.UltraChat +author: Ryandw11 +description: A chat formatting plugin. +depend: [Vault, PlaceholderAPI] +softdepend: [AdvancedBan] +api-version: 1.13 +commands: + chat: + description: The main command for the plugin. + aliases: [UltraChat, uchat, ultrac, uc] + sc: + description: The staff chat command. + aliases: [Staffchat, schat, staffc] + sctoggle: + description: Toggle the staff chat from showing up. + aliases: [StaffchatToggle, schattoggle, staffct, sct] + spy: + description: See commands that other players type. + aliases: [spycmd, cmds, uspy, ucspy] + color: + description: Change your chat color. + aliases: [ccolor, chatcolor, uchatcolor, uccolor, chat color] + channel: + description: Change the channel you are using or display the help. + aliases: [chan, cn, ch] + global: + description: Used when using range chat! + aliases: [g, gl, ug] + world: + description: Used when using range chat! + aliases: [w, wo, uw] + \ No newline at end of file diff --git a/src/me/ryandw11/ultrachat/UltraChat.java b/src/me/ryandw11/ultrachat/UltraChat.java new file mode 100644 index 0000000..fb620b7 --- /dev/null +++ b/src/me/ryandw11/ultrachat/UltraChat.java @@ -0,0 +1,393 @@ +package me.ryandw11.ultrachat; +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.util.ArrayList; +import java.util.UUID; + +import me.ryandw11.ultrachat.api.ChatMode; +import me.ryandw11.ultrachat.api.Lang; +import me.ryandw11.ultrachat.commands.ChannelCmd; +import me.ryandw11.ultrachat.commands.ChatCommand; +import me.ryandw11.ultrachat.commands.CommandTabCompleter; +import me.ryandw11.ultrachat.commands.Global; +import me.ryandw11.ultrachat.commands.StaffChat; +import me.ryandw11.ultrachat.commands.StaffChatToggle; +import me.ryandw11.ultrachat.commands.World; +import me.ryandw11.ultrachat.commands.SpyCommand; +import me.ryandw11.ultrachat.formatting.Channels; +import me.ryandw11.ultrachat.formatting.Chat_Json; +import me.ryandw11.ultrachat.formatting.Normal; +import me.ryandw11.ultrachat.formatting.Range; +import me.ryandw11.ultrachat.gui.ColorGUI; +import me.ryandw11.ultrachat.listner.ConsoleLogChat; +import me.ryandw11.ultrachat.listner.JoinListner; +import me.ryandw11.ultrachat.listner.NoSwear; +import me.ryandw11.ultrachat.listner.Notify; +import me.ryandw11.ultrachat.listner.Spy; +import me.ryandw11.ultrachat.listner.StopChat; +import me.ryandw11.ultrachat.pluginhooks.AdvancedBanMute; +import me.ryandw11.ultrachat.pluginhooks.EssentialsMute; +import me.ryandw11.ultrachat.util.Metrics; +import net.milkbowl.vault.chat.Chat; +import net.milkbowl.vault.permission.Permission; + +import org.bukkit.Bukkit; +import org.bukkit.configuration.InvalidConfigurationException; +import org.bukkit.configuration.file.FileConfiguration; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.plugin.RegisteredServiceProvider; +import org.bukkit.plugin.java.JavaPlugin; +/** + * Main Class + * @author Ryandw11 + * @version 2.2 + * Updated for 1.13. + * (Finally updated the yamlconfig) + * + */ +public class UltraChat extends JavaPlugin{ + + public static UltraChat plugin; + public Permission perms = null; + public Chat chat = null; + public Boolean Vault; + public Boolean chatStop = false; + public Boolean channelEnabled = false; + public Boolean JSON = false; + public ChatMode md; + public String defaultChannel; + public ArrayList stafftoggle = new ArrayList<>(); + public ArrayList spytoggle = new ArrayList<>(); + + public File datafile = new File(getDataFolder() + "/data/players.yml"); + public FileConfiguration data = YamlConfiguration.loadConfiguration(datafile); + public File channelfile; + public FileConfiguration channel; + public String prefix; + public static YamlConfiguration LANG; + public static File LANG_FILE; + + + + @Override + public void onEnable(){ + + + /* + * Plugin setup area + */ + plugin = this; + if (getServer().getPluginManager().getPlugin("Vault") == null && !setupChat()) { + getLogger().info(String.format("[%s] - Vault is not found!", getDescription().getName())); + getLogger().severe("§cWarning: You do not have Vault installed! This plugin has been disabled!"); + Bukkit.getPluginManager().disablePlugin(this); + return; + } + if (getServer().getPluginManager().getPlugin("PlaceholderAPI") == null) { + getLogger().severe("§cWarning: You do not have PlaceholderAPI installed! This plugin has been disabled!"); + Bukkit.getPluginManager().disablePlugin(this); + return; + } + else{ + getLogger().info(String.format("UltraChat is enabled and running fine! V: %s", getDescription().getVersion())); + getLogger().info("Hooked into PlaceholderAPI! You can use the place holders!"); + } + if(getServer().getPluginManager().getPlugin("AdvancedBan") != null && getConfig().getBoolean("pluginhooks.AdvancedBan")){ + getLogger().info("AdvancedBan detected! Activating hook!"); + getLogger().info("Mutes will now work with the chat types."); + Bukkit.getServer().getPluginManager().registerEvents(new AdvancedBanMute(), this); + } + if(getServer().getPluginManager().getPlugin("Essentials") != null && getConfig().getBoolean("pluginhooks.Essentials")){ + getLogger().info("Essentials detected! Activating hook!"); + getLogger().info("Mutes will now work with the chat types."); + Bukkit.getServer().getPluginManager().registerEvents(new EssentialsMute(), this); + } + loadMethod(); + registerConfig(); + loadFile(); + loadChannel(); + + setupPermissions(); + setupChat(); + setupFormatting(); + loadLang(); + if(plugin.getConfig().getBoolean("bstats")){ + @SuppressWarnings("unused") + Metrics m = new Metrics(this); + } + } + + @Override + public void onDisable(){ + getLogger().info("[UltraChat] has been disabled correctly!"); + saveFile(); + saveChannel(); + } + /** + * Setup the chat formatting. + */ + public void setupFormatting(){ + String type = getConfig().getString("chat_format"); + if(type.equals("")){ + getLogger().info("UltraChat will not format the chat. To change this go into the config."); + return; + } + switch(type.toLowerCase()){ + case "normal": + Bukkit.getServer().getPluginManager().registerEvents(new Normal(), this); + JSON = false; + channelEnabled = false; + md = ChatMode.NORMAL; + getLogger().info("Normal chat mode activated!"); + break; + case "json": + Bukkit.getServer().getPluginManager().registerEvents(new Chat_Json(), this); + JSON = true; + channelEnabled = false; + md = ChatMode.JSON; + getLogger().info("Json chat activated!"); + break; + case "channel": + channelEnabled = true; + JSON = false; + Bukkit.getServer().getPluginManager().registerEvents(new Channels(), this); + md = ChatMode.CHANNEL; + getLogger().info("Channel chat mode enabled."); + break; + case "channel_json": + JSON = true; + channelEnabled = true; + md = ChatMode.JSON_CHANNEL; + Bukkit.getServer().getPluginManager().registerEvents(new Chat_Json(), this); + getLogger().info("Channel chat mode enabled with json."); + break; + case "range": + Bukkit.getServer().getPluginManager().registerEvents(new Range(), this); + getCommand("global").setExecutor(new Global()); + getCommand("world").setExecutor(new World()); + getLogger().info("Range chat mode enabled. The commands /global and /world are now also active."); + md = ChatMode.RANGE; + break; + default: + getLogger().warning("§cThe chat format value is not correct!"); + getLogger().warning("§cIt most be one of the following: Normal, Json, Channel, Range. (Caps do not matter)"); + getLogger().warning("§cNo formatting has been enabled!"); + md = ChatMode.NONE; + break; + } + +// channelEnabled = getConfig().getBoolean("Channels"); +// if(channelEnabled){ +// if(legitDefaultChannel(getConfig().getString("Default_Channel"))){ +// defaultChannel = getConfig().getString("Default_Channel"); +// } +// else{ +// channelEnabled = false; +// } +// +// } +// if(getConfig().getBoolean("JSON")){ +// JSON = true; +// } +// else{ +// JSON = false; +// } +// if(!getConfig().getBoolean("Custom_Chat_Enabled")){ +// getLogger().info("Custom chat is not enabled. The chat will not be modified!"); +// } +// if(JSON){ +// Bukkit.getServer().getPluginManager().registerEvents(new Chat_Json(), this); +// +// }else if(channelEnabled){ +// Bukkit.getServer().getPluginManager().registerEvents(new Channels(), this); +// }else{ +// Bukkit.getServer().getPluginManager().registerEvents(new Normal(), this); +// } + } + + //Vault set-up ========================================================= + + private boolean setupChat() { + RegisteredServiceProvider rsp = getServer().getServicesManager().getRegistration(Chat.class); + chat = rsp.getProvider(); + return chat != null; + } + + private boolean setupPermissions() { + RegisteredServiceProvider rsp = getServer().getServicesManager().getRegistration(Permission.class); + perms = rsp.getProvider(); + return perms != null; + } + //========================================================================= END =============================== + /** + * Save the data file. + */ + public void saveFile(){ + + try{ + data.save(datafile); + }catch(IOException e){ + e.printStackTrace(); + + } + + } + /** + * load the data file + */ + public void loadFile(){ + if(datafile.exists()){ + try { + data.load(datafile); + + } catch (IOException | InvalidConfigurationException e) { + + e.printStackTrace(); + } + } + else{ + try { + data.save(datafile); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + /** + * Save the channel file. + */ + public void saveChannel(){ + + try{ + channel.save(channelfile); + }catch(IOException e){ + e.printStackTrace(); + + } + + } + + /** + * Load the cannel file. + */ + public void loadChannel(){ + channelfile = new File(getDataFolder(), "channel.yml"); + if (!channelfile.exists()) { + channelfile.getParentFile().mkdirs(); + saveResource("channel.yml", false); + } + channel = new YamlConfiguration(); + try { + channel.load(channelfile); + + } catch (IOException | InvalidConfigurationException e) { + + e.printStackTrace(); + } + } + public File getLangFile() { + return LANG_FILE; + } + public YamlConfiguration getLang() { + return LANG; + } + /** + * + */ + @SuppressWarnings("static-access") + public void loadLang() { + File lang = new File(getDataFolder(), "lang.yml"); + if (!lang.exists()) { + try { + getDataFolder().mkdir(); + lang.createNewFile(); + InputStream defConfigStream = this.getResource("lang.yml"); + if (defConfigStream != null) { + YamlConfiguration defConfig = YamlConfiguration.loadConfiguration(new InputStreamReader(defConfigStream)); + + defConfig.save(lang); + Lang.setFile(defConfig); + return; + } + } catch(IOException e) { + e.printStackTrace(); // So they notice + getLogger().severe("The language file could not be created. Disabling plugin."); + this.setEnabled(false); + } + } + YamlConfiguration conf = YamlConfiguration.loadConfiguration(lang); + for(Lang item:Lang.values()) { + if (conf.getString(item.getPath()) == null) { + conf.set(item.getPath(), item.getDefault()); + } + } + Lang.setFile(conf); + this.LANG = conf; + this.LANG_FILE = lang; + try { + conf.save(getLangFile()); + } catch(IOException e) { + getLogger().warning( "Failed to save lang.yml."); + e.printStackTrace(); + } + } + + + + + + + private void registerConfig() { + saveDefaultConfig(); + } + + /** + * Loads all of the Events and Commands. + */ + public void loadMethod(){ + getCommand("chat").setExecutor(new ChatCommand()); + getCommand("chat").setTabCompleter(new CommandTabCompleter()); + getCommand("sc").setExecutor(new StaffChat()); + getCommand("sctoggle").setExecutor(new StaffChatToggle()); + getCommand("spy").setExecutor(new SpyCommand()); + if(!(plugin.getConfig().getBoolean("ChatColor_Command"))) + getCommand("color").setExecutor(new ColorGUI()); + getCommand("channel").setExecutor(new ChannelCmd()); + Bukkit.getServer().getPluginManager().registerEvents(new StopChat(), this); + Bukkit.getServer().getPluginManager().registerEvents(new NoSwear(), this); + Bukkit.getServer().getPluginManager().registerEvents(new Spy(), this); + Bukkit.getServer().getPluginManager().registerEvents(new JoinListner(), this); + //Bukkit.getServer().getPluginManager().registerEvents(new Format(this), this); + Bukkit.getServer().getPluginManager().registerEvents(new ColorGUI(), this); + Bukkit.getServer().getPluginManager().registerEvents(new Notify(), this); + if(getConfig().getBoolean("console_log")) + Bukkit.getServer().getPluginManager().registerEvents(new ConsoleLogChat(), this); + + } + + + +} + +//Permmisions: +//ultrachat.stopchat +//ultrachat.stopchat.bypass +//ultrachat.mode +//ultrachat.vipchat +//ultrachat.broadcast +//ultrachat.staffchat +//ultrachat.staffchat.toggle +//ultrachat.spy +//ultrachat.staffmode +//ultrachat.clearchat +//ultrachat.commandblock.bypass +//ultrachat.sjoin +//ultrachat.color +//ultrachat.worldmute +//ultrachat.sjoin.alert +//ultrachat.spy.others +//ultrachat.fakejoin +//ultrachat.fakeleave +//ultrachat.help \ No newline at end of file diff --git a/src/me/ryandw11/ultrachat/api/ChatMode.java b/src/me/ryandw11/ultrachat/api/ChatMode.java new file mode 100644 index 0000000..2452bc2 --- /dev/null +++ b/src/me/ryandw11/ultrachat/api/ChatMode.java @@ -0,0 +1,10 @@ +package me.ryandw11.ultrachat.api; + +public enum ChatMode { + NORMAL, + JSON, + CHANNEL, + JSON_CHANNEL, + RANGE, + NONE; +} diff --git a/src/me/ryandw11/ultrachat/api/GlobalChatEvent.java b/src/me/ryandw11/ultrachat/api/GlobalChatEvent.java new file mode 100644 index 0000000..890b584 --- /dev/null +++ b/src/me/ryandw11/ultrachat/api/GlobalChatEvent.java @@ -0,0 +1,50 @@ +package me.ryandw11.ultrachat.api; + + +import org.bukkit.entity.Player; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; +/** + * Event class + * @author Ryandw11 + * + */ +public class GlobalChatEvent extends Event { + private static final HandlerList handlers = new HandlerList(); + private Player player; + private String chat; + private boolean cancelled; + + public GlobalChatEvent(Player p, String chat) { + player = p; + this.chat = chat; + } + + public Player getPlayer() { + return player; + } + + public String getMessage() { + return chat; + } + + public void setMessage(String message){ + chat = message; + } + + public boolean isCancelled(){ + return cancelled; + } + + public void setCancelled(boolean cancel){ + cancelled = cancel; + } + + public HandlerList getHandlers() { + return handlers; + } + + public static HandlerList getHandlerList() { + return handlers; + } +} diff --git a/src/me/ryandw11/ultrachat/api/JSON.java b/src/me/ryandw11/ultrachat/api/JSON.java new file mode 100644 index 0000000..9f8ce31 --- /dev/null +++ b/src/me/ryandw11/ultrachat/api/JSON.java @@ -0,0 +1,78 @@ +package me.ryandw11.ultrachat.api; + +import java.util.ArrayList; + +import org.bukkit.entity.Player; + +import me.clip.placeholderapi.PlaceholderAPI; +import me.ryandw11.ultrachat.formatting.PlayerFormatting; +//import me.ryandw11.ultrachat.UltraChat; +import net.md_5.bungee.api.ChatColor; +import net.md_5.bungee.api.chat.BaseComponent; +import net.md_5.bungee.api.chat.ComponentBuilder; +import net.md_5.bungee.api.chat.HoverEvent; +import net.md_5.bungee.api.chat.TextComponent; +import net.md_5.bungee.api.chat.ComponentBuilder.FormatRetention; + + + + +public class JSON { + + //private UltraChat plugin; + public JSON(){ + //plugin = UltraChat.plugin; + } + + /** + * Builds the hover message. + * @param msg The play name and format around it. + * @param lore The lore of the text. + * @param p The player it is being applied to. + * @return TextComponent with hover message. + */ + public BaseComponent[] hoverMessage(String msg, ArrayList lore, String chat, ChatColor color, Player p){ + PlayerFormatting pf = new PlayerFormatting(p); + int i = 0; + int l = lore.size() - 1; + msg = ChatColor.translateAlternateColorCodes('&', msg); + ComponentBuilder build = new ComponentBuilder(""); + for(String s : lore){ + build.append(PlaceholderAPI.setPlaceholders(p, ChatColor.translateAlternateColorCodes('&', s))); + if(i recipients; + private boolean cancelled; + + public JsonChatEvent(Player p, String chat, Set recipients) { + player = p; + this.chat = chat; + this.recipients = recipients; + } + /** + * Grab the recipients. + * @return The recipients. + */ + public Set getRecipients(){ + return recipients; + } + /** + * Set the recipients. + * @param recipents The set of recipients. + */ + public void setRecipients(Set recipients){ + this.recipients = recipients; + } + + public Player getPlayer() { + return player; + } + + public String getMessage() { + return chat; + } + + public void setMessage(String message){ + chat = message; + } + + public boolean isCancelled(){ + return cancelled; + } + + public void setCancelled(boolean cancel){ + cancelled = cancel; + } + + public HandlerList getHandlers() { + return handlers; + } + + public static HandlerList getHandlerList() { + return handlers; + } +} diff --git a/src/me/ryandw11/ultrachat/api/Lang.java b/src/me/ryandw11/ultrachat/api/Lang.java new file mode 100644 index 0000000..16d70c4 --- /dev/null +++ b/src/me/ryandw11/ultrachat/api/Lang.java @@ -0,0 +1,84 @@ +package me.ryandw11.ultrachat.api; + +import org.bukkit.configuration.file.YamlConfiguration; + +import net.md_5.bungee.api.ChatColor; +/** + * Language file + */ +public enum Lang { + PLUGIN_PREFIX("plugin-prefix","&7[&aUltraChat&7]"), + NO_PERM("no-perm", "&cYou do not have permission for this command!"), + ERROR_CHANNEL_ENABLED("error-channel-enabled", "&cError: Chat channels are not enabled on this server!"), + ERROR_CHANNEL_USAGE("error-channel-usage", "&cError: Use /channel {channel}!"), + CHANNEL_JSON_HOVER("channel-json-hover", "&5Click to join the channel!"), + CHAT_STOP_OFF("chat-stop-off", "&eThe chat has been &2Enabled &eby:&5 %p&e!"), + CHAT_STOP_ON("chat-stop-on", "&eThe chat has been &4disabled &eby:&5 %p&e!"), + BROADCAST_PREFIX("broadcast-prefix", "&7[&4UltraChat&7] "), + CHAT_CLEAR("chat-clear", "&3The chat has been cleared by &9%p&3!"), + CONFIG_RELOAD("config-reload", "&aThe config has been reloaded!"), + CHAT_CMD_NOT_VALID("chat-cmd-not-valid", "&cThat is not a valid command. Do /chat help for help!"), + CMD_SPY_ON("cmd-spy-on", "&bCommand Spy Enabled!"), + CMD_SPY_OFF("cmd-spy-off", "&bCommand Spy Disabled!"), + OTH_CMD_SPY_ON("oth-cmd-spy-on", "&a%p&b''s command spy has been enabled!"), + OTH_CMD_SPY_OFF("oth-cmd-spy-off", "&a%p&b''s command spy has ben disabled!"), + STAFF_CHAT_ON("staff-chat-on", "&dStaff chat has been enabled!"), + STAFF_CHAT_OFF("staff-chat-off", "&dStaff chat has been disabled!"), + STAFF_CHAT_FORMAT("staff-chat-format", "&7[&dStaff Chat&7] &9%p: &3%s"), + COLOR_GUI("color-gui", "&aChat Color"), + SILENT_JOIN_MESSAGE("silent-join-message", "%p &7has joined the game silently!"), + SILENT_LEAVE_MESSAGE("silent-leave-message", "%p &7has left the game silently!"), + NO_SWEAR("no-swear", "&cSwearing is not allowed on this server!"), + MENTION("mention", "&aSomeone has mentioned you!"), + CMD_SPY_FORMAT("cmd-spy-format", "&3[&6CommandSpy&3]&b %p: &3%s"), + STOP_CHAT_MESSAGE("stop-chat-message", "&cThe chat is currently not active."), + CONSOLE_CHAT_LOG("console-chat-log", "%p: %s"); + + + private String path; + private String def; + private static YamlConfiguration LANG; + + /** + * Lang enum constructor. + * @param path The string path. + * @param start The default string. + */ + Lang(String path, String start) { + this.path = path; + this.def = start; + } + + /** + * @param config The config to set. + */ + public static void setFile(YamlConfiguration config) { + LANG = config; + } + + @Override + public String toString() { + return ChatColor.translateAlternateColorCodes('&', LANG.getString(this.path, def)); + } + + public String toDefaultString(){ + return LANG.getString(this.path, def); + } + + /** + * Get the default value of the path. + * @return The default value of the path. + */ + public String getDefault() { + return this.def; + } + + /** + * Get the path to the string. + * @return The path to the string. + */ + public String getPath() { + return this.path; + } + +} diff --git a/src/me/ryandw11/ultrachat/api/UltraChatAPI.java b/src/me/ryandw11/ultrachat/api/UltraChatAPI.java new file mode 100644 index 0000000..a25c1f2 --- /dev/null +++ b/src/me/ryandw11/ultrachat/api/UltraChatAPI.java @@ -0,0 +1,312 @@ +package me.ryandw11.ultrachat.api; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.Set; + +import org.bukkit.Bukkit; +import org.bukkit.entity.Player; + +import me.ryandw11.ultrachat.UltraChat; +import me.ryandw11.ultrachat.formatting.PlayerFormatting; +/** + * UltraChatAPI + * @author Ryandw11 + * @version 2.1.0 + */ + +public class UltraChatAPI{ + /* + * + * UltraChatAPI ch = new UltraChatAPI(UltraChat.plugin); < Method + * + * + * + */ + /** + * Grab the Instance + * @return #getPlugin() + * @deprecated + */ + public static UltraChat getInstance(){ + return getPlugin(); + } + + private UltraChat plugin; + public UltraChatAPI(UltraChat plugin){ + this.plugin = plugin; + } + /** + * Grab the player's current channel. + * @param player + * @return The player's current channel. + */ + public String getPlayerChannel(Player player){ + return plugin.data.getString(player.getUniqueId() + ".channel"); + } + /** + * Get the servers default channel. + * @return Default Channel + */ + public String getDefaultChannel(){ + return plugin.getConfig().getString("Default_Channel"); + } + /** + * Set the player's channel. + * @param player + * @param channel + */ + public void setPlayerChannel(Player player, String channel){ + plugin.data.set(player.getUniqueId() + ".channel", channel); + plugin.saveFile(); + } + /** + * Set the default channel + * @param channel + */ + public void setDefaultChannel(String channel){ + plugin.getConfig().set("Default_Config", channel); + plugin.saveConfig(); + } + /** + * Get a channel's json. + * @param channel + * @return Json array + */ + @SuppressWarnings("unchecked") + public ArrayList getChannelJson(String channel){ + return (ArrayList) plugin.channel.get(channel + ".JSON"); + } + /** + * Get a format's json. + * @param number + * @return Json array + */ + @SuppressWarnings("unchecked") + public ArrayList getChatFormatJson(String number){ + return (ArrayList) plugin.getConfig().get("Custom_Chat." + number + ".JSON"); + } + /** + * Set a channel's json. + * @param json + * @param channel + */ + public void setChannelJson(ArrayList json, String channel){ + plugin.channel.set(channel + ".json", json); + plugin.saveChannel(); + } + /** + * Set a format's json. + * @param json + * @param number + * + */ + public void setChatFormatJson(ArrayList json, String number){ + plugin.getConfig().set("Custom_Chat." + number + ".JSON", json); + plugin.saveConfig(); + } + /** + * Check to see if channels are enabled. + * @deprecated Use getMode() + * @return boolean + */ + public boolean isChannelEnabled(){ + return plugin.getConfig().getBoolean("Channels"); + } + /** + * Check to see if json is enabled. + * @deprecated Use getMode() + * @return boolean + */ + public boolean isJsonEnabled(){ + return plugin.getConfig().getBoolean("JSON"); + } + /** + * Get the current chat mode. + * @return chat mode + */ + public ChatMode getMode(){ + return plugin.md; + } + /** + * Set the chat mode. Can be disabled in the config. + * @param cm The chat manager + */ + public void setMode(ChatMode cm){ + if(!plugin.getConfig().getBoolean("apirestrict") && cm != ChatMode.NONE){ + plugin.getConfig().set("chat_format", cm.toString().toLowerCase()); + plugin.getLogger().warning("A plugin has changed your chat mode to " + cm.toString() + "!"); + plugin.saveConfig(); + return; + } + if(!plugin.getConfig().getBoolean("apirestrict") && cm == ChatMode.NONE) + { + plugin.getConfig().set("chat_format", ""); + plugin.getLogger().warning("A plugin has changed your chat mode to " + cm.toString() + "!"); + plugin.saveConfig(); + return; + } + plugin.getLogger().warning("A plugin has tried to changed your chat mode!"); + } + /** + * Grab the player's formatting. + * @param p The player. + * @return The player's formatting. + */ + public PlayerFormatting getPlayerFormatting(Player p){ + PlayerFormatting pf = new PlayerFormatting(p); + return pf; + } + /** + * Get a chat format. + * @param number + * @return Chat format. + */ + public String getFormat(String number){ + return plugin.getConfig().getString("Custom_Chat." + number + ".Format"); + } + /** + * Get the op format. + * @return op format. + */ + public String getOpFormat(){ + return plugin.getConfig().getString("Custom_Chat.Op_Chat.Format"); + } + /** + * Get the default format. + * @return op format. + */ + public String getDefaultFormat(){ + return plugin.getConfig().getString("Custom_Chat.Default.Format"); + } + /** + * Get the permission of a chat group. + * @param number + * @return permission + */ + public String getPermission(String number){ + return plugin.getConfig().getString("Custom_Chat." + number + ".Permission"); + } + /** + * Get the number of formats + * @return Chat Count + */ + public int getChatCount(){ + return plugin.getConfig().getInt("Custom_Chat.Chat_Count"); + } + /** + * Get a player's color. Example: &4 + * @param player + * @return color code. + */ + public String getPlayerColor(Player player){ + return plugin.data.getString(player.getUniqueId() + ".color"); + } + /** + * Set a player's color. + * @param player + * @param color + */ + public void setPlayerColor(Player player, String color){ + plugin.data.set(player.getUniqueId() + ".color", color); + plugin.saveFile(); + } + /** + * Get the swear word list. + * @return Block swear words. + */ + @SuppressWarnings("unchecked") + public ArrayList getSwearWords(){ + return (ArrayList) plugin.getConfig().get("Blocked_Words"); + } + /** + * Set the swear word list. + * @param words + */ + public void setSwearWords(ArrayList words){ + plugin.getConfig().set("Blocked_Words", words); + plugin.saveConfig(); + } + /** + * Create a channel. + * @param channel + * @param prefix + * @param permission + * @param always_appear + * @param format + * @param json + */ + + public void createChannel(String channel, String prefix, String permission, boolean always_appear, String format, ArrayList json){ + plugin.channel.set(channel + ".prefix", prefix); + plugin.channel.set(channel + ".permission", permission); + plugin.channel.set(channel + ".always_appear", always_appear); + plugin.channel.set(channel + ".format", format); + plugin.channel.set(channel + ".JSON", json); + plugin.saveChannel(); + } + /** + * Remove a channel. + * @param channel + */ + public void removeChannel(String channel){ + plugin.channel.set(channel, null); + plugin.saveChannel(); + } + + /** + * Grab the plugin. + * @return plugin. Don't worry about the return + */ + public static UltraChat getPlugin(){ + return UltraChat.plugin; + } + /** + * Get the current formatting type. + * @return The value of the config. + */ + public String getFormattingType(){ + return plugin.getConfig().getString("chat_format"); + } + /** + * Get if the channel has json enabled or not. + * @return True or false. + */ + public boolean isChannelJson(){ + return plugin.getConfig().getBoolean("Channel_Json"); + } + + /** + * See if default channel exists. + * @param chan - The channel in the config. + * @return True if it does, false if not. + */ + public boolean legitDefaultChannel(String chan){ + if(plugin.channel.contains(chan)) + return true; + return false; + } + /** + * Get if range has json or not. + * @return True or False. + */ + public boolean isRangeJson(){ + return plugin.getConfig().getBoolean("Range_Json"); + } + /** + * Get the current active hooks. + * @return The set witht the names of the plugins. Returns null if no hooks are active. + */ + public Set getActiveHooks(){ + Set s = new HashSet(); + if(Bukkit.getServer().getPluginManager().getPlugin("AdvancedBan") != null && plugin.getConfig().getBoolean("pluginhooks.Essentials")){ + s.add("Essentials"); + } + if(Bukkit.getServer().getPluginManager().getPlugin("Essentials") != null && plugin.getConfig().getBoolean("pluginhooks.AdvancedBan")){ + s.add("AdvancedBan"); + } + + return s; + } + +} diff --git a/src/me/ryandw11/ultrachat/api/Util.java b/src/me/ryandw11/ultrachat/api/Util.java new file mode 100644 index 0000000..0d3b573 --- /dev/null +++ b/src/me/ryandw11/ultrachat/api/Util.java @@ -0,0 +1,49 @@ +package me.ryandw11.ultrachat.api; + +import net.md_5.bungee.api.ChatColor; + +public class Util { + /** + * + * @param s + * @return + */ + public static ChatColor getColorFromCode(String s){ + String b = s.substring(1); + switch (b){ + case "1": + return ChatColor.DARK_BLUE; + case "2": + return ChatColor.DARK_GREEN; + case "3": + return ChatColor.DARK_AQUA; + case "4": + return ChatColor.DARK_RED; + case "5": + return ChatColor.DARK_PURPLE; + case "6": + return ChatColor.GOLD; + case "7": + return ChatColor.GRAY; + case "8": + return ChatColor.DARK_GRAY; + case "9": + return ChatColor.BLUE; + case "c": + return ChatColor.RED; + case "d": + return ChatColor.LIGHT_PURPLE; + case "e": + return ChatColor.YELLOW; + case "f": + return ChatColor.WHITE; + case "a": + return ChatColor.GREEN; + case "b": + return ChatColor.AQUA; + } + return null; + } + + +} diff --git a/src/me/ryandw11/ultrachat/api/WorldChatEvent.java b/src/me/ryandw11/ultrachat/api/WorldChatEvent.java new file mode 100644 index 0000000..d6ce5db --- /dev/null +++ b/src/me/ryandw11/ultrachat/api/WorldChatEvent.java @@ -0,0 +1,67 @@ +package me.ryandw11.ultrachat.api; + +import java.util.Set; + +import org.bukkit.entity.Player; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; +/** + * Event class + * @author Ryandw11 + * + */ +public class WorldChatEvent extends Event { + private static final HandlerList handlers = new HandlerList(); + private Player player; + private String chat; + private Set recipients; + private boolean cancelled; + + public WorldChatEvent(Player p, String chat, Set recipients) { + player = p; + this.chat = chat; + this.recipients = recipients; + } + /** + * Grab the recipients. + * @return The recipients. + */ + public Set getRecipients(){ + return recipients; + } + /** + * Set the recipients. + * @param recipents The set of recipients. + */ + public void setRecipients(Set recipients){ + this.recipients = recipients; + } + + public Player getPlayer() { + return player; + } + + public String getMessage() { + return chat; + } + + public void setMessage(String message){ + chat = message; + } + + public boolean isCancelled(){ + return cancelled; + } + + public void setCancelled(boolean cancel){ + cancelled = cancel; + } + + public HandlerList getHandlers() { + return handlers; + } + + public static HandlerList getHandlerList() { + return handlers; + } +} diff --git a/src/me/ryandw11/ultrachat/commands/ChannelCmd.java b/src/me/ryandw11/ultrachat/commands/ChannelCmd.java new file mode 100644 index 0000000..3244940 --- /dev/null +++ b/src/me/ryandw11/ultrachat/commands/ChannelCmd.java @@ -0,0 +1,84 @@ +package me.ryandw11.ultrachat.commands; + +import java.util.ArrayList; + +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +import me.ryandw11.ultrachat.UltraChat; +import me.ryandw11.ultrachat.api.Lang; +import net.md_5.bungee.api.ChatColor; +import net.md_5.bungee.api.chat.ClickEvent; +import net.md_5.bungee.api.chat.ComponentBuilder; +import net.md_5.bungee.api.chat.HoverEvent; +/** + * + * @author Ryandw11 + * + */ +public class ChannelCmd implements CommandExecutor { + private UltraChat plugin; + public ChannelCmd(){ + plugin = UltraChat.plugin; + } + @Override + public boolean onCommand(CommandSender sender, Command cmd, String s, String[] args) { + + + Player p = (Player) sender; + if(!(p instanceof Player )) return true; + if(!p.hasPermission("ultrachat.channel")){ + p.sendMessage(ChatColor.translateAlternateColorCodes('&', Lang.NO_PERM.toString())); + return true; + } + if(!plugin.channelEnabled){ + p.sendMessage(ChatColor.translateAlternateColorCodes('&', Lang.ERROR_CHANNEL_ENABLED.toString())); + return true; + } + if(args.length != 1 && args.length != 0){ + p.sendMessage(ChatColor.translateAlternateColorCodes('&', Lang.ERROR_CHANNEL_USAGE.toString())); + } + else if(args.length == 0){ + p.sendMessage(ChatColor.BLUE + "-------------Chat Channels--------------"); + p.sendMessage(ChatColor.GREEN + "/channel {channel} - Change you channel. [Case Sensitive!]"); + p.sendMessage(ChatColor.GREEN + "/channel list - List the channels."); + }else if(args.length == 1 && args[0].equalsIgnoreCase("list")){ + if(!p.hasPermission("ultrachat.channel.list")){ + p.sendMessage(ChatColor.translateAlternateColorCodes('&', Lang.NO_PERM.toString())); + return true; + } + @SuppressWarnings("unchecked") + ArrayList chnls = (ArrayList) plugin.getConfig().get("Channel_List"); + p.sendMessage(ChatColor.BLUE + "-------------Channels List--------------"); + for(String st : chnls){ + ComponentBuilder cnl = new ComponentBuilder("- " + st); + cnl.event(new HoverEvent( HoverEvent.Action.SHOW_TEXT, new ComponentBuilder(ChatColor.translateAlternateColorCodes('&', Lang.CHANNEL_JSON_HOVER.toString())).create() ) ); + cnl.event(new ClickEvent( ClickEvent.Action.RUN_COMMAND, "/channel " + st)); + cnl.color(ChatColor.GREEN); + p.spigot().sendMessage(cnl.create()); + } + p.sendMessage(ChatColor.BLUE + "--------------------------------------"); + } + else{ + if(!plugin.channel.contains(args[0])){ + p.sendMessage(ChatColor.RED + "That channel does not exsist!"); + return true; + } + if(plugin.data.getString(p.getUniqueId() + ".channel").equalsIgnoreCase(args[0])){ + p.sendMessage(ChatColor.RED + "Error: you are currently in the channel"); + } + else if(p.hasPermission(plugin.channel.getString(args[0] + ".permission")) || plugin.channel.getString(args[0] + ".permission").equalsIgnoreCase("none")){ + plugin.data.set(p.getUniqueId() + ".channel", args[0]); + plugin.saveFile(); + p.sendMessage(ChatColor.BLUE + "You are now in the channel " + args[0] + "!"); + } + else{ + p.sendMessage(ChatColor.RED + "You do not have permission to join that channel."); + } + } + return false; + } + +} diff --git a/src/me/ryandw11/ultrachat/commands/ChatCommand.java b/src/me/ryandw11/ultrachat/commands/ChatCommand.java new file mode 100644 index 0000000..6af669a --- /dev/null +++ b/src/me/ryandw11/ultrachat/commands/ChatCommand.java @@ -0,0 +1,284 @@ +package me.ryandw11.ultrachat.commands; + +import me.ryandw11.ultrachat.UltraChat; +import me.ryandw11.ultrachat.api.Lang; +import me.ryandw11.ultrachat.api.UltraChatAPI; +import me.ryandw11.ultrachat.gui.ColorGUI; + +import org.bukkit.Bukkit; +import org.bukkit.ChatColor; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +/** + * + * @author Ryandw11 + * + */ +public class ChatCommand implements CommandExecutor { + + + private UltraChat plugin; + public ChatCommand(){ + plugin = UltraChat.plugin; + } + + @Override + public boolean onCommand(CommandSender sender, Command cmd, String s, String[] args) { + if(!(sender instanceof Player )){ + plugin.getLogger().info(ChatColor.RED + "This command is for players only!"); + return true; + } + Player p = (Player) sender; + + + if(args.length == 0){ + p.sendMessage(ChatColor.BLUE + "=============={" + ChatColor.GREEN + "Ultra Chat" + ChatColor.BLUE + "}=============="); + p.sendMessage(ChatColor.BLUE + "Plugin developed by:" + ChatColor.GREEN + " Ryandw11"); + p.sendMessage(ChatColor.BLUE + "Version: " + ChatColor.GREEN + String.format("%s", plugin.getDescription().getVersion())); + p.sendMessage(ChatColor.BLUE + "Plugin wiki:" + ChatColor.GREEN + " https://github.com/ryandw11/Ultra-Chat/wiki"); + p.sendMessage(ChatColor.BLUE + "Do " + ChatColor.GREEN + " /chat help " + ChatColor.BLUE + "for the list of commands!"); + p.sendMessage(ChatColor.BLUE + "=============={" + ChatColor.GREEN + "Ultra Chat" + ChatColor.BLUE + "}=============="); + + } + + + //Chat Stop Command + else if(args.length == 1 && args[0].equalsIgnoreCase("stop")){ + if(p.hasPermission("ultrachat.stopchat")){ + + if(plugin.chatStop == true){ + plugin.chatStop = false; + p.sendMessage(ChatColor.GREEN + "Chat Unstopped"); + Bukkit.getServer().broadcastMessage(Lang.CHAT_STOP_OFF.toString().replace("%p", p.getDisplayName())); + } + else if(plugin.chatStop == false){ + plugin.chatStop = true; + p.sendMessage(ChatColor.GREEN + "Chat Stopped"); + Bukkit.getServer().broadcastMessage(Lang.CHAT_STOP_ON.toString().replace("%p", p.getDisplayName())); + } + else{ + p.sendMessage("An error has occured!"); + } + + + + } + else{ + p.sendMessage(Lang.NO_PERM.toString()); + } + + + } + + + else if(args.length >= 1 && args[0].equalsIgnoreCase("broadcast")){ + if(p.hasPermission("ultrachat.broadcast")){ + String Message = ""; + for (int i = 1; i < args.length; i++){ + Message = Message + " " + args[i]; + } + Bukkit.getServer().broadcastMessage(Lang.BROADCAST_PREFIX.toString() + ChatColor.translateAlternateColorCodes('&', Message)); + } + else{ + p.sendMessage(Lang.NO_PERM.toString()); + } + + } + else if(args.length == 1 && args[0].equalsIgnoreCase("broadcast")){ + if(p.hasPermission("ultrachat.broadcast")){ + p.sendMessage(ChatColor.RED + "Invalid Usage: /chat broadcast (broadcast)"); + } + else{ + p.sendMessage(Lang.NO_PERM.toString()); + } + }//end of broadcast====================================================================================== + // + //================================================================================================================ + + else if(args.length == 1 && args[0].equalsIgnoreCase("clear")){ + if(p.hasPermission("ultrachat.clearchat")){ + for (int i = 0; i < 100; i++){ + for(Player pl : Bukkit.getOnlinePlayers()){ + pl.sendMessage(" "); + } + } + Bukkit.getServer().broadcastMessage(Lang.CHAT_CLEAR.toString().replace("%p", p.getName())); + + } + else{ + p.sendMessage(Lang.NO_PERM.toString()); + } + } + //======================================================== + + //========================================================== + + else if(args.length == 1 && args[0].equalsIgnoreCase("sjoin")){ + if(p.hasPermission("ultrachat.sjoin")){ + if(plugin.data.getBoolean(p.getUniqueId().toString() + ".sjoin")){ + p.sendMessage(ChatColor.AQUA + "Your Join/Leave message will now be shown!"); + plugin.data.set(p.getUniqueId().toString() + ".sjoin", false); + plugin.saveFile(); + } + else{ + plugin.data.set(p.getUniqueId().toString() + ".sjoin", true); + plugin.saveFile(); + p.sendMessage(ChatColor.AQUA + "Your Join/Leave message will no longer be shown!"); + } + } + else{ + p.sendMessage(Lang.NO_PERM.toString()); + } + + } + else if(args.length == 2 && args[0].equalsIgnoreCase("sjoin")){ + if(p.hasPermission("ultrachat.sjoin.others")){ + Player pl = (Player) Bukkit.getServer().getPlayer(args[1]); + if(pl == null){p.sendMessage(ChatColor.RED + "Player can not be null!"); return true;} + if(plugin.data.getBoolean(p.getUniqueId().toString() + ".sjoin")){ + p.sendMessage(ChatColor.AQUA + pl.getName() + " Join/Leave message will now be shown!"); + plugin.data.set(p.getUniqueId().toString() + ".sjoin", false); + plugin.saveFile(); + } + else{ + plugin.data.set(p.getUniqueId().toString() + ".sjoin", true); + plugin.saveFile(); + p.sendMessage(ChatColor.AQUA + pl.getName() + " Join/Leave message will no longer be shown!"); + } + } + else{ + p.sendMessage(Lang.NO_PERM.toString()); + } + + } + + //====================================================================================================== + // Break + //====================================================================================================== + + + else if(args.length == 2 && args[0].equalsIgnoreCase("join")){ + if(p.hasPermission("ultrachat.fakejoin")){ + Bukkit.getServer().broadcastMessage(ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("Join_Message").replace("%player%", args[1]))); + + } + else{ + p.sendMessage(Lang.NO_PERM.toString()); + } + }//end of fake join + + else if(args.length == 2 && args[0].equalsIgnoreCase("leave")){ + if(p.hasPermission("ultrachat.fakeleave")){ + Bukkit.getServer().broadcastMessage(ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("Leave_Message").replace("%player%", args[1]))); + + } + else{ + p.sendMessage(Lang.NO_PERM.toString()); + } + }//end of fake leave + //==================================================================== + + //================================================================ + else if(args.length == 1 && args[0].equalsIgnoreCase("help")){ + if(!p.hasPermission("ultrachat.help")) + p.sendMessage(ChatColor.BLUE + "-------------------=[" + ChatColor.GREEN + "Utlra Chat" + ChatColor.BLUE + "]=-------------------"); + p.sendMessage(ChatColor.GREEN + "/chat help" + ChatColor.BLUE + " The help command."); + p.sendMessage(ChatColor.GREEN + "/chat stop" + ChatColor.BLUE + " Stop the chat."); + p.sendMessage(ChatColor.GREEN + "/chat broadcast (message)" + ChatColor.BLUE + " Send a message to every player."); + p.sendMessage(ChatColor.GREEN + "/sc (message)" + ChatColor.BLUE + " Talk in staff chat."); + p.sendMessage(ChatColor.GREEN + "/sctoggle" + ChatColor.BLUE + " Toggle staff chat."); + p.sendMessage(ChatColor.GREEN + "/spy" + ChatColor.BLUE + " Enable or disable command spy."); + p.sendMessage(ChatColor.GREEN + "/chat clear" + ChatColor.BLUE + " Clear the chat."); + p.sendMessage(ChatColor.GREEN + "/chat sjoin" + ChatColor.BLUE + " Silently join and leave the server."); + p.sendMessage(ChatColor.GREEN + "/chat leave (player)" + ChatColor.BLUE + " Send a fake leave message."); + p.sendMessage(ChatColor.GREEN + "/chat join (player) " + ChatColor.BLUE + " Send a fake join message."); + p.sendMessage(ChatColor.BLUE + "Do" + ChatColor.GREEN + " /chat help 2" + ChatColor.BLUE + " for more help pages!"); + p.sendMessage(ChatColor.BLUE + "Plugin made by: " + ChatColor.GREEN + "Ryandw11" + ChatColor.BLUE + "! Help Page: " + ChatColor.GREEN + "1/2" + ChatColor.BLUE + "."); + p.sendMessage(ChatColor.BLUE + "---------------------------------------------------"); + + }//end of help + + else if(args.length == 2 && args[0].equalsIgnoreCase("help")){ + if(p.hasPermission("ultrachat.help")){ + if(args[1].equals("2")){ + p.sendMessage(ChatColor.BLUE + "-------------------=[" + ChatColor.GREEN + "Utlra Chat" + ChatColor.BLUE + "]=-------------------"); + p.sendMessage(ChatColor.GREEN + "/chat color" + ChatColor.BLUE + " Change your chat color."); + p.sendMessage(ChatColor.GREEN + "/chat raw {Message}" + ChatColor.BLUE + " Send a message in the chat without a prefix."); + p.sendMessage(ChatColor.GREEN + "/chat reload" + ChatColor.BLUE + " Reload the config file."); + p.sendMessage(ChatColor.GREEN + "/chat hooks" + ChatColor.BLUE + " Get the current plugin hooks!"); + p.sendMessage(ChatColor.GREEN + "/channels" + ChatColor.BLUE + " The channel command."); + p.sendMessage(ChatColor.BLUE + "Plugin made by: " + ChatColor.GREEN + "Ryandw11" + ChatColor.BLUE + "! Help Page: " + ChatColor.GREEN + "2/2" + ChatColor.BLUE + "."); + p.sendMessage(ChatColor.BLUE + "---------------------------------------------------"); + } + if(!(args[1].equals("1") || args[1].equals("2"))){ + p.sendMessage(ChatColor.RED + "There are only two help pages!"); + } + } + else{ + p.sendMessage(ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("No_Permission"))); + } + }//end of help page ======== + + else if(args.length > 1 && args[0].equalsIgnoreCase("raw")){ + if(p.hasPermission("ultrachat.raw")){ + String Message = ""; + for (int i = 1; i < args.length; i++){ + if(i == 1){ + Message = Message + args[i]; // Fixed bugs + }else{ + Message = Message + " " + args[i]; + } + } + Bukkit.getServer().broadcastMessage(ChatColor.translateAlternateColorCodes('&', ChatColor.translateAlternateColorCodes('&', Message))); + } + else{ + p.sendMessage(Lang.NO_PERM.toString()); + } + } + + else if(args.length == 1 && args[0].equalsIgnoreCase("reload")){ + if(p.hasPermission("ultrachat.reload")){ + plugin.reloadConfig(); + plugin.loadChannel(); + p.sendMessage(Lang.CONFIG_RELOAD.toString()); + } + else{ + p.sendMessage(Lang.NO_PERM.toString()); + } + } + else if(args.length == 1 && args[0].equalsIgnoreCase("color")){ + if(p.hasPermission("ultrachat.color")){ + ColorGUI.openGUI(p.getPlayer()); + } + else{ + p.sendMessage(Lang.NO_PERM.toString()); + } + } + else if(args.length == 1 && args[0].equalsIgnoreCase("hooks")){ + if(p.hasPermission("ultrachat.hooks")){ + UltraChatAPI uapi = new UltraChatAPI(plugin); + p.sendMessage(ChatColor.BLUE + "Ultra Chat Hooks:"); + if(uapi.getActiveHooks() == null){ + p.sendMessage(ChatColor.GREEN + "No hooks are currently active!"); + }else{ + for(String st : uapi.getActiveHooks()){ + p.sendMessage(ChatColor.GREEN + " - " + st); + } + } + } + else{ + p.sendMessage(Lang.NO_PERM.toString()); + } + } +//=========================================----------------------------------------=========================================== + else{ + p.sendMessage(Lang.CHAT_CMD_NOT_VALID.toString()); + } + + return false; + } + +} diff --git a/src/me/ryandw11/ultrachat/commands/CommandTabCompleter.java b/src/me/ryandw11/ultrachat/commands/CommandTabCompleter.java new file mode 100644 index 0000000..ea18ef8 --- /dev/null +++ b/src/me/ryandw11/ultrachat/commands/CommandTabCompleter.java @@ -0,0 +1,50 @@ +package me.ryandw11.ultrachat.commands; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; + +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.command.TabCompleter; + +public class CommandTabCompleter implements TabCompleter{ + + @Override + public List onTabComplete(CommandSender sender, Command cmd, String s, String[] args) { + if(cmd.getName().equalsIgnoreCase("chat")){ + ArrayList completions = new ArrayList<>(); + if(args.length == 1){ + completions = new ArrayList<>( Arrays.asList("help", "stop", "broadcast", "clear", "sjoin", "leave", "join", "color", "raw", "reload", "hooks")); + completions = getAppliableTabCompleters(args.length == 1 ? args[0] : "", completions); + }else{ + if(args[0].equalsIgnoreCase("help")){ + completions = new ArrayList<>(Arrays.asList("2")); + completions = getAppliableTabCompleters(args.length == 2 ? args[1] : "", completions); + } + else{ + return null; + } + } + Collections.sort(completions); + return completions; + } + + return null; + } + + public ArrayList getAppliableTabCompleters(String arg, ArrayList completions) { + if (arg == null || arg.equalsIgnoreCase("")) { + return completions; + } + ArrayList valid = new ArrayList<>(); + for (String posib : completions) { + if (posib.startsWith(arg)) { + valid.add(posib); + } + } + return valid; + } + +} diff --git a/src/me/ryandw11/ultrachat/commands/Global.java b/src/me/ryandw11/ultrachat/commands/Global.java new file mode 100644 index 0000000..8050847 --- /dev/null +++ b/src/me/ryandw11/ultrachat/commands/Global.java @@ -0,0 +1,71 @@ +package me.ryandw11.ultrachat.commands; + +import java.util.ArrayList; + +import org.bukkit.Bukkit; +import org.bukkit.ChatColor; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +import me.ryandw11.ultrachat.UltraChat; +import me.ryandw11.ultrachat.api.GlobalChatEvent; +import me.ryandw11.ultrachat.api.JSON; +import me.ryandw11.ultrachat.api.Lang; +import me.ryandw11.ultrachat.api.UltraChatAPI; +import me.ryandw11.ultrachat.formatting.PlayerFormatting; + +public class Global implements CommandExecutor { + private UltraChat plugin; + public Global(){ + plugin = UltraChat.plugin; + } + + @SuppressWarnings("unchecked") + @Override + public boolean onCommand(CommandSender sender, Command cmd, String s, String[] args) { + if(!(sender instanceof Player)){ + sender.sendMessage("§cThis command is for players only!"); + return true; + } + Player p = (Player) sender; + if(!p.hasPermission("ultrachat.global")){ + p.sendMessage(Lang.NO_PERM.toString()); + return true; + } + UltraChatAPI uapi = new UltraChatAPI(plugin); + PlayerFormatting pf = new PlayerFormatting(p); + if(!uapi.isRangeJson()){ + GlobalChatEvent e = new GlobalChatEvent(p, this.getMessage(args, p)); + Bukkit.getServer().getPluginManager().callEvent(e); + if(!e.isCancelled()){ + Bukkit.broadcastMessage(pf.getGlobal().replace("%player%", p.getDisplayName()).replace("%prefix%", pf.getPrefix()).replace("%suffix%", pf.getSuffix()) + pf.getColor() + e.getMessage()); + Bukkit.getLogger().info(pf.getGlobal().replace("%player%", p.getDisplayName()).replace("%prefix%", pf.getPrefix()).replace("%suffix%", pf.getSuffix()).replace('&', '§') + pf.getColor() + e.getMessage().replace('&', '§')); + } + }else{ + GlobalChatEvent e = new GlobalChatEvent(p, this.getMessage(args, p)); + Bukkit.getServer().getPluginManager().callEvent(e); + if(!e.isCancelled()){ + JSON j = new JSON(); + for(Player pl : Bukkit.getOnlinePlayers()){ + pl.spigot().sendMessage(j.hoverMessage(pf.getGlobal().replace("%player%", p.getDisplayName()).replace("%prefix%", pf.getPrefix()).replace("%suffix%", pf.getSuffix()), (ArrayList) plugin.getConfig().get("Global.json"), e.getMessage(), pf.getColor(), p)); + } + Bukkit.getLogger().info(pf.getGlobal().replace("%player%", p.getDisplayName()).replace("%prefix%", pf.getPrefix()).replace("%suffix%", pf.getSuffix()).replace('&', '§') + pf.getColor() + e.getMessage().replace('&', '§')); + } + } + + return false; + } + + private String getMessage(String[] args, Player p){ + String end = ""; + for(String s : args){ + end += s + " "; + } + if(p.hasPermission("ultrachat.color")) + return ChatColor.translateAlternateColorCodes('&', end); + return end; + } + +} diff --git a/src/me/ryandw11/ultrachat/commands/SpyCommand.java b/src/me/ryandw11/ultrachat/commands/SpyCommand.java new file mode 100644 index 0000000..cc701b7 --- /dev/null +++ b/src/me/ryandw11/ultrachat/commands/SpyCommand.java @@ -0,0 +1,78 @@ +package me.ryandw11.ultrachat.commands; + +import org.bukkit.Bukkit; +import org.bukkit.ChatColor; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +import me.ryandw11.ultrachat.UltraChat; +import me.ryandw11.ultrachat.api.Lang; + +/** + * Spy Command class. + * @author Ryandw11 + * + */ +public class SpyCommand implements CommandExecutor { + + + + private UltraChat plugin; + public SpyCommand(){ + plugin = UltraChat.plugin; + } + + @Override + public boolean onCommand(CommandSender sender, Command cmd, String s, String[] args) { + if(!(sender instanceof Player )){ + plugin.getLogger().info("This command is for players only!"); + return true; + } + Player p = (Player) sender; + + if(args.length == 0){ + if (p.hasPermission("ultrachat.spy")) { + if(!(args.length == 0)){ + p.sendMessage(ChatColor.RED + "Invailed subcommand! Ussage: /spy"); + + } + else{ + if(plugin.spytoggle.contains(p.getUniqueId())){ + p.sendMessage(Lang.CMD_SPY_OFF.toString()); + plugin.spytoggle.remove(p.getUniqueId()); + plugin.data.set(p.getUniqueId().toString() + ".spy", false); + plugin.saveFile(); + } + else{ + plugin.spytoggle.add(p.getUniqueId()); + p.sendMessage(Lang.CMD_SPY_ON.toString()); + plugin.data.set(p.getUniqueId().toString() + ".spy", true); + plugin.saveFile(); + } + } + + }//end of perm check + } + else if(args.length == 1){ + if(p.hasPermission("ultrachat.spy.others")){ + Player pl = (Player) Bukkit.getServer().getPlayer(args[0]); + if(plugin.spytoggle.contains(pl.getUniqueId())){ + plugin.spytoggle.remove(pl.getUniqueId()); + p.sendMessage(Lang.OTH_CMD_SPY_OFF.toString().replace("%p", args[0])); + plugin.data.set(pl.getUniqueId().toString() + ".spy", false); + plugin.saveFile(); + } + else{ + plugin.spytoggle.add(pl.getUniqueId()); + p.sendMessage(Lang.OTH_CMD_SPY_ON.toString().replace("%p", args[0])); + plugin.data.set(pl.getUniqueId().toString() + ".spy", true); + plugin.saveFile(); + } + } + } + return false; + } + +} diff --git a/src/me/ryandw11/ultrachat/commands/StaffChat.java b/src/me/ryandw11/ultrachat/commands/StaffChat.java new file mode 100644 index 0000000..d69d59e --- /dev/null +++ b/src/me/ryandw11/ultrachat/commands/StaffChat.java @@ -0,0 +1,60 @@ +package me.ryandw11.ultrachat.commands; + +import org.bukkit.Bukkit; +import org.bukkit.ChatColor; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +import me.ryandw11.ultrachat.UltraChat; +import me.ryandw11.ultrachat.api.Lang; + +public class StaffChat implements CommandExecutor { + private UltraChat plugin; + public StaffChat(){ + plugin = UltraChat.plugin; + } + + + @Override + public boolean onCommand(CommandSender sender, Command cmd, String s, String[] args) { + + CommandSender p = sender; + if(p.hasPermission("ultrachat.staffchat")){ + String message = ""; + + if(args.length > 0){ + + for (int i = 0; i < args.length; i++){ + message = message + " " + args[i]; + + } + for(Player p1 : Bukkit.getOnlinePlayers()){ + if(p1.hasPermission("ultrachat.staffchat")){ + if(!plugin.stafftoggle.contains(p1.getUniqueId())){ + p1.sendMessage(Lang.STAFF_CHAT_FORMAT.toString().replace("%p", p.getName()).replace("%s", message)); + }// end of if + } + }//end of for + plugin.getLogger().info(Lang.STAFF_CHAT_FORMAT.toString().replace("%p", p.getName()).replace("%s", message)); + }//end + else{ + p.sendMessage(ChatColor.RED + "Not enough words. Ussage: /sc (message)"); + } + + + }//end of perm check + else{ + p.sendMessage(Lang.NO_PERM.toString()); + + } + + + + + + return false; + } + +} diff --git a/src/me/ryandw11/ultrachat/commands/StaffChatToggle.java b/src/me/ryandw11/ultrachat/commands/StaffChatToggle.java new file mode 100644 index 0000000..d2affb5 --- /dev/null +++ b/src/me/ryandw11/ultrachat/commands/StaffChatToggle.java @@ -0,0 +1,44 @@ +package me.ryandw11.ultrachat.commands; + +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +import me.ryandw11.ultrachat.UltraChat; +import me.ryandw11.ultrachat.api.Lang; +/** + * StaffChat Toggle command. + * @author Ryandw11 + * + */ +public class StaffChatToggle implements CommandExecutor { + + private UltraChat plugin; + public StaffChatToggle(){ + plugin = UltraChat.plugin; + } + + @Override + public boolean onCommand(CommandSender sender, Command cmd, String s, String[] args) { + if(!(sender instanceof Player)){ + plugin.getLogger().info("That command is for players only!"); + return true; + } + Player p = (Player) sender; + if(p.hasPermission("ultrachat.staffchat.toggle")){ + + if(plugin.stafftoggle.contains(p.getUniqueId())){ + plugin.stafftoggle.remove(p.getUniqueId()); + p.sendMessage(Lang.STAFF_CHAT_ON.toString()); + + } + else{ + plugin.stafftoggle.add(p.getUniqueId()); + p.sendMessage(Lang.STAFF_CHAT_OFF.toString()); + } + }//end of perm check + return false; + } + +} \ No newline at end of file diff --git a/src/me/ryandw11/ultrachat/commands/World.java b/src/me/ryandw11/ultrachat/commands/World.java new file mode 100644 index 0000000..b57e245 --- /dev/null +++ b/src/me/ryandw11/ultrachat/commands/World.java @@ -0,0 +1,74 @@ +package me.ryandw11.ultrachat.commands; + +import java.util.ArrayList; +import java.util.HashSet; + +import org.bukkit.Bukkit; +import org.bukkit.ChatColor; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +import me.ryandw11.ultrachat.UltraChat; +import me.ryandw11.ultrachat.api.JSON; +import me.ryandw11.ultrachat.api.Lang; +import me.ryandw11.ultrachat.api.UltraChatAPI; +import me.ryandw11.ultrachat.api.WorldChatEvent; +import me.ryandw11.ultrachat.formatting.PlayerFormatting; + +public class World implements CommandExecutor { + private UltraChat plugin; + public World(){ + plugin = UltraChat.plugin; + } + + @SuppressWarnings("unchecked") + @Override + public boolean onCommand(CommandSender sender, Command cmd, String s, String[] args) { + if(!(sender instanceof Player)){ + sender.sendMessage("§cThis command is for players only!"); + return true; + } + Player p = (Player) sender; + if(!p.hasPermission("ultrachat.world")){ + p.sendMessage(Lang.NO_PERM.toString()); + return true; + } + UltraChatAPI uapi = new UltraChatAPI(plugin); + PlayerFormatting pf = new PlayerFormatting(p); + if(!uapi.isRangeJson()){ + WorldChatEvent e = new WorldChatEvent(p, this.getMessage(args, p), new HashSet( p.getWorld().getPlayers())); + Bukkit.getServer().getPluginManager().callEvent(e); + if(!e.isCancelled()){ + for(Player pl : e.getRecipients()){ + pl.sendMessage(pf.getWorld().replace("%player%", p.getDisplayName()).replace("%prefix%", pf.getPrefix()).replace("%suffix%", pf.getSuffix()) + pf.getColor() + e.getMessage()); + } + Bukkit.getLogger().info(pf.getWorld().replace("%player%", p.getDisplayName()).replace("%prefix%", pf.getPrefix()).replace("%suffix%", pf.getSuffix()).replace('&', '§') + pf.getColor() + e.getMessage().replace('&', '§')); + } + }else{ + WorldChatEvent e = new WorldChatEvent(p, this.getMessage(args, p), new HashSet( p.getWorld().getPlayers())); + Bukkit.getServer().getPluginManager().callEvent(e); + if(!e.isCancelled()){ + JSON j = new JSON(); + for(Player pl : e.getRecipients()){ + pl.spigot().sendMessage(j.hoverMessage(pf.getWorld().replace("%player%", p.getDisplayName()).replace("%prefix%", pf.getPrefix()).replace("%suffix%", pf.getSuffix()), (ArrayList) plugin.getConfig().get("World.json"), e.getMessage(), pf.getColor(), p)); + } + Bukkit.getLogger().info(pf.getWorld().replace("%player%", p.getDisplayName()).replace("%prefix%", pf.getPrefix()).replace("%suffix%", pf.getSuffix()).replace('&', '§') + pf.getColor() + e.getMessage().replace('&', '§')); + } + } + + return false; + } + + private String getMessage(String[] args, Player p){ + String end = ""; + for(String s : args){ + end += s + " "; + } + if(p.hasPermission("ultrachat.color")) + return ChatColor.translateAlternateColorCodes('&', end); + return end; + } + +} diff --git a/src/me/ryandw11/ultrachat/formatting/Channels.java b/src/me/ryandw11/ultrachat/formatting/Channels.java new file mode 100644 index 0000000..1fd7c5f --- /dev/null +++ b/src/me/ryandw11/ultrachat/formatting/Channels.java @@ -0,0 +1,44 @@ +package me.ryandw11.ultrachat.formatting; + +import org.bukkit.Bukkit; +import org.bukkit.ChatColor; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.AsyncPlayerChatEvent; + +import me.clip.placeholderapi.PlaceholderAPI; +import me.ryandw11.ultrachat.UltraChat; +/** + * Channels without any kind of json involved. + * @author Ryandw11 + * + */ +public class Channels implements Listener { + private UltraChat plugin; + public Channels(){ + plugin = UltraChat.plugin; + } + + @EventHandler + public void onChat(AsyncPlayerChatEvent e){ + PlayerFormatting pf = new PlayerFormatting(e.getPlayer()); + Player p = e.getPlayer(); + + String channel = plugin.data.getString(p.getUniqueId() + ".channel"); + if(!plugin.channel.getBoolean(channel + ".always_appear")){ + e.getRecipients().removeAll(Bukkit.getOnlinePlayers()); + if(p.hasPermission("ultrachat.chat.color")){ + e.setMessage(ChatColor.translateAlternateColorCodes('&', e.getMessage())); + } + for(Player pl : Bukkit.getOnlinePlayers()){ + if(plugin.data.getString(pl.getUniqueId() + ".channel").equals(channel)){ + if(pl.hasPermission(plugin.channel.getString(channel + ".permission")) || plugin.channel.getString(channel + ".permission").equalsIgnoreCase("none")){ + e.getRecipients().add(pl); + } + } + } + } + e.setFormat(PlaceholderAPI.setPlaceholders(p, ChatColor.translateAlternateColorCodes('&', plugin.channel.getString(channel + ".prefix")) + ChatColor.translateAlternateColorCodes('&', plugin.channel.getString(channel + ".format").replace("%prefix%", pf.getPrefix()).replace("%suffix%", pf.getSuffix()).replace("%player%", "%s") + pf.getColor() + "%s"))); + } +} diff --git a/src/me/ryandw11/ultrachat/formatting/Chat_Json.java b/src/me/ryandw11/ultrachat/formatting/Chat_Json.java new file mode 100644 index 0000000..244d222 --- /dev/null +++ b/src/me/ryandw11/ultrachat/formatting/Chat_Json.java @@ -0,0 +1,99 @@ +package me.ryandw11.ultrachat.formatting; + +import java.util.ArrayList; +import java.util.HashSet; + +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 me.ryandw11.ultrachat.UltraChat; +import me.ryandw11.ultrachat.api.JSON; +import me.ryandw11.ultrachat.api.JsonChatEvent; +/** + * If JSON is enabled. + * @author Ryandw11 + * + */ +public class Chat_Json implements Listener{ + private UltraChat plugin; + private JSON json; + public Chat_Json(){ + plugin = UltraChat.plugin; + json = new JSON(); + } + + @SuppressWarnings("unchecked") + @EventHandler + public void onChat(AsyncPlayerChatEvent e){ + Player p = e.getPlayer(); + PlayerFormatting pf = new PlayerFormatting(p); + /* + * Check if Channel and JSON is enabled. + */ + if(plugin.channelEnabled){ + e.setCancelled(true); + String channel = plugin.data.getString(p.getUniqueId() + ".channel"); + if(!plugin.channel.getBoolean(channel + ".always_appear")){ + JsonChatEvent event = new JsonChatEvent(p, e.getMessage(), new HashSet(Bukkit.getOnlinePlayers())); + Bukkit.getServer().getPluginManager().callEvent(event); + if(!event.isCancelled()) + for(Player pl : event.getRecipients()){ + if(plugin.data.getString(pl.getUniqueId() + ".channel").equals(channel)){ + if(pl.hasPermission(plugin.channel.getString(channel + ".permission")) || plugin.channel.getString(channel + ".permission").equalsIgnoreCase("none")){ + + pl.spigot().sendMessage(json.hoverMessage(plugin.channel.getString(channel + ".prefix") + plugin.channel.getString(channel + ".format").replace("%prefix%", pf.getPrefix()).replace("%suffix%", pf.getSuffix()).replace("%player%", p.getDisplayName()), (ArrayList) plugin.channel.get(channel + ".JSON"), event.getMessage(), pf.getColor(), p)); + } + } + + } + } + else{ + JsonChatEvent event = new JsonChatEvent(p, e.getMessage(), new HashSet(Bukkit.getOnlinePlayers())); + Bukkit.getServer().getPluginManager().callEvent(event); + if(!event.isCancelled()) + for(Player pl : event.getRecipients()){ + pl.spigot().sendMessage(json.hoverMessage(plugin.channel.getString(channel + ".prefix") + plugin.channel.getString(channel + ".format").replace("%prefix%", pf.getPrefix()).replace("%suffix%", pf.getSuffix()).replace("%player%", p.getDisplayName()), (ArrayList) plugin.channel.get(channel + ".JSON"), event.getMessage(), pf.getColor(), p)); //fixed suffix bug + } + } + }else{ //if Channel is not enabled. + boolean complete = false; + e.setCancelled(true); + JsonChatEvent event = new JsonChatEvent(p, e.getMessage(), new HashSet(Bukkit.getOnlinePlayers())); + Bukkit.getServer().getPluginManager().callEvent(event); + if(!event.isCancelled()){ + if(p.isOp()){ + for(Player pl : event.getRecipients()){ + pl.spigot().sendMessage(json.hoverMessage(pf.getOpFormat().replace("%prefix%", pf.getPrefix()).replace("%suffix%", pf.getSuffix()).replace("%player%", p.getDisplayName()), (ArrayList) plugin.getConfig().get("Custom_Chat.Op_Chat.JSON"), event.getMessage(), pf.getColor(), p)); + } + return; + }else{ + int i = 1; + while(i <= plugin.getConfig().getInt("Custom_Chat.Chat_Count")){ + if(p.hasPermission(plugin.getConfig().getString("Custom_Chat." + i + ".Permission"))){ + for(Player pl : event.getRecipients()){ + pl.spigot().sendMessage(json.hoverMessage(plugin.getConfig().getString("Custom_Chat." + i +".Format").replace("%player%", p.getDisplayName()).replace("%prefix%", pf.getPrefix()).replace("%suffix%", pf.getSuffix()), (ArrayList) plugin.getConfig().get("Custom_Chat." + i +".JSON"), event.getMessage(), pf.getColor(), p)); //fixed error. + complete = true; + break; + } + } + i++; + } + } + if(complete) + return; + /* + * Normal player check + */ + if(!complete){ + for(Player pl : event.getRecipients()){ // Fixed for normal players + pl.spigot().sendMessage(json.hoverMessage(pf.getDefaultFormat().replace("%prefix%", pf.getPrefix()).replace("%suffix%", pf.getSuffix()).replace("%player%", p.getDisplayName()), (ArrayList) plugin.getConfig().get("Custom_Chat.Default_Chat.JSON"), event.getMessage(), pf.getColor(), p)); + } + } + } // if the vent is canccels + } + } +} + diff --git a/src/me/ryandw11/ultrachat/formatting/Normal.java b/src/me/ryandw11/ultrachat/formatting/Normal.java new file mode 100644 index 0000000..f0a5d20 --- /dev/null +++ b/src/me/ryandw11/ultrachat/formatting/Normal.java @@ -0,0 +1,67 @@ +package me.ryandw11.ultrachat.formatting; + +import java.util.UnknownFormatConversionException; + +import org.bukkit.Bukkit; +import org.bukkit.ChatColor; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.AsyncPlayerChatEvent; + +import me.clip.placeholderapi.PlaceholderAPI; +import me.ryandw11.ultrachat.UltraChat; +/** + * Normal chat formatting with no channels or Json. + * @author Ryandw11 + * + */ +public class Normal implements Listener { + private UltraChat plugin; + public Normal(){ + plugin = UltraChat.plugin; + } + //TODO Fix this and make it work + + @EventHandler + public void onChat(AsyncPlayerChatEvent e){ + PlayerFormatting pf = new PlayerFormatting(e.getPlayer()); + Player p = e.getPlayer(); + if(p.hasPermission("ultrachat.chat.color")){ + e.setMessage(ChatColor.translateAlternateColorCodes('&', e.getMessage())); + } + if(p.isOp()){ + try{ + e.setFormat(pf.getOpFormat().replace("%prefix%", pf.getPrefix()).replace("%suffix%", pf.getSuffix()).replace("%player%", "%s") + pf.getColor() + "%s"); + }catch (UnknownFormatConversionException ex){ + p.sendMessage(ChatColor.RED + "A fatal error has occured. Check the console for more info!"); + Bukkit.getLogger().warning(ChatColor.RED + "A fatal error has occured!"); + Bukkit.getLogger().warning(ChatColor.RED + "Your formatting seems to be a bit off! Check the config.yml Fortmat: OP"); + } + }else{ + int i = 1; + while(i <= plugin.getConfig().getInt("Custom_Chat.Chat_Count")){ + if(p.hasPermission(plugin.getConfig().getString("Custom_Chat." + i + ".Permission"))){ + try{ + e.setFormat(PlaceholderAPI.setPlaceholders(p, ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("Custom_Chat." + i +".Format").replace("%player%", "%s").replace("%prefix%", pf.getPrefix()).replace("%suffix%", pf.getSuffix())) + pf.getColor() + "%s")); + }catch (UnknownFormatConversionException ex){ + p.sendMessage(ChatColor.RED + "A fatal error has occured. Contact an administrator!"); + Bukkit.getLogger().warning(ChatColor.RED + "A fatal error has occured!"); + Bukkit.getLogger().warning(ChatColor.RED + "Your formatting seems to be a bit off! Check the config.yml Fortmat #: " + i); + } + + return; + } + i++; + } + try{ + e.setFormat(pf.getDefaultFormat().replace("%prefix%", pf.getPrefix()).replace("%suffix%", pf.getSuffix()).replace("%player%", "%s") + pf.getColor() + "%s"); + }catch(UnknownFormatConversionException ex){ + p.sendMessage(ChatColor.RED + "A fatal error has occured. Contact an administrator!"); + Bukkit.getLogger().warning(ChatColor.RED + "A fatal error has occured!"); + Bukkit.getLogger().warning(ChatColor.RED + "Your formatting seems to be a bit off! Check the config.yml Fortmat: Defualt"); + } + } + } + +} diff --git a/src/me/ryandw11/ultrachat/formatting/PlayerFormatting.java b/src/me/ryandw11/ultrachat/formatting/PlayerFormatting.java new file mode 100644 index 0000000..83a40f1 --- /dev/null +++ b/src/me/ryandw11/ultrachat/formatting/PlayerFormatting.java @@ -0,0 +1,65 @@ +package me.ryandw11.ultrachat.formatting; + +import org.bukkit.entity.Player; + +import me.clip.placeholderapi.PlaceholderAPI; +import me.ryandw11.ultrachat.UltraChat; +import me.ryandw11.ultrachat.api.Util; +import net.md_5.bungee.api.ChatColor; +/** + * Class for formatting player chat easily. (Demo: May not stay). + * @author Ryandw11 + * + */ +public class PlayerFormatting { + private UltraChat plugin; + public PlayerFormatting(Player p){ + plugin = UltraChat.plugin; + + color = ChatColor.translateAlternateColorCodes('&', plugin.data.getString(p.getUniqueId() + ".color")); + prefix = ChatColor.translateAlternateColorCodes('&', plugin.chat.getPlayerPrefix(p)); + suffix = ChatColor.translateAlternateColorCodes('&', plugin.chat.getPlayerSuffix(p)); + formatOp = PlaceholderAPI.setPlaceholders(p, ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("Custom_Chat.Op_Chat.Format"))); + defaults = PlaceholderAPI.setPlaceholders(p, ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("Custom_Chat.Default_Chat.Format"))); + global = PlaceholderAPI.setPlaceholders(p, ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("Global.format"))); + world = PlaceholderAPI.setPlaceholders(p, ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("World.format"))); + local = PlaceholderAPI.setPlaceholders(p, ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("Local.format"))); + } + private String prefix; + private String suffix; + public String color; + private String formatOp; + private String defaults; + private String global; + private String world; + private String local; + + public String getGlobal(){ + return global; + } + + public String getWorld(){ + return world; + } + + public String getLocal(){ + return local; + } + + public String getPrefix(){ + return prefix; + } + public String getSuffix(){ + return suffix; + } + public ChatColor getColor(){ + return Util.getColorFromCode(color); + } + public String getOpFormat(){ + return formatOp; + } + public String getDefaultFormat(){ + return defaults; + } + +} diff --git a/src/me/ryandw11/ultrachat/formatting/Range.java b/src/me/ryandw11/ultrachat/formatting/Range.java new file mode 100644 index 0000000..3a4ac86 --- /dev/null +++ b/src/me/ryandw11/ultrachat/formatting/Range.java @@ -0,0 +1,71 @@ +package me.ryandw11.ultrachat.formatting; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.UnknownFormatConversionException; + +import org.bukkit.Bukkit; +import org.bukkit.ChatColor; +import org.bukkit.entity.Entity; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.AsyncPlayerChatEvent; + +import me.ryandw11.ultrachat.UltraChat; +import me.ryandw11.ultrachat.api.JSON; +import me.ryandw11.ultrachat.api.JsonChatEvent; +import me.ryandw11.ultrachat.api.UltraChatAPI; + +public class Range implements Listener{ + private UltraChat plugin; + public Range(){ + plugin = UltraChat.plugin; + } + + @SuppressWarnings("unchecked") + @EventHandler + public void onChat(AsyncPlayerChatEvent e){ + Player p = e.getPlayer(); + PlayerFormatting pf = new PlayerFormatting(p); + UltraChatAPI uapi = new UltraChatAPI(plugin); + if(p.hasPermission("ultrachat.chat.color")){ + e.setMessage(ChatColor.translateAlternateColorCodes('&', e.getMessage())); + } + if(!uapi.isRangeJson()){ + e.getRecipients().removeAll(Bukkit.getOnlinePlayers()); + e.getRecipients().addAll(getNearbyPlayers(p)); + e.getRecipients().add(p); + try{ + e.setFormat(pf.getLocal().replace("%player%", "%s").replace("%prefix%", pf.getPrefix()).replace("%suffix%", pf.getSuffix()) + pf.getColor() + "%s"); + }catch(UnknownFormatConversionException ex){ + Bukkit.getLogger().severe("A fatal error has occured! The local formatting is not correct!"); + } + }else{ + e.getRecipients().removeAll(Bukkit.getOnlinePlayers()); + e.getRecipients().addAll(getNearbyPlayers(p)); + e.getRecipients().add(p); + e.setCancelled(true); + + JsonChatEvent event = new JsonChatEvent(p, e.getMessage(), new HashSet(e.getRecipients())); + Bukkit.getServer().getPluginManager().callEvent(event); + if(!event.isCancelled()){ + JSON j = new JSON(); + for(Player pl : event.getRecipients()){ + pl.spigot().sendMessage(j.hoverMessage(pf.getLocal().replace("%player%", p.getDisplayName()).replace("%prefix%", pf.getPrefix()).replace("%suffix%", pf.getSuffix()), (ArrayList) plugin.getConfig().get("Local.json"), event.getMessage(), pf.getColor(), p)); + } + } + } + } + + public ArrayList getNearbyPlayers(Player pl){ + ArrayList nearby = new ArrayList(); + double range = plugin.getConfig().getDouble("Local.range"); + for (Entity e : pl.getNearbyEntities(range, range, range)){ + if (e instanceof Player){ + nearby.add((Player) e); + } + } + return nearby; + } +} diff --git a/src/me/ryandw11/ultrachat/gui/ColorGUI.java b/src/me/ryandw11/ultrachat/gui/ColorGUI.java new file mode 100644 index 0000000..90d8794 --- /dev/null +++ b/src/me/ryandw11/ultrachat/gui/ColorGUI.java @@ -0,0 +1,355 @@ +package me.ryandw11.ultrachat.gui; + +import org.bukkit.Bukkit; +import org.bukkit.ChatColor; +import org.bukkit.Material; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.inventory.InventoryClickEvent; +import org.bukkit.inventory.Inventory; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.ItemMeta; + +import me.ryandw11.ultrachat.UltraChat; +import me.ryandw11.ultrachat.api.Lang; + +/** + * ColorGUI class. + * Updated for 1.13. + * @author Ryandw11 + * + */ +public class ColorGUI implements CommandExecutor, Listener{ + + private UltraChat plugin; + public ColorGUI(){ + plugin = UltraChat.plugin; + } + public static void openGUI(Player p){ + Inventory i = Bukkit.createInventory(null, 9*2, Lang.COLOR_GUI.toString()); + + ItemStack darkblueitem = new ItemStack(Material.BLUE_WOOL); + ItemMeta darkbluemeta = darkblueitem.getItemMeta(); + + ItemStack greenitem = new ItemStack(Material.GREEN_WOOL); + ItemMeta greenmeta = greenitem.getItemMeta(); + + ItemStack lightblueitem = new ItemStack(Material.CYAN_WOOL); + ItemMeta lightbluemeta = lightblueitem.getItemMeta(); + + ItemStack reditem = new ItemStack(Material.RED_WOOL); + ItemMeta redmeta = reditem.getItemMeta(); + + ItemStack purpleitem = new ItemStack(Material.PURPLE_WOOL); + ItemMeta purplemeta = purpleitem.getItemMeta(); + + ItemStack golditem = new ItemStack(Material.ORANGE_WOOL); + ItemMeta goldmeta = golditem.getItemMeta(); + + ItemStack lightgrayitem = new ItemStack(Material.LIGHT_GRAY_WOOL); + ItemMeta lightgraymeta = lightgrayitem.getItemMeta(); + + ItemStack grayitem = new ItemStack(Material.GRAY_WOOL); + ItemMeta graymeta = grayitem.getItemMeta(); + + ItemStack blueitem = new ItemStack(Material.LAPIS_BLOCK); + ItemMeta bluemeta = blueitem.getItemMeta(); + + ItemStack lightgreenitem = new ItemStack(Material.LIME_WOOL); + ItemMeta lightgreenmeta = lightgreenitem.getItemMeta(); + + ItemStack aquaitem = new ItemStack(Material.LIGHT_BLUE_WOOL); + ItemMeta aquameta = aquaitem.getItemMeta(); + + ItemStack lightreditem = new ItemStack(Material.PINK_WOOL); + ItemMeta lightredmeta = lightreditem.getItemMeta(); + + ItemStack pinkitem = new ItemStack(Material.MAGENTA_WOOL); + ItemMeta pinkmeta = pinkitem.getItemMeta(); + + ItemStack yellowitem = new ItemStack(Material.YELLOW_WOOL); + ItemMeta yellowmeta = yellowitem.getItemMeta(); + + ItemStack whiteitem = new ItemStack(Material.WHITE_WOOL); + ItemMeta whitemeta = whiteitem.getItemMeta(); + + //========================================================== + + darkbluemeta.setDisplayName("§1Dark Blue Color Chat"); + darkblueitem.setItemMeta(darkbluemeta); + + greenmeta.setDisplayName("§2Green Color Chat"); + greenitem.setItemMeta(greenmeta); + + lightbluemeta.setDisplayName("§3Cyan Color Chat"); + lightblueitem.setItemMeta(lightbluemeta); + + redmeta.setDisplayName("§4Red Color Chat"); + reditem.setItemMeta(redmeta); + + purplemeta.setDisplayName("§5Purple Color Chat"); + purpleitem.setItemMeta(purplemeta); + + goldmeta.setDisplayName("§6Gold Color Chat"); + golditem.setItemMeta(goldmeta); + + lightgraymeta.setDisplayName("§7Light Gray Color Chat"); + lightgrayitem.setItemMeta(lightgraymeta); + + graymeta.setDisplayName("§8Gray Color Chat"); + grayitem.setItemMeta(graymeta); + + bluemeta.setDisplayName("§9Blue Color Chat"); + blueitem.setItemMeta(bluemeta); + + lightgreenmeta.setDisplayName("§aLight Green Color Chat"); + lightgreenitem.setItemMeta(lightgreenmeta); + + aquameta.setDisplayName("§bAqua Color Chat"); + aquaitem.setItemMeta(aquameta); + + lightredmeta.setDisplayName("§cLight Red Color Chat"); + lightreditem.setItemMeta(lightredmeta); + + pinkmeta.setDisplayName("§dMagenta Color Chat"); + pinkitem.setItemMeta(pinkmeta); + + yellowmeta.setDisplayName("§eYellow Color Chat"); + yellowitem.setItemMeta(yellowmeta); + + whitemeta.setDisplayName("§fWhite Color Chat"); + whiteitem.setItemMeta(whitemeta); + //========================================================== + + + i.setItem(0, darkblueitem); + i.setItem(1, greenitem); + i.setItem(2, lightblueitem); + i.setItem(3, reditem); + i.setItem(4, purpleitem); + i.setItem(5, golditem); + i.setItem(6, lightgrayitem); + i.setItem(7, grayitem); + i.setItem(8, blueitem); + i.setItem(9, lightgreenitem); + i.setItem(10, aquaitem); + i.setItem(11, lightreditem); + i.setItem(12, pinkitem); + i.setItem(13, yellowitem); + i.setItem(14, whiteitem); + + + p.openInventory(i); + } + /* + * Command + */ + + @Override + public boolean onCommand(CommandSender sender, Command cmd, String s, String[] args) { + if(!(sender instanceof Player)){ + plugin.getLogger().info("This command is for players only!"); + return true; + } + Player p = (Player) sender; + if(p.hasPermission("ultrachat.color")){ + openGUI(p.getPlayer()); + } + else{ + p.sendMessage(Lang.NO_PERM.toString()); + } + return false; + + } + /* + * Event + */ + + @EventHandler + public void onInventoryClickEvent(InventoryClickEvent e){ + if(!e.getInventory().getName().equalsIgnoreCase(Lang.COLOR_GUI.toString())) return; + + Player p = (Player) e.getWhoClicked(); + e.setCancelled(true); + + if(e.getCurrentItem() == null || e.getCurrentItem().getType() == Material.AIR || !e.getCurrentItem().hasItemMeta()){ + p.closeInventory(); + return; + } + //================ + ItemStack item = e.getCurrentItem(); + + switch(item.getType()) { + case LAPIS_BLOCK: + if(p.hasPermission("ultrachat.color.blue")){ + p.sendMessage(ChatColor.BLUE + "You choose blue color chat!"); + p.closeInventory(); + plugin.data.set(p.getUniqueId() + ".color", "&9"); + plugin.saveFile(); + } + else{ + p.sendMessage(ChatColor.RED + "You do not have permission for this color!"); + } + break; + case WHITE_WOOL: + p.sendMessage(ChatColor.WHITE + "You choose white color chat!"); + p.closeInventory(); + plugin.data.set(p.getUniqueId() + ".color", "&f"); + plugin.saveFile(); + break; + case ORANGE_WOOL: + if(p.hasPermission("ultrachat.color.gold")){ + p.sendMessage(ChatColor.GOLD + "You choose gold color chat!"); + p.closeInventory(); + plugin.data.set(p.getUniqueId() + ".color", "&6"); + plugin.saveFile(); + }else{ + p.sendMessage(ChatColor.RED + "You do not have permission for this color!"); + } + break; + + case MAGENTA_WOOL: + if(p.hasPermission("ultrachat.color.magenta")){ + p.sendMessage(ChatColor.LIGHT_PURPLE + "You choose magenta color chat!"); + p.closeInventory(); + plugin.data.set(p.getUniqueId() + ".color", "&d"); + plugin.saveFile(); + } + else{ + p.sendMessage(ChatColor.RED + "You do not have permission for this color!"); + } + break; + + + + case LIGHT_BLUE_WOOL: + if(p.hasPermission("ultrachat.color.aqua")){ + p.sendMessage(ChatColor.AQUA + "You choose Aqua color chat!"); + p.closeInventory(); + plugin.data.set(p.getUniqueId() + ".color", "&b"); + plugin.saveFile(); + } + else{ + p.sendMessage(ChatColor.RED + "You do not have permission for this color!"); + } + break; + + + + case YELLOW_WOOL: + if(p.hasPermission("ultrachat.color.yellow")){ + p.sendMessage(ChatColor.YELLOW + "You choose yellow color chat!"); + p.closeInventory(); + plugin.data.set(p.getUniqueId() + ".color", "&e"); + plugin.saveFile(); + }else{ + p.sendMessage(ChatColor.RED + "You do not have permission for this color!"); + } + break; + + case LIME_WOOL: + if(p.hasPermission("ultrachat.color.lightgreen")){ + p.sendMessage(ChatColor.GREEN + "You choose light green color chat!"); + p.closeInventory(); + plugin.data.set(p.getUniqueId() + ".color", "&a"); + plugin.saveFile(); + }else{ + p.sendMessage(ChatColor.RED + "You do not have permission for this color!"); + } + break; + case PINK_WOOL: + if(p.hasPermission("ultrachat.color.lightred")){ + p.sendMessage(ChatColor.RED + "You choose light red color chat!"); + p.closeInventory(); + plugin.data.set(p.getUniqueId() + ".color", "&c"); + plugin.saveFile(); + }else{ + p.sendMessage(ChatColor.RED + "You do not have permission for this color!"); + } + break; + case GRAY_WOOL: + if(p.hasPermission("ultrachat.color.gray")){ + p.sendMessage(ChatColor.DARK_GRAY + "You choose gray color chat!"); + p.closeInventory(); + plugin.data.set(p.getUniqueId() + ".color", "&8"); + plugin.saveFile(); + }else{ + p.sendMessage(ChatColor.RED + "You do not have permission for this color!"); + } + break; + case LIGHT_GRAY_WOOL: + if(p.hasPermission("ultrachat.color.lightgray")){ + p.sendMessage(ChatColor.GRAY + "You choose light gray color chat!"); + p.closeInventory(); + plugin.data.set(p.getUniqueId() + ".color", "&7"); + plugin.saveFile(); + }else{ + p.sendMessage(ChatColor.RED + "You do not have permission for this color!"); + } + break; + case CYAN_WOOL: + if(p.hasPermission("ultrachat.color.cyan")){ + p.sendMessage(ChatColor.DARK_AQUA + "You choose cyan color chat!"); + p.closeInventory(); + plugin.data.set(p.getUniqueId() + ".color", "&3"); + plugin.saveFile(); + }else{ + p.sendMessage(ChatColor.RED + "You do not have permission for this color!"); + } + break; + case PURPLE_WOOL: + if(p.hasPermission("ultrachat.color.purple")){ + p.sendMessage(ChatColor.DARK_PURPLE + "You choose purple color chat!"); + p.closeInventory(); + plugin.data.set(p.getUniqueId() + ".color", "&5"); + plugin.saveFile(); + }else{ + p.sendMessage(ChatColor.RED + "You do not have permission for this color!"); + } + break; + case BLUE_WOOL: + if(p.hasPermission("ultrachat.color.darkblue")){ + p.sendMessage(ChatColor.DARK_BLUE + "You choose dark blue color chat!"); + p.closeInventory(); + plugin.data.set(p.getUniqueId() + ".color", "&1"); + plugin.saveFile(); + }else{ + p.sendMessage(ChatColor.RED + "You do not have permission for this color!"); + } + break; + case GREEN_WOOL: + if(p.hasPermission("ultrachat.color.green")){ + p.sendMessage(ChatColor.DARK_GREEN + "You choose green color chat!"); + p.closeInventory(); + plugin.data.set(p.getUniqueId() + ".color", "&2"); + plugin.saveFile(); + }else{ + p.sendMessage(ChatColor.RED + "You do not have permission for this color!"); + } + break; + case RED_WOOL: + if(p.hasPermission("ultrachat.color.red")){ + p.sendMessage(ChatColor.DARK_RED + "You choose red color chat!"); + p.closeInventory(); + plugin.data.set(p.getUniqueId() + ".color", "&4"); + plugin.saveFile(); + }else{ + p.sendMessage(ChatColor.RED + "You do not have permission for this color!"); + } + break; + default: + p.sendMessage(ChatColor.WHITE + "You choose white color chat!"); + p.closeInventory(); + plugin.data.set(p.getUniqueId() + ".color", "&f"); + plugin.saveFile(); + break; + } + + } + + +} diff --git a/src/me/ryandw11/ultrachat/listner/ConsoleLogChat.java b/src/me/ryandw11/ultrachat/listner/ConsoleLogChat.java new file mode 100644 index 0000000..bf5810b --- /dev/null +++ b/src/me/ryandw11/ultrachat/listner/ConsoleLogChat.java @@ -0,0 +1,21 @@ +package me.ryandw11.ultrachat.listner; + +import java.util.logging.Level; + +import org.bukkit.Bukkit; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; + +import me.ryandw11.ultrachat.api.JsonChatEvent; +import me.ryandw11.ultrachat.api.Lang; + +public class ConsoleLogChat implements Listener{ + + @EventHandler + public void jsonChat(JsonChatEvent e){ + String msg = e.getMessage(); + String pname = e.getPlayer().getDisplayName(); + Bukkit.getLogger().log(Level.INFO, Lang.CONSOLE_CHAT_LOG.toString().replace("%p", pname).replace("%s", msg).replace('&', '§')); + } + +} diff --git a/src/me/ryandw11/ultrachat/listner/JoinListner.java b/src/me/ryandw11/ultrachat/listner/JoinListner.java new file mode 100644 index 0000000..c43d80e --- /dev/null +++ b/src/me/ryandw11/ultrachat/listner/JoinListner.java @@ -0,0 +1,125 @@ +package me.ryandw11.ultrachat.listner; + +import java.util.List; + +import me.clip.placeholderapi.PlaceholderAPI; +import me.ryandw11.ultrachat.UltraChat; +import me.ryandw11.ultrachat.api.Lang; + +import org.bukkit.Bukkit; +import org.bukkit.ChatColor; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerJoinEvent; +import org.bukkit.event.player.PlayerQuitEvent; +/** + * @author Ryandw11 + */ +public class JoinListner implements Listener { + + private UltraChat plugin; + public JoinListner(){ + plugin = UltraChat.plugin; + } + + @EventHandler + public void onJoin(PlayerJoinEvent event){ + Player p = event.getPlayer(); + + if(plugin.data.contains(p.getUniqueId().toString())){ + if(!(plugin.channel.contains(plugin.data.getString(p.getUniqueId() + ".channel")))){ + /* + * Fail safe so that if the player joins with an invalid channel it goes back to default. + */ + plugin.data.set(p.getUniqueId() + ".channel", plugin.getConfig().getString("Default_Channel")); + plugin.saveFile(); + + }else if(!(plugin.data.contains(p.getUniqueId().toString() + ".spy"))){ + plugin.data.set(p.getUniqueId().toString() + ".spy", false); + plugin.saveFile(); + } + } + else{ + plugin.data.set(p.getUniqueId().toString() + ".color", "&f"); + plugin.data.set(p.getUniqueId().toString() + ".sjoin", false); + plugin.data.set(p.getUniqueId().toString() + ".spy", false); + plugin.data.set(p.getUniqueId().toString() + ".channel", plugin.getConfig().getString("Default_Channel")); + plugin.saveFile(); + } + + if(plugin.data.getBoolean(p.getUniqueId().toString() + ".sjoin")){ + event.setJoinMessage(""); + for(Player pl : Bukkit.getOnlinePlayers()){ + if(pl.hasPermission("ultrachat.sjoin.alert")){ + pl.sendMessage(Lang.SILENT_JOIN_MESSAGE.toString().replace("%p", p.getDisplayName())); + } + } + + }else{ + + String Join = ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("Join_Message").replace("%player%", p.getName())); + event.setJoinMessage(Join); + } + + + } + + /* + * On leave event + */ + @EventHandler + public void onLeave(PlayerQuitEvent event){ + + Player p = event.getPlayer(); + if(plugin.data.getBoolean(p.getUniqueId().toString() + ".sjoin")){ + event.setQuitMessage(""); + for(Player pl : Bukkit.getOnlinePlayers()){ + if(pl.hasPermission("ultrachat.sjoin.alert")){ + pl.sendMessage(Lang.SILENT_LEAVE_MESSAGE.toString().replace("%p", p.getDisplayName())); + } + } + }else{ + + String leave = ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("Leave_Message").replace("%player%", p.getName())); + event.setQuitMessage(leave); + } + } + + + + + /* + * For MOTD + */ + @EventHandler + public void MOTD(PlayerJoinEvent event){ + Player p = event.getPlayer(); + if(plugin.getConfig().getBoolean("Motd_Enabled")){ + List motd = plugin.getConfig().getStringList("Motd"); + for(String OutPut : motd){ + String message = OutPut; + message = PlaceholderAPI.setPlaceholders(p, message); + p.sendMessage(ChatColor.translateAlternateColorCodes('&', message)); + } + + } + + } + + /* + * If there is a new player. + */ + + @EventHandler + public void NewPlayer(PlayerJoinEvent event){ + Player p = event.getPlayer(); + if(!(p.hasPlayedBefore()) && !(plugin.getConfig().getString("New_Player").equalsIgnoreCase("none"))){ + Bukkit.getServer().broadcastMessage(ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("New_Player").replace("%player%", p.getDisplayName()))); + } + + } + + + +} diff --git a/src/me/ryandw11/ultrachat/listner/NoSwear.java b/src/me/ryandw11/ultrachat/listner/NoSwear.java new file mode 100644 index 0000000..1b6b186 --- /dev/null +++ b/src/me/ryandw11/ultrachat/listner/NoSwear.java @@ -0,0 +1,73 @@ +package me.ryandw11.ultrachat.listner; + +import java.util.List; + +import me.ryandw11.ultrachat.UltraChat; +import me.ryandw11.ultrachat.api.JsonChatEvent; +import me.ryandw11.ultrachat.api.Lang; + +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.AsyncPlayerChatEvent; +/** + * @author Ryandw11 + */ +public class NoSwear implements Listener { + + private UltraChat plugin; + public NoSwear(){ + plugin = UltraChat.plugin; + } + + + + @EventHandler + public void onPlayerChat(AsyncPlayerChatEvent event) { + if(plugin.JSON) return; + + if(plugin.getConfig().getBoolean("Anti_Swear_Enabled")){ + Player p = event.getPlayer(); + + + List swear = plugin.getConfig().getStringList("Blocked_Words"); + int times = 0; + + String Message = " " + event.getMessage().toLowerCase().replace(".", "") + " "; + + for(String swearWord : swear){ + //Check if world chat is enabled + if(Message.contains(swearWord + " ") && times == 0 || Message.contains(" " + swearWord + " ") && times == 0 || Message.contains(" " + swearWord) && times == 0 || Message.contains(swearWord)){ + //else do this: + event.setCancelled(true); + p.sendMessage(Lang.NO_SWEAR.toString()); + break; + } + } + } + } + + @EventHandler + public void onJsonChat(JsonChatEvent event){ + if(plugin.getConfig().getBoolean("Anti_Swear_Enabled")){ + Player p = event.getPlayer(); + + + List swear = plugin.getConfig().getStringList("Blocked_Words"); + int times = 0; + + String Message = " " + event.getMessage().toLowerCase().replace(".", "") + " "; + + for(String swearWord : swear){ + //Check if world chat is enabled + if(Message.contains(swearWord + " ") && times == 0 || Message.contains(" " + swearWord + " ") && times == 0 || Message.contains(" " + swearWord) && times == 0 || Message.contains(swearWord)){ + //else do this: + event.setCancelled(true); + p.sendMessage(Lang.NO_SWEAR.toString()); + break; + } + } + } + } + +} diff --git a/src/me/ryandw11/ultrachat/listner/Notify.java b/src/me/ryandw11/ultrachat/listner/Notify.java new file mode 100644 index 0000000..85d1c8b --- /dev/null +++ b/src/me/ryandw11/ultrachat/listner/Notify.java @@ -0,0 +1,49 @@ +package me.ryandw11.ultrachat.listner; + +import org.bukkit.Bukkit; +import org.bukkit.Sound; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.AsyncPlayerChatEvent; + +import me.ryandw11.ultrachat.UltraChat; +import me.ryandw11.ultrachat.api.JsonChatEvent; +import me.ryandw11.ultrachat.api.Lang; +/** + * + * @author Ryandw11 + * Updated for 1.13 + * + */ +public class Notify implements Listener { + + private UltraChat plugin; + public Notify(){ + plugin = UltraChat.plugin; + } + + + @EventHandler + public void onChat(AsyncPlayerChatEvent event){ + if(plugin.JSON) return; + for(Player p : Bukkit.getOnlinePlayers()){ + if(event.getMessage().contains("@" + p.getName())){ + p.playSound(p.getLocation(), Sound.BLOCK_NOTE_BLOCK_PLING, 10, 0); + p.sendMessage(Lang.MENTION.toString().replace("%p", event.getPlayer().getDisplayName())); + } + } + } + + @EventHandler + public void onJsonChat(JsonChatEvent e){ + for(Player p : Bukkit.getOnlinePlayers()){ + if(e.getMessage().contains("@" + p.getName())){ + p.playSound(p.getLocation(), Sound.BLOCK_NOTE_BLOCK_PLING, 10, 0); + p.sendMessage(Lang.MENTION.toString().replace("%p", e.getPlayer().getDisplayName())); + } + } + } + + +} diff --git a/src/me/ryandw11/ultrachat/listner/Spy.java b/src/me/ryandw11/ultrachat/listner/Spy.java new file mode 100644 index 0000000..048e2ec --- /dev/null +++ b/src/me/ryandw11/ultrachat/listner/Spy.java @@ -0,0 +1,38 @@ +package me.ryandw11.ultrachat.listner; + +import me.ryandw11.ultrachat.UltraChat; +import me.ryandw11.ultrachat.api.Lang; + +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; + +public class Spy implements Listener{ + + private UltraChat plugin; + public Spy(){ + plugin = UltraChat.plugin; + } + + @EventHandler + public void onPlayerCommand(PlayerCommandPreprocessEvent event){ + Player p1 = (Player) event.getPlayer(); + String msg = event.getMessage();//get user name + + for(Player p : Bukkit.getOnlinePlayers()){ + if(plugin.spytoggle.contains(p.getUniqueId())){ + p.sendMessage(Lang.CMD_SPY_FORMAT.toString().replace("%p", p1.getName()).replace("%s", msg)); + }// end of if + + + }//end of for loop + + + + + } + + +} \ No newline at end of file diff --git a/src/me/ryandw11/ultrachat/listner/StopChat.java b/src/me/ryandw11/ultrachat/listner/StopChat.java new file mode 100644 index 0000000..8be8ffd --- /dev/null +++ b/src/me/ryandw11/ultrachat/listner/StopChat.java @@ -0,0 +1,48 @@ +package me.ryandw11.ultrachat.listner; + +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.AsyncPlayerChatEvent; + +import me.ryandw11.ultrachat.UltraChat; +import me.ryandw11.ultrachat.api.JsonChatEvent; +import me.ryandw11.ultrachat.api.Lang; +/** + * Prevent players from chatting when the chat is stopped. + * @author Ryandw11 + * + */ +public class StopChat implements Listener { + + private UltraChat plugin; + public StopChat(){ + plugin = UltraChat.plugin; + } + + @EventHandler + public void onPlayerChat(AsyncPlayerChatEvent event) { + if(plugin.JSON) return; + Player p = event.getPlayer(); + if(plugin.chatStop){ + if(!p.hasPermission("ultrachat.stopchat.bypass")){ + event.setCancelled(true); + p.sendMessage(Lang.STOP_CHAT_MESSAGE.toString()); + } + } + } + + @EventHandler + public void onChat(JsonChatEvent e){ + Player p = e.getPlayer(); + if(plugin.chatStop){ + if(!p.hasPermission("ultrachat.stopchat.bypass")){ + e.setCancelled(true); + p.sendMessage(Lang.STOP_CHAT_MESSAGE.toString()); + } + } + } + + + +} diff --git a/src/me/ryandw11/ultrachat/pluginhooks/AdvancedBanMute.java b/src/me/ryandw11/ultrachat/pluginhooks/AdvancedBanMute.java new file mode 100644 index 0000000..d3fcf45 --- /dev/null +++ b/src/me/ryandw11/ultrachat/pluginhooks/AdvancedBanMute.java @@ -0,0 +1,38 @@ +package me.ryandw11.ultrachat.pluginhooks; + +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; + +import me.leoko.advancedban.manager.PunishmentManager; +import me.leoko.advancedban.manager.UUIDManager; +import me.ryandw11.ultrachat.api.GlobalChatEvent; +import me.ryandw11.ultrachat.api.JsonChatEvent; +import me.ryandw11.ultrachat.api.WorldChatEvent; + +public class AdvancedBanMute implements Listener{ + + @EventHandler + public void jsonChat(JsonChatEvent e){ + Player p = e.getPlayer(); + if(PunishmentManager.get().isMuted(UUIDManager.get().getUUID(p.getName()))){ + e.setCancelled(true); + } + } + + @EventHandler + public void globalChat(GlobalChatEvent e){ + Player p = e.getPlayer(); + if(PunishmentManager.get().isMuted(UUIDManager.get().getUUID(p.getName()))){ + e.setCancelled(true); + } + } + + @EventHandler + public void worldChat(WorldChatEvent e){ + Player p = e.getPlayer(); + if(PunishmentManager.get().isMuted(UUIDManager.get().getUUID(p.getName()))){ + e.setCancelled(true); + } + } +} diff --git a/src/me/ryandw11/ultrachat/pluginhooks/EssentialsMute.java b/src/me/ryandw11/ultrachat/pluginhooks/EssentialsMute.java new file mode 100644 index 0000000..b43f131 --- /dev/null +++ b/src/me/ryandw11/ultrachat/pluginhooks/EssentialsMute.java @@ -0,0 +1,41 @@ +package me.ryandw11.ultrachat.pluginhooks; + +import org.bukkit.Bukkit; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; + +import com.earth2me.essentials.Essentials; +import me.ryandw11.ultrachat.api.GlobalChatEvent; +import me.ryandw11.ultrachat.api.JsonChatEvent; +import me.ryandw11.ultrachat.api.WorldChatEvent; + +public class EssentialsMute implements Listener{ + + @EventHandler + public void jsonChat(JsonChatEvent e){ + Player p = e.getPlayer(); + Essentials ess = (Essentials) Bukkit.getPluginManager().getPlugin("Essentials"); + if(ess.getUser(p).isMuted()){ + e.setCancelled(true); + } + } + + @EventHandler + public void globalChat(GlobalChatEvent e){ + Player p = e.getPlayer(); + Essentials ess = (Essentials) Bukkit.getPluginManager().getPlugin("Essentials"); + if(ess.getUser(p).isMuted()){ + e.setCancelled(true); + } + } + + @EventHandler + public void worldChat(WorldChatEvent e){ + Player p = e.getPlayer(); + Essentials ess = (Essentials) Bukkit.getPluginManager().getPlugin("Essentials"); + if(ess.getUser(p).isMuted()){ + e.setCancelled(true); + } + } +} diff --git a/src/me/ryandw11/ultrachat/util/Metrics.java b/src/me/ryandw11/ultrachat/util/Metrics.java new file mode 100644 index 0000000..5cd9299 --- /dev/null +++ b/src/me/ryandw11/ultrachat/util/Metrics.java @@ -0,0 +1,668 @@ +package me.ryandw11.ultrachat.util; + +import org.bukkit.Bukkit; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.entity.Player; +import org.bukkit.plugin.RegisteredServiceProvider; +import org.bukkit.plugin.ServicePriority; +import org.bukkit.plugin.java.JavaPlugin; +import org.json.simple.JSONArray; +import org.json.simple.JSONObject; + +import javax.net.ssl.HttpsURLConnection; +import java.io.ByteArrayOutputStream; +import java.io.DataOutputStream; +import java.io.File; +import java.io.IOException; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.net.URL; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.Map; +import java.util.Timer; +import java.util.TimerTask; +import java.util.UUID; +import java.util.concurrent.Callable; +import java.util.logging.Level; +import java.util.zip.GZIPOutputStream; + +/** + * bStats collects some data for plugin authors. + * + * Check out https://bStats.org/ to learn more about bStats! + */ +@SuppressWarnings("unchecked") +public class Metrics { + + static { + // You can use the property to disable the check in your test environment + if (System.getProperty("bstats.relocatecheck") == null || !System.getProperty("bstats.relocatecheck").equals("false")) { + // Maven's Relocate is clever and changes strings, too. So we have to use this little "trick" ... :D + final String defaultPackage = new String( + new byte[]{'o', 'r', 'g', '.', 'b', 's', 't', 'a', 't', 's', '.', 'b', 'u', 'k', 'k', 'i', 't'}); + final String examplePackage = new String(new byte[]{'y', 'o', 'u', 'r', '.', 'p', 'a', 'c', 'k', 'a', 'g', 'e'}); + // We want to make sure nobody just copy & pastes the example and use the wrong package names + if (Metrics.class.getPackage().getName().equals(defaultPackage) || Metrics.class.getPackage().getName().equals(examplePackage)) { + throw new IllegalStateException("bStats Metrics class has not been relocated correctly!"); + } + } + } + + // The version of this bStats class + public static final int B_STATS_VERSION = 1; + + // The url to which the data is sent + private static final String URL = "https://bStats.org/submitData/bukkit"; + + // Should failed requests be logged? + private static boolean logFailedRequests; + + // The uuid of the server + private static String serverUUID; + + // The plugin + private final JavaPlugin plugin; + + // A list with all custom charts + private final List charts = new ArrayList<>(); + + /** + * Class constructor. + * + * @param plugin The plugin which stats should be submitted. + */ + public Metrics(JavaPlugin plugin) { + if (plugin == null) { + throw new IllegalArgumentException("Plugin cannot be null!"); + } + this.plugin = plugin; + + // Get the config file + File bStatsFolder = new File(plugin.getDataFolder().getParentFile(), "bStats"); + File configFile = new File(bStatsFolder, "config.yml"); + YamlConfiguration config = YamlConfiguration.loadConfiguration(configFile); + + // Check if the config file exists + if (!config.isSet("serverUuid")) { + + // Add default values + config.addDefault("enabled", true); + // Every server gets it's unique random id. + config.addDefault("serverUuid", UUID.randomUUID().toString()); + // Should failed request be logged? + config.addDefault("logFailedRequests", false); + + // Inform the server owners about bStats + config.options().header( + "bStats collects some data for plugin authors like how many servers are using their plugins.\n" + + "To honor their work, you should not disable it.\n" + + "This has nearly no effect on the server performance!\n" + + "Check out https://bStats.org/ to learn more :)" + ).copyDefaults(true); + try { + config.save(configFile); + } catch (IOException ignored) { } + } + + // Load the data + serverUUID = config.getString("serverUuid"); + logFailedRequests = config.getBoolean("logFailedRequests", false); + if (config.getBoolean("enabled", true)) { + boolean found = false; + // Search for all other bStats Metrics classes to see if we are the first one + for (Class service : Bukkit.getServicesManager().getKnownServices()) { + try { + service.getField("B_STATS_VERSION"); // Our identifier :) + found = true; // We aren't the first + break; + } catch (NoSuchFieldException ignored) { } + } + // Register our service + Bukkit.getServicesManager().register(Metrics.class, this, plugin, ServicePriority.Normal); + if (!found) { + // We are the first! + startSubmitting(); + } + } + } + + /** + * Adds a custom chart. + * + * @param chart The chart to add. + */ + public void addCustomChart(CustomChart chart) { + if (chart == null) { + throw new IllegalArgumentException("Chart cannot be null!"); + } + charts.add(chart); + } + + /** + * Starts the Scheduler which submits our data every 30 minutes. + */ + private void startSubmitting() { + final Timer timer = new Timer(true); // We use a timer cause the Bukkit scheduler is affected by server lags + timer.scheduleAtFixedRate(new TimerTask() { + @Override + public void run() { + if (!plugin.isEnabled()) { // Plugin was disabled + timer.cancel(); + return; + } + // Nevertheless we want our code to run in the Bukkit main thread, so we have to use the Bukkit scheduler + // Don't be afraid! The connection to the bStats server is still async, only the stats collection is sync ;) + Bukkit.getScheduler().runTask(plugin, new Runnable() { + @Override + public void run() { + submitData(); + } + }); + } + }, 1000*60*5, 1000*60*30); + // Submit the data every 30 minutes, first time after 5 minutes to give other plugins enough time to start + // WARNING: Changing the frequency has no effect but your plugin WILL be blocked/deleted! + // WARNING: Just don't do it! + } + + /** + * Gets the plugin specific data. + * This method is called using Reflection. + * + * @return The plugin specific data. + */ + public JSONObject getPluginData() { + JSONObject data = new JSONObject(); + + String pluginName = plugin.getDescription().getName(); + String pluginVersion = plugin.getDescription().getVersion(); + + data.put("pluginName", pluginName); // Append the name of the plugin + data.put("pluginVersion", pluginVersion); // Append the version of the plugin + JSONArray customCharts = new JSONArray(); + for (CustomChart customChart : charts) { + // Add the data of the custom charts + JSONObject chart = customChart.getRequestJsonObject(); + if (chart == null) { // If the chart is null, we skip it + continue; + } + customCharts.add(chart); + } + data.put("customCharts", customCharts); + + return data; + } + + /** + * Gets the server specific data. + * + * @return The server specific data. + */ + private JSONObject getServerData() { + // Minecraft specific data + int playerAmount; + try { + // Around MC 1.8 the return type was changed to a collection from an array, + // This fixes java.lang.NoSuchMethodError: org.bukkit.Bukkit.getOnlinePlayers()Ljava/util/Collection; + Method onlinePlayersMethod = Class.forName("org.bukkit.Server").getMethod("getOnlinePlayers"); + playerAmount = onlinePlayersMethod.getReturnType().equals(Collection.class) + ? ((Collection) onlinePlayersMethod.invoke(Bukkit.getServer())).size() + : ((Player[]) onlinePlayersMethod.invoke(Bukkit.getServer())).length; + } catch (Exception e) { + playerAmount = Bukkit.getOnlinePlayers().size(); // Just use the new method if the Reflection failed + } + int onlineMode = Bukkit.getOnlineMode() ? 1 : 0; + String bukkitVersion = org.bukkit.Bukkit.getVersion(); + bukkitVersion = bukkitVersion.substring(bukkitVersion.indexOf("MC: ") + 4, bukkitVersion.length() - 1); + + // OS/Java specific data + String javaVersion = System.getProperty("java.version"); + String osName = System.getProperty("os.name"); + String osArch = System.getProperty("os.arch"); + String osVersion = System.getProperty("os.version"); + int coreCount = Runtime.getRuntime().availableProcessors(); + + JSONObject data = new JSONObject(); + + data.put("serverUUID", serverUUID); + + data.put("playerAmount", playerAmount); + data.put("onlineMode", onlineMode); + data.put("bukkitVersion", bukkitVersion); + + data.put("javaVersion", javaVersion); + data.put("osName", osName); + data.put("osArch", osArch); + data.put("osVersion", osVersion); + data.put("coreCount", coreCount); + + return data; + } + + /** + * Collects the data and sends it afterwards. + */ + private void submitData() { + final JSONObject data = getServerData(); + + JSONArray pluginData = new JSONArray(); + // Search for all other bStats Metrics classes to get their plugin data + for (Class service : Bukkit.getServicesManager().getKnownServices()) { + try { + service.getField("B_STATS_VERSION"); // Our identifier :) + + for (RegisteredServiceProvider provider : Bukkit.getServicesManager().getRegistrations(service)) { + try { + pluginData.add(provider.getService().getMethod("getPluginData").invoke(provider.getProvider())); + } catch (NullPointerException | NoSuchMethodException | IllegalAccessException | InvocationTargetException ignored) { } + } + } catch (NoSuchFieldException ignored) { } + } + + data.put("plugins", pluginData); + + // Create a new thread for the connection to the bStats server + new Thread(new Runnable() { + @Override + public void run() { + try { + // Send the data + sendData(data); + } catch (Exception e) { + // Something went wrong! :( + if (logFailedRequests) { + plugin.getLogger().log(Level.WARNING, "Could not submit plugin stats of " + plugin.getName(), e); + } + } + } + }).start(); + } + + /** + * Sends the data to the bStats server. + * + * @param data The data to send. + * @throws Exception If the request failed. + */ + private static void sendData(JSONObject data) throws Exception { + if (data == null) { + throw new IllegalArgumentException("Data cannot be null!"); + } + if (Bukkit.isPrimaryThread()) { + throw new IllegalAccessException("This method must not be called from the main thread!"); + } + HttpsURLConnection connection = (HttpsURLConnection) new URL(URL).openConnection(); + + // Compress the data to save bandwidth + byte[] compressedData = compress(data.toString()); + + // Add headers + connection.setRequestMethod("POST"); + connection.addRequestProperty("Accept", "application/json"); + connection.addRequestProperty("Connection", "close"); + connection.addRequestProperty("Content-Encoding", "gzip"); // We gzip our request + connection.addRequestProperty("Content-Length", String.valueOf(compressedData.length)); + connection.setRequestProperty("Content-Type", "application/json"); // We send our data in JSON format + connection.setRequestProperty("User-Agent", "MC-Server/" + B_STATS_VERSION); + + // Send data + connection.setDoOutput(true); + DataOutputStream outputStream = new DataOutputStream(connection.getOutputStream()); + outputStream.write(compressedData); + outputStream.flush(); + outputStream.close(); + + connection.getInputStream().close(); // We don't care about the response - Just send our data :) + } + + /** + * Gzips the given String. + * + * @param str The string to gzip. + * @return The gzipped String. + * @throws IOException If the compression failed. + */ + private static byte[] compress(final String str) throws IOException { + if (str == null) { + return null; + } + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + GZIPOutputStream gzip = new GZIPOutputStream(outputStream); + gzip.write(str.getBytes("UTF-8")); + gzip.close(); + return outputStream.toByteArray(); + } + + /** + * Represents a custom chart. + */ + public static abstract class CustomChart { + + // The id of the chart + final String chartId; + + /** + * Class constructor. + * + * @param chartId The id of the chart. + */ + CustomChart(String chartId) { + if (chartId == null || chartId.isEmpty()) { + throw new IllegalArgumentException("ChartId cannot be null or empty!"); + } + this.chartId = chartId; + } + + private JSONObject getRequestJsonObject() { + JSONObject chart = new JSONObject(); + chart.put("chartId", chartId); + try { + JSONObject data = getChartData(); + if (data == null) { + // If the data is null we don't send the chart. + return null; + } + chart.put("data", data); + } catch (Throwable t) { + if (logFailedRequests) { + Bukkit.getLogger().log(Level.WARNING, "Failed to get data for custom chart with id " + chartId, t); + } + return null; + } + return chart; + } + + protected abstract JSONObject getChartData() throws Exception; + + } + + /** + * Represents a custom simple pie. + */ + public static class SimplePie extends CustomChart { + + private final Callable callable; + + /** + * Class constructor. + * + * @param chartId The id of the chart. + * @param callable The callable which is used to request the chart data. + */ + public SimplePie(String chartId, Callable callable) { + super(chartId); + this.callable = callable; + } + + @Override + protected JSONObject getChartData() throws Exception { + JSONObject data = new JSONObject(); + String value = callable.call(); + if (value == null || value.isEmpty()) { + // Null = skip the chart + return null; + } + data.put("value", value); + return data; + } + } + + /** + * Represents a custom advanced pie. + */ + public static class AdvancedPie extends CustomChart { + + private final Callable> callable; + + /** + * Class constructor. + * + * @param chartId The id of the chart. + * @param callable The callable which is used to request the chart data. + */ + public AdvancedPie(String chartId, Callable> callable) { + super(chartId); + this.callable = callable; + } + + @Override + protected JSONObject getChartData() throws Exception { + JSONObject data = new JSONObject(); + JSONObject values = new JSONObject(); + Map map = callable.call(); + if (map == null || map.isEmpty()) { + // Null = skip the chart + return null; + } + boolean allSkipped = true; + for (Map.Entry entry : map.entrySet()) { + if (entry.getValue() == 0) { + continue; // Skip this invalid + } + allSkipped = false; + values.put(entry.getKey(), entry.getValue()); + } + if (allSkipped) { + // Null = skip the chart + return null; + } + data.put("values", values); + return data; + } + } + + /** + * Represents a custom drilldown pie. + */ + public static class DrilldownPie extends CustomChart { + + private final Callable>> callable; + + /** + * Class constructor. + * + * @param chartId The id of the chart. + * @param callable The callable which is used to request the chart data. + */ + public DrilldownPie(String chartId, Callable>> callable) { + super(chartId); + this.callable = callable; + } + + @Override + public JSONObject getChartData() throws Exception { + JSONObject data = new JSONObject(); + JSONObject values = new JSONObject(); + Map> map = callable.call(); + if (map == null || map.isEmpty()) { + // Null = skip the chart + return null; + } + boolean reallyAllSkipped = true; + for (Map.Entry> entryValues : map.entrySet()) { + JSONObject value = new JSONObject(); + boolean allSkipped = true; + for (Map.Entry valueEntry : map.get(entryValues.getKey()).entrySet()) { + value.put(valueEntry.getKey(), valueEntry.getValue()); + allSkipped = false; + } + if (!allSkipped) { + reallyAllSkipped = false; + values.put(entryValues.getKey(), value); + } + } + if (reallyAllSkipped) { + // Null = skip the chart + return null; + } + data.put("values", values); + return data; + } + } + + /** + * Represents a custom single line chart. + */ + public static class SingleLineChart extends CustomChart { + + private final Callable callable; + + /** + * Class constructor. + * + * @param chartId The id of the chart. + * @param callable The callable which is used to request the chart data. + */ + public SingleLineChart(String chartId, Callable callable) { + super(chartId); + this.callable = callable; + } + + @Override + protected JSONObject getChartData() throws Exception { + JSONObject data = new JSONObject(); + int value = callable.call(); + if (value == 0) { + // Null = skip the chart + return null; + } + data.put("value", value); + return data; + } + + } + + /** + * Represents a custom multi line chart. + */ + public static class MultiLineChart extends CustomChart { + + private final Callable> callable; + + /** + * Class constructor. + * + * @param chartId The id of the chart. + * @param callable The callable which is used to request the chart data. + */ + public MultiLineChart(String chartId, Callable> callable) { + super(chartId); + this.callable = callable; + } + + @Override + protected JSONObject getChartData() throws Exception { + JSONObject data = new JSONObject(); + JSONObject values = new JSONObject(); + Map map = callable.call(); + if (map == null || map.isEmpty()) { + // Null = skip the chart + return null; + } + boolean allSkipped = true; + for (Map.Entry entry : map.entrySet()) { + if (entry.getValue() == 0) { + continue; // Skip this invalid + } + allSkipped = false; + values.put(entry.getKey(), entry.getValue()); + } + if (allSkipped) { + // Null = skip the chart + return null; + } + data.put("values", values); + return data; + } + + } + + /** + * Represents a custom simple bar chart. + */ + public static class SimpleBarChart extends CustomChart { + + private final Callable> callable; + + /** + * Class constructor. + * + * @param chartId The id of the chart. + * @param callable The callable which is used to request the chart data. + */ + public SimpleBarChart(String chartId, Callable> callable) { + super(chartId); + this.callable = callable; + } + + @Override + protected JSONObject getChartData() throws Exception { + JSONObject data = new JSONObject(); + JSONObject values = new JSONObject(); + Map map = callable.call(); + if (map == null || map.isEmpty()) { + // Null = skip the chart + return null; + } + for (Map.Entry entry : map.entrySet()) { + JSONArray categoryValues = new JSONArray(); + categoryValues.add(entry.getValue()); + values.put(entry.getKey(), categoryValues); + } + data.put("values", values); + return data; + } + + } + + /** + * Represents a custom advanced bar chart. + */ + public static class AdvancedBarChart extends CustomChart { + + private final Callable> callable; + + /** + * Class constructor. + * + * @param chartId The id of the chart. + * @param callable The callable which is used to request the chart data. + */ + public AdvancedBarChart(String chartId, Callable> callable) { + super(chartId); + this.callable = callable; + } + + @Override + protected JSONObject getChartData() throws Exception { + JSONObject data = new JSONObject(); + JSONObject values = new JSONObject(); + Map map = callable.call(); + if (map == null || map.isEmpty()) { + // Null = skip the chart + return null; + } + boolean allSkipped = true; + for (Map.Entry entry : map.entrySet()) { + if (entry.getValue().length == 0) { + continue; // Skip this invalid + } + allSkipped = false; + JSONArray categoryValues = new JSONArray(); + for (int categoryValue : entry.getValue()) { + categoryValues.add(categoryValue); + } + values.put(entry.getKey(), categoryValues); + } + if (allSkipped) { + // Null = skip the chart + return null; + } + data.put("values", values); + return data; + } + + } +}