Initial Commit

src/main/java/com/fpghoti/fpchatx/chat/ChatChannel.java

@@ -0,0 +1,344 @@
+package com.fpghoti.fpchatx.chat;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.UUID;
+import java.util.logging.Level;
+
+import org.bukkit.ChatColor;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.entity.Player;
+
+import com.fpghoti.fpchatx.FPChat;
+import com.fpghoti.fpchatx.badge.BadgeList;
+import com.fpghoti.fpchatx.config.ChannelFile;
+import com.fpghoti.fpchatx.customcodes.BubbleCode;
+import com.fpghoti.fpchatx.customcodes.Codify;
+import com.fpghoti.fpchatx.permission.Permission;
+import com.fpghoti.fpchatx.player.FPlayer;
+
+public abstract class ChatChannel {
+
+	private static ChatChannel defaultChannel = null;
+	private static ArrayList<StandardChannel> channels;
+	private static ArrayList<TempChannel> tempchannels;
+	private static ChatChannel shout;
+	private static final String[] reserved = {"shout"};
+
+	private static ArrayList<String> loadChannelNames() {
+		ArrayList<String> cnames = new ArrayList<String>();
+		for(File f : ChannelFile.getChannelFiles()) {
+			String fname = f.getName();
+			cnames.add(fname.substring(0, fname.length()-4));
+		}
+		return cnames;
+	}
+	
+
+	public static StandardChannel loadChannel(String channelname) {
+		if(ChannelFile.channelExists(channelname)) {
+			return makeChannel(channelname);
+		}
+		return null;
+	}
+
+	public static StandardChannel makeChannel(String channelname) {
+		ChannelFile file = new ChannelFile(FPChat.getPlugin(), channelname);
+		StandardChannel c = new StandardChannel(FPChat.getPlugin(), file);
+		return c;
+	}
+
+	public static TempChannel makeTempChannel(FPlayer owner, String channelname) {
+		TempChannel t = new TempChannel(FPChat.getPlugin(), owner, channelname);
+		t.setShortcut(channelname);
+		tempchannels.add(t);
+		return t;
+	}
+	
+	public static void setShout(ShoutChannel shoutchannel) {
+		shout = shoutchannel;
+	}
+
+	public static void deleteChannel(String channelname) {
+		ChatChannel c = getChannel(channelname);
+		boolean temp = false;
+		if(c == null) {
+			c = getTempChannel(channelname);
+			temp = true;
+		}
+		if(c != null) {
+			String cname = c.getName();
+			for(FPlayer pl : c.getPlayers()) {
+				pl.leaveChannel(cname);
+				FPlayer.dualMsg(pl, ChatColor.YELLOW + "The channel you were in " + ChatColor.WHITE + c.getName() + ChatColor.YELLOW + " was deleted.");
+			}
+			tempchannels.remove(c);
+			channels.remove(c);
+			if(!temp) {
+				File cdir = new File(FPChat.getPlugin().getDataFolder() + File.separator + "channels");
+				cdir.mkdirs();
+				File configFile = new File(cdir, cname + ".yml");
+				if(configFile.delete()) {
+					FPChat.getPlugin().log(Level.INFO, "Channel file for " + cname + " successfully deleted.");
+				} else {
+					FPChat.getPlugin().log(Level.SEVERE, "======================================================");
+					FPChat.getPlugin().log(Level.SEVERE, "| ------------------ FPCHATX ERROR ----------------- |");
+					FPChat.getPlugin().log(Level.SEVERE, "======================================================");
+					FPChat.getPlugin().log(Level.SEVERE, "| Channel not properly removed. File deletion error. |");
+					FPChat.getPlugin().log(Level.SEVERE, "| ---------- Check the file and try again. --------- |");
+					FPChat.getPlugin().log(Level.SEVERE, "======================================================");
+					return;
+				}
+			}else {
+				FPChat.getPlugin().log(Level.INFO, "Temp Channel " + cname + " was deleted.");
+			}
+		}
+	}
+
+	public static ChatChannel getDefault() {
+		return defaultChannel;
+	}
+	
+	public static void setDefault(String channel) {
+		defaultChannel = getChannel(channel);
+	}
+
+	public static ArrayList<ChatChannel> getChannels(){
+		ArrayList<ChatChannel> c = new ArrayList<ChatChannel>();
+		for(StandardChannel ch : channels) {
+			c.add(ch);
+		}
+		for(TempChannel ch : tempchannels) {
+			c.add(ch);
+		}
+		return c;
+	}
+
+	public static ChatChannel getChannel(String name) {
+		for(ChatChannel c : channels) {
+			if(c.getName().equalsIgnoreCase(name)) {
+				return c;
+			}
+		}
+		return null;
+	}
+
+	public static ChatChannel getTempChannel(String name) {
+		for(ChatChannel c : tempchannels) {
+			if(c.getName().equalsIgnoreCase(name)) {
+				return c;
+			}
+		}
+		return null;
+	}
+
+	public static void loadChannels() {
+		shout = (ChatChannel)(new ShoutChannel(FPChat.getPlugin()));
+		channels = new ArrayList<StandardChannel>();
+		tempchannels = new ArrayList<TempChannel>();
+		for(String c : loadChannelNames()) {
+			StandardChannel chan = loadChannel(c);
+			if(chan != null) {
+				channels.add(chan);
+			}
+		}
+	}
+
+	public static ChatChannel getShout() {
+		return shout;
+	}
+
+	public static boolean channelExists(String name) {
+		for(ChatChannel c : getChannels()) {
+			if(c.getName().equalsIgnoreCase(name)) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	public static boolean isReserved(String name) {
+		if(channelExists(name)) {
+			return true;
+		}
+		for(String s : reserved) {
+			if(s.equalsIgnoreCase(name)) {
+				return true;
+			}
+		}
+		return false;
+	}
+	
+	public static void addChannel(StandardChannel channel) {
+		channels.add(channel);
+	}
+
+	protected FPChat plugin;
+	protected String name;
+	protected String shortcut;
+	protected String chatFormat;
+	protected String distinguishedChatFormat;
+	protected boolean isWhitelisted;
+
+	protected ArrayList<UUID> whitelist;
+	protected ArrayList<UUID> banned;
+
+	public ChatChannel(FPChat plugin) {
+		this.plugin = plugin;
+		this.isWhitelisted = false;
+		this.whitelist = new ArrayList<UUID>();
+	}
+
+	public void makeDefault() {
+		ChatChannel.defaultChannel = this;
+	}
+
+	public abstract boolean isTemp();
+
+	public abstract boolean isDefault();
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	public String getName() {
+		return this.name;
+	}
+
+	public abstract void kick(FPlayer p);
+
+	public abstract void setShortcut(String shortcut);
+
+	public String getShortcut() {
+		return this.shortcut;
+	}
+
+	public abstract void setChatFormat(String chatFormat);
+
+	public String getChatFormat() {
+		return this.chatFormat.replace("{channel}", name);
+	}
+
+	public abstract void setDistinguishedChatFormat(String chatFormat);
+
+	public String getDistinguishedChatFormat() {
+		return this.distinguishedChatFormat.replace("{channel}", name);
+	}
+
+	public abstract void enableWhitelist();
+
+	public abstract void disableWhitelist();
+
+	public boolean whitelistEnabled() {
+		return this.isWhitelisted;
+	}
+
+	public void whitelistAdd(OfflinePlayer p) {
+		whitelistAdd(p.getUniqueId());
+	}
+
+	public void whitelistAdd(Player p) {
+		whitelistAdd(p.getUniqueId());
+	}
+
+	public void whitelistAdd(FPlayer p) {
+		whitelistAdd(p.getUniqueId());
+	}
+
+	public abstract void whitelistAdd(UUID uuid);
+
+	public void whitelistRemove(OfflinePlayer p) {
+		whitelistRemove(p.getUniqueId());
+	}
+
+	public void whitelistRemove(Player p) {
+		whitelistRemove(p.getUniqueId());
+	}
+
+	public void whitelistRemove(FPlayer p) {
+		whitelistRemove(p.getUniqueId());
+	}
+
+	public abstract void whitelistRemove(UUID uuid);
+
+	public abstract boolean isWhitelisted(FPlayer p);
+
+	public void log(String str) {
+		plugin.log(Level.INFO, str);
+	}
+
+	public abstract void enableRadius();
+
+	public abstract void disableRadius();
+
+	public abstract boolean hasRadius();
+
+	public abstract void setRadius(int radius);
+
+	public abstract int getRadius();
+
+	public boolean isBanned(FPlayer p) {
+		return banned.contains(p.getUniqueId());
+	}
+
+	public abstract void addBanned(FPlayer p);
+
+	public abstract ArrayList<FPlayer> getPlayers();
+
+	public abstract void removeBanned(FPlayer p);
+
+	public ArrayList<UUID> getBanned(){
+		return this.banned;
+	}
+	
+	public int playerCount() {
+		int count = 0;
+		for(FPlayer p : FPlayer.getPlayers()) {
+			if(p.getChannels().contains(name) || p.getTempChannels().contains(name)) {
+				count++;
+			}
+		}
+		return count;
+	}
+
+	public String format(FPlayer p, String msg) {
+		String finalMessage = "";
+		String slot3 = "", slot2 = "", slot1 = "";
+		String stf = "";
+		if (Permission.canUseColor(p)) {
+			msg = msg.replaceAll("&([0-9a-fk-or])", "§$1");
+		} else {
+			msg = msg.replaceAll("§[0-9a-fk-or]", "");
+		}
+		String header = PrepareChat.swapPlaceholders(p, this, msg);
+		if(Permission.isStaff(p)){
+			stf = FPChat.getPlugin().getMainConfig().getStaffBadge();
+		}
+		if(plugin.getMainConfig().mySQLEnabled()){
+			Integer[] badges = p.getBadges();
+			slot1 = BadgeList.badgelist.get(badges[0]);
+			slot2 = BadgeList.badgelist.get(badges[1]);
+			slot3 = BadgeList.badgelist.get(badges[2]);
+		}
+		String filler = "";
+		if(plugin.getMainConfig().chatFilterEnabled()){
+			filler = "word ";
+		}
+		if(Permission.canUseColor(p)){
+			String last = ChatFilter.filter(filler + msg);
+			last = BubbleCode.bubblecode(Permission.canBubbleCode(p), Codify.changeFormatSign(last));
+			finalMessage = stf + slot3 + slot2 + slot1 + header + last;
+		}else{
+			String newmsg = ChatColor.stripColor(ChatColor.translateAlternateColorCodes('§', ChatFilter.filter(filler + msg)));
+			finalMessage = stf + slot3 + slot2 + slot1 + Codify.removeBubbles(header + newmsg);
+		}
+		return finalMessage;
+	}
+
+	public abstract void sendMessage(String msg, FPlayer from);
+	
+	public void delete() {
+		ChatChannel.deleteChannel(name);
+	}
+
+}

src/main/java/com/fpghoti/fpchatx/chat/ChatFilter.java

@@ -0,0 +1,87 @@
+package com.fpghoti.fpchatx.chat;
+
+import java.util.ArrayList;
+
+import org.bukkit.ChatColor;
+
+import com.fpghoti.fpchatx.FPChat;
+
+public class ChatFilter {
+
+	public static ArrayList<String> filtered = null;
+
+	//CHAT FILTER
+
+	public static String filter(String sentence){  // THIS FUNCTION TAKES THE RAW CHAT MESSAGE AND SENDS EACH 
+		String msg = sentence;                     // INDIVIDUAL WORD INTO THE FILTER WORD FUNCTION BELOW
+		if(FPChat.getPlugin().getMainConfig().chatFilterEnabled()){
+			msg = "";
+			int i = 0;
+			for(String s : sentence.split(" ")){
+				if(i != 0){
+					msg = msg + filterWord(s) + " ";
+				}
+				i++;
+			}
+		}
+		return msg;
+	}
+
+	public static String filterWord(String word){             // THIS TAKES THE WORD, LOWERCASES IT,
+		String wordp = "";                                // AND REPLACES CHARACTERS "1" and "!" with "i", "5" with "s", "6" with "g", and
+		if(FPChat.getPlugin().getMainConfig().chatFilterEnabled()){    // "3" with "e". It then compares it to the list of
+			String word2 = word.toLowerCase();                // Naughty words and replaces it with "Frank" or "bleep" if a match is found
+			String color = ChatColor.getLastColors(word2);
+			if(word2.length() >= 2 && word2.charAt(word2.length() -1) == '!'){
+				for(int i = 0; i < word2.length() -1; i++ ){
+					wordp += word2.charAt(i);
+				}
+				word2 = wordp;
+			}
+			wordp = "";
+			for(int i = 0; i < word2.length(); i++ ){
+				if(word2.charAt(i) != '!'){
+					wordp += word2.charAt(i);
+				}else{
+					wordp += 'i';
+				}
+			}
+			word2 = wordp;
+			word2 = ChatColor.translateAlternateColorCodes('§', word2);
+			word2 = ChatColor.translateAlternateColorCodes('&', word2);
+			word2 = ChatColor.stripColor(word2);
+			word2 = word2.replaceAll("\\p{Punct}+", "").replaceAll("1", "i").replaceAll("5", "s").replaceAll("6", "g").replaceAll("3", "e");
+			if(filtered == null) {
+				filtered = new ArrayList<String>();
+				for(String s : FPChat.getPlugin().getMainConfig().getNaughtyWords().split(",")) {
+					filtered.add(s);
+				}
+			}
+
+			for(String item : filtered){
+				if(ChatColor.stripColor(word2).equalsIgnoreCase(item) || ChatColor.stripColor(word2).equalsIgnoreCase(item + "s")){
+					if (word2.length() > 2) {
+						if(word2.substring(word2.length() - 3).equalsIgnoreCase("ing")){
+							word = "bleeping";
+							if(FPChat.getPlugin().getMainConfig().frankModeEnabled()){
+								word = "Franking";
+							}
+						}else{
+							word = "bleep";
+							if(FPChat.getPlugin().getMainConfig().frankModeEnabled()){
+								word = "Frank";
+							}
+						}
+					}
+				}
+				word = color + word;
+			}
+			word2 = null;
+		}
+		return word;
+	}
+
+
+	// By the end of the loop, the sentence is reconstructed with the naughty words replaced
+
+}

src/main/java/com/fpghoti/fpchatx/chat/PrepareChat.java

@@ -0,0 +1,84 @@
+package com.fpghoti.fpchatx.chat;
+
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+
+import com.fpghoti.fpchatx.FPChat;
+import com.fpghoti.fpchatx.customcodes.BubbleCode;
+import com.fpghoti.fpchatx.customcodes.Codify;
+import com.fpghoti.fpchatx.permission.Permission;
+import com.fpghoti.fpchatx.player.FPlayer;
+import com.fpghoti.fpchatx.util.VaultUtil;
+
+public class PrepareChat {
+
+	public static String swapPlaceholders(FPlayer p, ChatChannel channel, String msg) {
+		return swapPlaceholders(p,channel,msg,"", false);
+	}
+
+	public static String swapPlaceholders(FPlayer p, String recipient, String msg, boolean in) {
+		return swapPlaceholders(p,null,msg,recipient,in);
+	}
+	
+	public static String swapPlaceholders(FPlayer p, String msg) {
+		return swapPlaceholders(p,null,msg,"",false);
+	}
+
+
+	private static String swapPlaceholders(FPlayer p, ChatChannel channel, String msg, String recipient, boolean in) {
+		if(!p.isOnline()) {
+			return "";
+		}
+		Player sender = Bukkit.getPlayer(p.getUniqueId());
+		String prefix = "";
+		String suffix = "";
+		String group = "";
+		String groupPrefix = "";
+		String groupSuffix = "";
+		World world = sender.getWorld();
+		prefix = VaultUtil.chat.getPlayerPrefix(sender);
+		prefix = BubbleCode.bubblecode(Permission.canBubbleCode(p), Codify.changeFormatSign(prefix)).replaceAll("&([0-9A-FK-OR])", "§$1").replace("&", "§");
+		suffix = VaultUtil.chat.getPlayerSuffix(sender);
+		suffix = BubbleCode.bubblecode(Permission.canBubbleCode(p), Codify.changeFormatSign(suffix)).replaceAll("&([0-9A-FK-OR])", "§$1").replace("&", "§");
+		group = VaultUtil.permission.getPrimaryGroup(sender);
+		groupPrefix = VaultUtil.chat.getGroupPrefix(world, group).replace("&", "§");
+		groupSuffix = VaultUtil.chat.getGroupSuffix(world, group).replace("&", "§");
+		String displayName = sender.getDisplayName();
+		displayName = BubbleCode.bubblecode(Permission.canBubbleCode(p), Codify.changeFormatSign(displayName)).replaceAll("&([0-9A-FK-OR])", "§$1").replace("&", "§");
+		String format = "";
+		if(channel != null) {
+			if(Permission.isDistinguished(p)) {
+				format = channel.getDistinguishedChatFormat();
+			}else {
+				format = channel.getChatFormat();
+			}
+		}else {
+			if(recipient.equals("")) {
+				format = FPChat.getPlugin().getMainConfig().getShoutFormat();
+			}else {
+				if(in) {
+					format = FPChat.getPlugin().getMainConfig().getInMsgFormat();
+				}else {
+					format = FPChat.getPlugin().getMainConfig().getOutMsgFormat();
+				}
+			}
+		}
+		format = format.replaceAll("&([0-9a-fk-or])", "§$1");
+		format = format.replace("{prefix}", prefix);
+		format = format.replace("{prefix}", prefix);
+		format = format.replace("{suffix}", suffix);
+		format = format.replace("{group}", group);
+		format = format.replace("{groupprefix}", groupPrefix);
+		format = format.replace("{groupSuffix}", groupSuffix);
+		if (channel != null) {
+			format = format.replace("{shortcut}", channel.getShortcut());
+			format = format.replace("{name}", channel.getName());
+		}
+		format = format.replace("{player}", displayName);
+		format = format.replace("{recipient}", recipient);
+		format = format.replace("{world}", world.getName());
+
+		return format;
+	}
+}

src/main/java/com/fpghoti/fpchatx/chat/ShoutChannel.java

@@ -0,0 +1,158 @@
+package com.fpghoti.fpchatx.chat;
+
+import java.util.ArrayList;
+import java.util.UUID;
+import java.util.logging.Level;
+
+import org.bukkit.ChatColor;
+
+import com.fpghoti.fpchatx.FPChat;
+import com.fpghoti.fpchatx.player.FPlayer;
+
+public class ShoutChannel extends ChatChannel{
+
+	/*
+	 * This is the shout channel
+	 * 
+	 * Shout is intended to act as a streamlined alternative
+	 * to setting up a StandardChannel with the radius disabled.
+	 * 
+	 * It also provides the ability to restrict global message sending
+	 * to a cooldown.
+	 * 
+	 * It also allows for a separate mute (hush) to be enforced.
+	 * 
+	 * Players can opt out of seeing shout.
+	 * 
+	 * Many functions here will do nothing. Shout extends ChatChannel
+	 * for the sake of treating shouts as a form of chat message.
+	*/
+	
+	public ShoutChannel(FPChat plugin) {
+		super(plugin);
+		this.name = "Shout";
+		this.shortcut = "Shout";
+		this.chatFormat = plugin.getMainConfig().getShoutFormat();
+		this.distinguishedChatFormat = plugin.getMainConfig().getDistinguishedShout();
+	}
+
+	@Override
+	public boolean isTemp() {
+		// Shout will always be a registered channel while the plugin is enabled.
+		return false;
+	}
+
+	@Override
+	public boolean isDefault() {
+		// Shout can only be spoken in by use of command, so cannot be default.
+		return false;
+	}
+
+	@Override
+	public void kick(FPlayer p) {
+		// No real reason to use this. It will hush the player if called.
+		// Leaving the shout channel is impossible. Standard channel should
+		// be used if the ability to leave is required.
+		
+		p.hush();
+	}
+
+	@Override
+	public void setShortcut(String shortcut) {
+		// Shout has a dedicated command, so a shortcut is not needed.
+	}
+
+	@Override
+	public void setChatFormat(String chatFormat) {
+		this.chatFormat = plugin.getMainConfig().getShoutFormat();
+	}
+
+	@Override
+	public void setDistinguishedChatFormat(String chatFormat) {
+		this.distinguishedChatFormat = plugin.getMainConfig().getDistinguishedShout();
+	}
+
+	@Override
+	public void enableWhitelist() {
+		return;
+	}
+
+	@Override
+	public void disableWhitelist() {
+		return;
+	}
+
+	@Override
+	public void whitelistAdd(UUID uuid) {
+		return;
+	}
+
+	@Override
+	public void whitelistRemove(UUID uuid) {
+		return;
+	}
+
+	@Override
+	public boolean isWhitelisted(FPlayer p) {
+		return false;
+	}
+
+	@Override
+	public void enableRadius() {
+		return;
+	}
+
+	@Override
+	public void disableRadius() {
+		return;
+	}
+
+	@Override
+	public boolean hasRadius() {
+		return false;
+	}
+
+	@Override
+	public void setRadius(int radius) {
+		return;
+	}
+
+	@Override
+	public int getRadius() {
+		return 0;
+	}
+	
+	@Override
+	public ArrayList<FPlayer> getPlayers(){
+		return FPlayer.getPlayers();
+	}
+
+	@Override
+	public void addBanned(FPlayer p) {
+		// No real reason to use this. It will hush the player if called.
+		// Leaving the shout channel is impossible. Standard channel should
+		// be used if the ability to leave is required.
+		
+		p.hush();
+	}
+
+	@Override
+	public void removeBanned(FPlayer p) {
+		// No real reason to use this. It will hush the player if called.
+		// Leaving the shout channel is impossible. Standard channel should
+		// be used if the ability to leave is required.
+		
+		p.unhush();
+	}
+
+	@Override
+	public void sendMessage(String msg, FPlayer from) {
+		plugin.log(Level.INFO, "Shout: " + msg);
+		for(FPlayer p : FPlayer.getPlayers()) {
+			if(p.isShoutVisible() && !p.isIgnoring(from)) {
+				p.sendMessage(ChatColor.translateAlternateColorCodes('&', "&8[&4&lS&r&8]&r") + msg);
+			}
+		}
+	}
+
+}

src/main/java/com/fpghoti/fpchatx/chat/StandardChannel.java

@@ -0,0 +1,358 @@
+package com.fpghoti.fpchatx.chat;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.UUID;
+import java.util.logging.Level;
+
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import com.fpghoti.fpchatx.FPChat;
+import com.fpghoti.fpchatx.config.ChannelFile;
+import com.fpghoti.fpchatx.player.FPlayer;
+import com.fpghoti.fpchatx.util.Util;
+
+public class StandardChannel extends ChatChannel{
+
+	private boolean hasRadius;
+	private int chatRadius;
+	private String permission;
+	private ChannelFile file;
+
+	public StandardChannel(FPChat plugin, ChannelFile file) {
+		super(plugin);
+		this.file = file;
+		setName(file.getName());
+		this.hasRadius = file.hasRadius();
+		this.permission = file.getWhitelistedPermissionNode();
+		this.banned = new ArrayList<UUID>();
+		if(!file.getBannedUUIDs().equals("")) {
+			for(String s : file.getBannedUUIDs().split(",")) {
+				UUID u = UUID.fromString(s);
+				banned.add(u);
+			}
+		}
+		this.whitelist = new ArrayList<UUID>();
+		if(!file.getWhitelistedUUIDs().equals("")) {
+			for(String s : file.getWhitelistedUUIDs().split(",")) {
+				UUID u = UUID.fromString(s);
+				whitelist.add(u);
+			}
+		}
+		this.shortcut = file.getShortcut();
+		this.distinguishedChatFormat = file.getDistinguishedChatFormat();
+		this.chatFormat = file.getChatFormat();
+		this.chatRadius = file.getRadius();
+		this.isWhitelisted = file.isWhitelisted();
+	}
+
+	@Override
+	public boolean isTemp() {
+		return false;
+	}
+
+	@Override
+	public void enableRadius() {
+		this.hasRadius = true;
+		new BukkitRunnable() {
+			@Override
+			public void run() {
+				try {
+					file.saveHasRadius(true);
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+		}.runTaskAsynchronously(plugin);
+	}
+
+	@Override
+	public void disableRadius() {
+		this.hasRadius = false;
+		new BukkitRunnable() {
+			@Override
+			public void run() {
+				try {
+					file.saveHasRadius(false);
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+		}.runTaskAsynchronously(plugin);
+	}
+
+	@Override
+	public boolean hasRadius() {
+		return this.hasRadius;
+	}
+
+	@Override
+	public void setRadius(int radius) {
+		this.chatRadius = radius;
+		new BukkitRunnable() {
+			@Override
+			public void run() {
+				try {
+					file.saveRadius(radius);
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+		}.runTaskAsynchronously(plugin);
+	}
+
+	@Override
+	public int getRadius() {
+		return this.chatRadius;
+	}
+
+	@Override
+	public boolean isWhitelisted(FPlayer p)  {
+		if(!whitelistEnabled()) {
+			return true;
+		}
+		if(isDefault()){
+			return true;
+		}
+		if(whitelist.contains(p.getUniqueId())) {
+			return true;
+		}
+		if(p.hasPermission(permission)) {
+			return true;
+		}
+		return false;		
+	}
+
+	public void setPermission(String perm) {
+		this.permission = perm;
+	}
+
+	public String getPermission() {
+		return this.permission;
+	}
+
+	@Override
+	public boolean isDefault()  {
+		return ChatChannel.getDefault() == this;
+	}
+
+	@Override
+	public void kick(FPlayer p) {
+		p.leaveChannel(getName());
+	}
+
+	@Override
+	public void setShortcut(String shortcut) {
+		this.shortcut = shortcut;
+		new BukkitRunnable() {
+			@Override
+			public void run() {
+				try {
+					file.saveShortcut(shortcut);
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+		}.runTaskAsynchronously(plugin);
+	}
+
+	@Override
+	public void enableWhitelist() {
+		this.isWhitelisted = true;
+		new BukkitRunnable() {
+			@Override
+			public void run() {
+				try {
+					file.saveWhitelist(true);
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+		}.runTaskAsynchronously(plugin);
+	}
+
+	@Override
+	public void disableWhitelist() {
+		this.isWhitelisted = false;
+		new BukkitRunnable() {
+			@Override
+			public void run() {
+				try {
+					file.saveWhitelist(false);
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+		}.runTaskAsynchronously(plugin);
+	}
+
+	@Override
+	public void whitelistAdd(UUID uuid) {
+		this.whitelist.add(uuid);
+
+		ArrayList<UUID> rl = this.whitelist;
+		new BukkitRunnable() {
+			@Override
+			public void run() {
+				try {
+					String setting = "";
+					for(UUID u : rl) {
+						String su = u.toString();
+						setting = setting + su + ",";
+					}
+					setting = StringUtils.chop(setting);
+					file.saveWhitelistedUUIDs(setting);
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+		}.runTaskAsynchronously(plugin);
+
+
+	}
+
+	@Override
+	public void whitelistRemove(UUID uuid) {
+		this.whitelist.remove(uuid);
+		ArrayList<UUID> rl = this.whitelist;
+		new BukkitRunnable() {
+			@Override
+			public void run() {
+				try {
+					String setting = "";
+					for(UUID u : rl) {
+						String su = u.toString();
+						setting = setting + su + ",";
+					}
+					setting = StringUtils.chop(setting);
+					file.saveWhitelistedUUIDs(setting);
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+		}.runTaskAsynchronously(plugin);
+	}
+
+	@Override
+	public void setChatFormat(String chatFormat) {
+		this.chatFormat = chatFormat;
+		new BukkitRunnable() {
+			@Override
+			public void run() {
+				try {
+					file.saveChatFormat(chatFormat);
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+		}.runTaskAsynchronously(plugin);
+	}
+
+	@Override
+	public ArrayList<FPlayer> getPlayers(){
+		ArrayList<FPlayer> players = new ArrayList<FPlayer>();
+		for(FPlayer p : FPlayer.getPlayers()) {
+			if(p.getChannels().contains(name)) {
+				players.add(p);
+			}
+		}
+		return players;
+	}
+
+	@Override
+	public void addBanned(FPlayer p) {
+		this.banned.add(p.getUniqueId());
+		ArrayList<UUID> rl = this.banned;
+		new BukkitRunnable() {
+			@Override
+			public void run() {
+				try {
+					String setting = "";
+					for(UUID u : rl) {
+						String su = u.toString();
+						setting = setting + su + ",";
+					}
+					setting = StringUtils.chop(setting);
+					file.saveBannedUUIDs(setting);
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+		}.runTaskAsynchronously(plugin);
+	}
+
+	@Override
+	public void removeBanned(FPlayer p) {
+		this.banned.remove(p.getUniqueId());
+		ArrayList<UUID> rl = this.banned;
+		new BukkitRunnable() {
+			@Override
+			public void run() {
+				try {
+					String setting = "";
+					for(UUID u : rl) {
+						String su = u.toString();
+						setting = setting + su + ",";
+					}
+					setting = StringUtils.chop(setting);
+					file.saveBannedUUIDs(setting);
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+		}.runTaskAsynchronously(plugin);
+	}
+
+	@Override
+	public void setDistinguishedChatFormat(String chatFormat) {
+		this.distinguishedChatFormat = chatFormat;
+		new BukkitRunnable() {
+			@Override
+			public void run() {
+				try {
+					file.saveDistinguishedChatFormat(chatFormat);
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+		}.runTaskAsynchronously(plugin);
+	}
+
+	@Override
+	public void sendMessage(String msg, FPlayer from) {
+		Player pf = Util.getEP(from.getName());
+		plugin.log(Level.INFO, name + ": " + msg);
+		for(FPlayer p : FPlayer.getPlayers()) {
+			if(p.getChannels().contains(name) && !p.isIgnoring(from)) {
+				if(hasRadius) {
+					Player pp = Util.getEP(p.getName());
+					if(pp.getWorld() == pf.getWorld()) {
+						if(pp.getLocation().distance(pf.getLocation()) < chatRadius){
+							p.sendMessage(msg);
+						}
+					}
+				}else {
+					p.sendMessage(msg);
+				}
+			}
+		}
+	}
+
+	public void update(ChannelFile file) {
+		this.file = file;
+		setName(file.getName());
+		this.hasRadius = file.hasRadius();
+		this.permission = file.getWhitelistedPermissionNode();
+		this.banned = new ArrayList<UUID>();
+		for(String s : file.getBannedUUIDs().split(",")) {
+			UUID u = UUID.fromString(s);
+			banned.add(u);
+		}
+		this.shortcut = file.getShortcut();
+	}
+
+}
+
+

src/main/java/com/fpghoti/fpchatx/chat/TempChannel.java

@@ -0,0 +1,157 @@
+package com.fpghoti.fpchatx.chat;
+
+import java.util.ArrayList;
+import java.util.UUID;
+import java.util.logging.Level;
+
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+
+import com.fpghoti.fpchatx.FPChat;
+import com.fpghoti.fpchatx.player.FPlayer;
+
+public class TempChannel extends ChatChannel{
+	
+	private UUID owner;
+	
+	public TempChannel(FPChat plugin, FPlayer owner, String name) {
+		super(plugin);
+		this.name = name;
+		this.owner = owner.getUniqueId();
+		this.chatFormat = plugin.getMainConfig().getTempChannelFormat();
+		this.distinguishedChatFormat = plugin.getMainConfig().getTempChannelFormat();
+		this.banned = new ArrayList<UUID>();
+	}
+	
+	public FPlayer getOwner() {
+		OfflinePlayer p = Bukkit.getOfflinePlayer(owner);
+		return FPlayer.getPlayer(p, !p.isOnline());
+	}
+	
+	public boolean isOwner(FPlayer p) {
+		return p.getUniqueId() == this.owner;
+	}
+
+	public void setOwner(FPlayer p) {
+		this.owner = p.getUniqueId();
+	}
+	
+	@Override
+	public boolean isTemp() {
+		return true;
+	}
+
+	@Override
+	public boolean isWhitelisted(FPlayer p) {
+		if(!whitelistEnabled()) {
+			return true;
+		}
+		if(whitelist.contains(p.getUniqueId())) {
+			return true;
+		}
+		return false;		
+	}
+
+	@Override
+	public void enableRadius() {
+		return;
+	}
+
+	@Override
+	public void disableRadius() {
+		return;
+	}
+
+	@Override
+	public boolean hasRadius() {
+		return false;
+	}
+
+	@Override
+	public void setRadius(int radius) {
+		return;
+	}
+
+	@Override
+	public int getRadius() {
+		return 0;
+	}
+
+	@Override
+	public boolean isDefault() {
+		return false;
+	}
+
+	@Override
+	public void kick(FPlayer p) {
+		p.leaveTempChannel(getName());
+	}
+
+	@Override
+	public void setShortcut(String shortcut) {
+		this.shortcut = shortcut;
+	}
+
+	@Override
+	public void enableWhitelist() {
+		this.isWhitelisted = true;
+	}
+	
+	@Override
+	public void disableWhitelist() {
+		this.isWhitelisted = false;
+	}
+
+	@Override
+	public void whitelistAdd(UUID uuid){
+		this.whitelist.add(uuid);
+	}
+
+	@Override
+	public void whitelistRemove(UUID uuid) {
+		this.whitelist.remove(uuid);
+	}
+	
+	@Override
+	public void addBanned(FPlayer p) {
+		this.banned.add(p.getUniqueId());
+	}
+
+
+	@Override
+	public void removeBanned(FPlayer p) {
+		this.banned.remove(p.getUniqueId());
+	}
+
+	@Override
+	public void setChatFormat(String chatFormat) {
+		this.chatFormat = chatFormat;
+	}
+
+	@Override
+	public void setDistinguishedChatFormat(String chatFormat) {
+		this.distinguishedChatFormat = chatFormat;
+	}
+	
+	@Override
+	public ArrayList<FPlayer> getPlayers(){
+		ArrayList<FPlayer> players = new ArrayList<FPlayer>();
+		for(FPlayer p : FPlayer.getPlayers()) {
+			if(p.getTempChannels().contains(name)) {
+				players.add(p);
+			}
+		}
+		return players;
+	}
+	
+	@Override
+	public void sendMessage(String msg, FPlayer from) {
+		plugin.log(Level.INFO, "[TC] " + name + ": " + msg);
+		for(FPlayer p : FPlayer.getPlayers()) {
+			if(p.getTempChannels().contains(name) && !p.isIgnoring(from)) {
+				p.sendMessage(msg);
+			}
+		}
+	}
+
+}