first commit

2b2t-core/src/main/java/org.cn2b2t.core/Main.java

@@ -0,0 +1,93 @@
+package org.cn2b2t.core;
+
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.event.Listener;
+import org.bukkit.plugin.PluginManager;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.cn2b2t.core.commands.Kar;
+import org.cn2b2t.core.listener.JoinListener;
+import org.cn2b2t.core.listener.TabCompleteListener;
+import org.cn2b2t.core.managers.users.UserValueManager;
+import org.cn2b2t.core.managers.utils.*;
+import org.cn2b2t.core.utils.ColorParser;
+
+import java.util.logging.Level;
+
+public class Main extends JavaPlugin {
+
+    public static Main instance;
+    public static PluginManager pluginManager;
+
+    @Override
+    public void onEnable() {
+        Main.instance = this;
+        pluginManager = Bukkit.getPluginManager();
+
+        log("&c&lGhost " + this.getName().substring(5) + " &7开始加载...");
+
+        log("&7├ &f加载配置文件管理器...");
+        ConfigManager.loadConfig();
+
+        log("&7├ &f链接数据库...");
+        DataManager.init();
+
+        log("&7├ &f启用Messager系统...");
+        MessagerManager.enable();
+        MessagerManager.registerChannel("chat");
+//
+        log("&7├ &f启用跨服管理器...");
+        ServersManager.init();
+
+        log("&7├ &f启用用户Value管理器....");
+        UserValueManager.init();
+
+        log("&7├ &f加载指令...");
+        regCMD("kar", new Kar());
+
+        log("&7├ &f加载监听器...");
+        regListener(new TabCompleteListener());
+        regListener(new JoinListener());
+
+        log("&7├ &f注册变量...");
+
+        log("&7├ &f注册Handlers...");
+
+        log("&7└ &a&l加载完成！");
+
+
+    }
+
+    @Override
+    public void onDisable() {
+        log("&c&LGhost &f" + this.getName().substring(5) + " &7开始卸载...");
+
+
+        log("&7├ &f卸载监听器...");
+        Bukkit.getServicesManager().unregisterAll(this);
+
+        log("&7├ &f移除Handlers...");
+
+        log("&7├ &f关闭线程...");
+        Main.getInstance().getServer().getScheduler().cancelTasks(Main.getInstance());
+
+        log("&7└ &a&l卸载完成！");
+    }
+
+    public static void regListener(Listener listener) {
+        pluginManager.registerEvents(listener, Main.getInstance());
+    }
+
+    public static void regCMD(String command, CommandExecutor commandExecutor) {
+        getInstance().getCommand(command).setExecutor(commandExecutor);
+    }
+
+    public static void log(String message) {
+        getInstance().getLogger().log(Level.INFO, ColorParser.parse(message));
+    }
+
+
+    public static JavaPlugin getInstance() {
+        return instance;
+    }
+}

2b2t-core/src/main/java/org.cn2b2t.core/commands/Core.java

@@ -0,0 +1,32 @@
+package org.cn2b2t.core.commands;
+
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.cn2b2t.core.managers.users.UserValueManager;
+import org.cn2b2t.core.managers.utils.MessagerManager;
+import org.cn2b2t.core.managers.utils.ServersManager;
+import org.cn2b2t.core.utils.ColorParser;
+
+import java.util.Arrays;
+import java.util.stream.Collectors;
+
+public class Core implements CommandExecutor {
+
+    @Override
+    public boolean onCommand(final CommandSender sender, final Command cmd, final String label, final String[] args) {
+        if (sender instanceof Player) {
+            sender.sendMessage(ColorParser.parse("&7本服由 &f&lKa&7&lr &8Network &7提供技术支持。"));
+            sender.sendMessage(ColorParser.parse("&7官方网站 &chttps://www.kar.red/"));
+            return true;
+        }
+        String aim = args[0].toLowerCase();
+        switch (aim) {
+        }
+
+
+        return true;
+    }
+}

2b2t-core/src/main/java/org.cn2b2t.core/commands/Kar.java

@@ -0,0 +1,37 @@
+package org.cn2b2t.core.commands;
+
+import org.cn2b2t.core.managers.utils.ServersManager;
+import org.cn2b2t.core.managers.utils.UserManager;
+import org.cn2b2t.core.utils.ColorParser;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class Kar implements CommandExecutor {
+
+    @Override
+    public boolean onCommand(final CommandSender sender, final Command cmd, final String label, final String[] args) {
+        if (sender instanceof Player) {
+            if (args.length == 0) {
+                sender.sendMessage(ColorParser.parse("&7本服由 &f&lKa&7&lr &8Network &7提供技术支持。"));
+                sender.sendMessage(ColorParser.parse("&7您可以输入 &c/kar go &7直接传送到Kar服务器。"));
+                sender.sendMessage(ColorParser.parse("&7官方网站 &chttps://www.kar.red/"));
+            } else {
+                if (args.length == 1) {
+                    if (args[0].equalsIgnoreCase("debugsb")) {
+                        UserManager.getUser(sender).getSbRender().setLine(1, "init");
+                        return true;
+                    }
+                }
+                ServersManager.switchServer((Player) sender, "cn.kar.red");
+            }
+        } else {
+            sender.sendMessage(ColorParser.parse("&7本服由 &f&lKa&7&lr &8Network &7提供技术支持。"));
+            sender.sendMessage(ColorParser.parse("&7官方网站 &chttps://www.kar.red/"));
+        }
+
+        return true;
+    }
+
+}

2b2t-core/src/main/java/org.cn2b2t.core/commands/ServerTeleport.java

@@ -0,0 +1,23 @@
+package org.cn2b2t.core.commands;
+
+
+import org.cn2b2t.core.managers.utils.ServersManager;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class ServerTeleport implements CommandExecutor {
+
+	@Override
+	public boolean onCommand(CommandSender sender, org.bukkit.command.Command cmd, String label, String[] args) {
+		if (sender instanceof Player) {
+			if (args.length == 1) {
+				ServersManager.teleport((Player) sender, args[0]);
+				return true;
+			}
+		}
+		return true;
+	}
+
+
+}

2b2t-core/src/main/java/org.cn2b2t.core/events/MessageReceiveEvent.java

@@ -0,0 +1,82 @@
+package org.cn2b2t.core.events;
+
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+public class MessageReceiveEvent extends Event {
+
+	private static final HandlerList handlers = new HandlerList();
+
+	String channel;
+	long sendTime;
+
+	String fromServer;
+	String fromPlugin;
+
+	String key;
+	String[] values;
+
+
+	public MessageReceiveEvent(String channel, long sendTime, String fromServer, String fromPlugin, String key, String[] values) {
+		this.channel = channel;
+		this.sendTime = sendTime;
+		this.fromPlugin = fromPlugin;
+		this.fromServer = fromServer;
+		this.key = key;
+		this.values = values;
+	}
+
+	public static HandlerList getHandlerList() {
+		return handlers;
+	}
+
+	public boolean isTimeOut() {
+		return System.currentTimeMillis() - sendTime > 5000;
+	}
+
+	public String getChannel() {
+		return channel;
+	}
+
+	public String getKey() {
+		return key;
+	}
+
+	public String[] getValues() {
+		return values;
+	}
+
+	@Override
+	public String getEventName() {
+		return super.getEventName();
+	}
+
+	@Override
+	public String toString() {
+		return "MessageReceiveEvent{" +
+				"channel='" + channel + '\'' +
+				", sendTime=" + sendTime +
+				", fromServer=" + fromServer +
+				", fromPlugin='" + fromPlugin + '\'' +
+				", key='" + key + '\'' +
+				", value='" + values + '\'' +
+				'}';
+	}
+
+	public String getSendPlugin() {
+		return fromPlugin;
+	}
+
+	public long getSendTime() {
+		return sendTime;
+	}
+
+	public String getSendServer() {
+		return fromServer;
+	}
+
+	@Override
+	public HandlerList getHandlers() {
+		return handlers;
+	}
+}

2b2t-core/src/main/java/org.cn2b2t.core/events/UserHandlerLoadedEvent.java

@@ -0,0 +1,36 @@
+package org.cn2b2t.core.events;
+
+import org.cn2b2t.core.modules.users.AbstractUserHandler;
+import org.cn2b2t.core.modules.users.User;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+public class UserHandlerLoadedEvent extends Event {
+
+	private static final HandlerList handlers = new HandlerList();
+
+	private User user;
+	private AbstractUserHandler handler;
+
+	public UserHandlerLoadedEvent(AbstractUserHandler handler) {
+		this.user = handler.getUser();
+		this.handler = handler;
+	}
+	
+	public AbstractUserHandler getHandler() {
+		return handler;
+	}
+
+	public User getUser() {
+		return user;
+	}
+
+	@Override
+	public HandlerList getHandlers() {
+		return handlers;
+	}
+
+	public static HandlerList getHandlerList() {
+		return handlers;
+	}
+}

2b2t-core/src/main/java/org.cn2b2t.core/events/UserLoadedEvent.java

@@ -0,0 +1,41 @@
+package org.cn2b2t.core.events;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+import org.cn2b2t.core.modules.users.User;
+
+/**
+ * @author LSeng
+ */
+public class UserLoadedEvent extends Event {
+
+    private static final HandlerList handlers = new HandlerList();
+
+    private User user;
+
+    private UserLoadedEvent() {
+    }
+
+    public UserLoadedEvent(User u) {
+        user = u;
+    }
+
+    public User getUser() {
+        return this.user;
+    }
+
+    public Player getPlayer() {
+        return this.user.getPlayer();
+    }
+
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+}

2b2t-core/src/main/java/org.cn2b2t.core/listener/JoinListener.java

@@ -0,0 +1,29 @@
+package org.cn2b2t.core.listener;
+
+import org.cn2b2t.core.managers.users.UserValueManager;
+import org.cn2b2t.core.managers.utils.UserManager;
+import org.cn2b2t.core.modules.users.User;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+
+public class JoinListener implements Listener {
+
+
+
+	@EventHandler(priority = EventPriority.LOWEST)
+	public void loadUser(PlayerJoinEvent e) {
+		User u = UserManager.registeruser(e.getPlayer());
+	}
+
+	@EventHandler(priority = EventPriority.MONITOR)
+	public void unloadUser(PlayerQuitEvent e) {
+		UserManager.unregisterUser(e.getPlayer());
+	}
+
+}

2b2t-core/src/main/java/org.cn2b2t.core/listener/MessageListener.java

@@ -0,0 +1,69 @@
+package org.cn2b2t.core.listener;
+
+import com.google.common.io.ByteArrayDataInput;
+import com.google.common.io.ByteStreams;
+import org.cn2b2t.core.Main;
+import org.cn2b2t.core.managers.utils.MessagerManager;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.messaging.PluginMessageListener;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import java.io.ByteArrayInputStream;
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Base64;
+import java.util.logging.Level;
+
+public class MessageListener implements PluginMessageListener {
+
+
+	@Override
+	public void onPluginMessageReceived(String tag, Player player, byte[] data) {
+		if (!tag.equals("BungeeCord")) return;
+
+		ByteArrayDataInput in = ByteStreams.newDataInput(data);
+		String channel = in.readUTF();
+		if (!MessagerManager.hasChannel(channel)) {
+			return;
+		}
+		short len = in.readShort();
+		byte[] msgbytes = new byte[len];
+		in.readFully(msgbytes);
+
+		DataInputStream msgin = new DataInputStream(new ByteArrayInputStream(msgbytes));
+		try {
+			long time = msgin.readLong();
+			if (System.currentTimeMillis() - time > MessagerManager.timeOutTime) {
+				Main.getInstance().getLogger().log(Level.WARNING, "从BC接收到一条消息，但已经超时。");
+				return;
+			}
+
+			String server = msgin.readUTF();
+			String pluginName = msgin.readUTF();
+			boolean encoded = msgin.readInt() == 1;
+			String key = msgin.readUTF();
+			String value = msgin.readUTF();
+			if (encoded) {
+				new BukkitRunnable() {
+					@Override
+					public void run() {
+						String[] messages = value.split(":");
+						if (messages.length < 1) {
+							Main.getInstance().getLogger().log(Level.WARNING, "错误！ 受到的value = null");
+							return;
+						}
+
+						String[] values = (String[]) Arrays.stream(messages).map(message -> new String(Base64.getDecoder().decode(message))).toArray();
+						MessagerManager.callEvent(channel, time, server, pluginName, key, values);
+					}
+				}.runTaskAsynchronously(Main.getInstance());
+			} else {
+				MessagerManager.callEvent(channel, time, server, pluginName, key, new String[]{value});
+			}
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+
+}

2b2t-core/src/main/java/org.cn2b2t.core/listener/TabCompleteListener.java

@@ -0,0 +1,87 @@
+package org.cn2b2t.core.listener;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.ProtocolLibrary;
+import com.comphenix.protocol.ProtocolManager;
+import com.comphenix.protocol.events.ListenerPriority;
+import com.comphenix.protocol.events.PacketAdapter;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.events.PacketEvent;
+import com.comphenix.protocol.reflect.FieldAccessException;
+import org.cn2b2t.core.Main;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerCommandPreprocessEvent;
+
+public final class TabCompleteListener implements Listener {
+
+	private final ProtocolManager pm;
+
+	public TabCompleteListener() {
+		this.pm = ProtocolLibrary.getProtocolManager();
+		setupPackets();
+	}
+
+	private void setupPackets() {
+		this.pm.addPacketListener(new PacketAdapter(Main.getInstance(), ListenerPriority.NORMAL, PacketType.Play.Client.TAB_COMPLETE) {
+			@Override
+			public void onPacketReceiving(PacketEvent event) {
+				if (!event.getPlayer().isOp()) {
+					if (event.getPacketType() == PacketType.Play.Client.TAB_COMPLETE) {
+						try {
+
+							PacketContainer packet = event.getPacket();
+
+							String message = packet.getSpecificModifier(String.class).read(0).toLowerCase();
+							if (message.equalsIgnoreCase("/")
+									|| shouldCancel(message, "//")
+									|| shouldCancel(message, "/cmi")
+									|| shouldCancel(message, "/mcpay")
+									|| shouldCancel(message, "/help")
+									|| shouldCancel(message, "/bukkit:")
+									|| shouldCancel(message, "/minecraft:")) {
+								event.setCancelled(true);
+							}
+						} catch (FieldAccessException ignored) {
+						}
+					}
+				}
+			}
+		});
+	}
+
+
+	@EventHandler
+	public void onAtTab(PlayerCommandPreprocessEvent e) {
+		if (!e.getPlayer().isOp()) {
+			String message = e.getMessage();
+			if (message.equalsIgnoreCase("/")
+					|| shouldCancel(message, "//")
+					|| message.startsWith("/minecraft:")
+					|| message.startsWith("/bukkit:")
+					|| message.startsWith("/help")) {
+				e.setCancelled(true);
+			}
+		}
+	}
+
+	public static boolean shouldCancel(String message, String command) {
+		return message.startsWith(command) || command.startsWith(message);
+	}
+
+//	@EventHandler
+//	public void onAtTab(PlayerChatTabCompleteEvent e) {
+//		if (Bukkit.getOnlinePlayers().size() < 1 || ServersManager.allPlayers.size() < 1) return;
+//		String s = e.getChatMessage().substring(e.getChatMessage().lastIndexOf('@') + 1);
+//		Bukkit.getOnlinePlayers().stream().filter(all -> all.getName().toLowerCase().startsWith(s.toLowerCase())).forEachOrdered(all -> e.getTabCompletions().add("@" + all.getName()));
+//	}
+//
+//	@EventHandler
+//	public void onNameTab(TabCompleteEvent e) {
+//		if (Bukkit.getOnlinePlayers().size() < 1 || ServersManager.allPlayers.size() < 1) return;
+//		String toComplete = e.getBuffer();
+//		e.setCompletions(ServersManager.allPlayers.stream().filter(s -> StringUtil.startsWithIgnoreCase(s, toComplete)).collect(Collectors.toList()));
+//	}
+
+
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/render/BelowName.java

@@ -0,0 +1,38 @@
+package org.cn2b2t.core.managers.render;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.scoreboard.DisplaySlot;
+import org.bukkit.scoreboard.Objective;
+import org.bukkit.scoreboard.Scoreboard;
+
+public class BelowName {
+
+	public static void set(Player viewer, Player target, int score, String displayName){
+		Scoreboard sb = viewer.getScoreboard();
+		if(Bukkit.getScoreboardManager().getMainScoreboard() == sb || sb == null){
+			sb = Bukkit.getScoreboardManager().getNewScoreboard();
+			viewer.setScoreboard(sb);
+		}
+		Objective obj = sb.getObjective(DisplaySlot.BELOW_NAME);
+		if(obj == null){
+			obj = sb.registerNewObjective("KSBR_BN", "dummy");
+			obj.setDisplaySlot(DisplaySlot.BELOW_NAME);
+		}
+		obj.setDisplayName(displayName);
+		obj.getScore(target).setScore(score);
+	}
+	
+	public static void reset(Player viewer){
+		Scoreboard sb = viewer.getScoreboard();
+		if(sb == null){
+			sb = Bukkit.getScoreboardManager().getNewScoreboard();
+			viewer.setScoreboard(sb);
+		}
+		Objective obj = sb.getObjective("KSBR_BN");
+		if(obj != null){
+			obj.unregister();
+		}
+	}
+	
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/render/NamePrefix.java

@@ -0,0 +1,60 @@
+package org.cn2b2t.core.managers.render;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.scoreboard.NameTagVisibility;
+import org.bukkit.scoreboard.Scoreboard;
+import org.bukkit.scoreboard.Team;
+
+public class NamePrefix {
+
+	public static void set(Player viewer, Player target, String str){
+		set(viewer,target,str, PSType.PREFIX);
+	}
+	
+	public static void set(Player viewer, Player target, String str, PSType type){
+		Scoreboard sb = viewer.getScoreboard();
+		if(Bukkit.getScoreboardManager().getMainScoreboard() == sb || sb == null){
+			sb = Bukkit.getScoreboardManager().getNewScoreboard();
+			viewer.setScoreboard(sb);
+		}
+		Team t = sb.getTeam("NP_"+target.getName().substring(0, Math.min(13, target.getName().length())));
+		if(t==null){
+			t = sb.registerNewTeam("NP_"+target.getName().substring(0, Math.min(13, target.getName().length())));
+			t.setNameTagVisibility(NameTagVisibility.ALWAYS);
+		}
+		if(str.length()>16){
+			str = str.substring(0, 16);
+		}
+		switch (type) {
+			case PREFIX:
+				t.setPrefix(str);
+				break;
+			case SUFFIX:
+				t.setSuffix(str);
+				break;
+			default:
+				throw new AssertionError(type.name());
+		}
+		if(!t.hasEntry(target.getName())) t.addEntry(target.getName());
+	}
+	
+	public static void reset(Player viewer, Player target){
+		Scoreboard sb = viewer.getScoreboard();
+		if(Bukkit.getScoreboardManager().getMainScoreboard() == sb || sb == null){
+			sb = Bukkit.getScoreboardManager().getNewScoreboard();
+			viewer.setScoreboard(sb);
+			return;
+		}
+		Team t = sb.getTeam("NP_"+target.getUniqueId().toString().substring(0, 13));
+		if(t!=null){
+			t.unregister();
+		}
+	}
+	
+	public enum PSType{
+		PREFIX,
+		SUFFIX;
+	}
+	
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/render/PlayerList.java

@@ -0,0 +1,59 @@
+package org.cn2b2t.core.managers.render;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.scoreboard.DisplaySlot;
+import org.bukkit.scoreboard.Objective;
+import org.bukkit.scoreboard.Scoreboard;
+
+public class PlayerList {
+
+	public static boolean isActive(Player viewer){
+		Scoreboard sb = viewer.getScoreboard();
+		if(Bukkit.getScoreboardManager().getMainScoreboard() == sb || sb == null){
+			sb = Bukkit.getScoreboardManager().getNewScoreboard();
+			viewer.setScoreboard(sb);
+		}
+		Objective obj = sb.getObjective("KSBR_PL");
+		return obj != null;
+	}
+	
+	public static void health(Player viewer){
+		Scoreboard sb = viewer.getScoreboard();
+		if(Bukkit.getScoreboardManager().getMainScoreboard() == sb || sb == null){
+			sb = Bukkit.getScoreboardManager().getNewScoreboard();
+			viewer.setScoreboard(sb);
+		}
+		Objective obj = sb.getObjective(DisplaySlot.PLAYER_LIST);
+		if(obj == null){
+			obj = sb.registerNewObjective("KSBR_PL", "health");
+			obj.setDisplaySlot(DisplaySlot.PLAYER_LIST);
+		}
+	}
+	
+	public static void set(Player viewer, Player target, int score){
+		Scoreboard sb = viewer.getScoreboard();
+		if(Bukkit.getScoreboardManager().getMainScoreboard() == sb || sb == null){
+			sb = Bukkit.getScoreboardManager().getNewScoreboard();
+			viewer.setScoreboard(sb);
+		}
+		Objective obj = sb.getObjective(DisplaySlot.PLAYER_LIST);
+		if(obj == null){
+			obj = sb.registerNewObjective("KSBR_PL", "dummy");
+			obj.setDisplaySlot(DisplaySlot.PLAYER_LIST);
+		}
+		obj.getScore(target).setScore(score);
+	}
+	
+	public static void reset(Player viewer){
+		Scoreboard sb = viewer.getScoreboard();
+		if(sb == null){
+			sb = Bukkit.getScoreboardManager().getNewScoreboard();
+			viewer.setScoreboard(sb);
+		}
+		Objective obj = sb.getObjective("KSBR_PL");
+		if(obj != null){
+			obj.unregister();
+		}
+	}
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/team/Team.java

@@ -0,0 +1,208 @@
+package org.cn2b2t.core.managers.team;
+
+import org.cn2b2t.core.managers.render.NamePrefix;
+import org.cn2b2t.core.modules.users.User;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+
+import java.util.*;
+
+public class Team {
+
+    private final List<User> teammates = new ArrayList<>();
+    private String name;
+    private Map<String, Object> handlers = new HashMap<>();
+    private boolean friendlyHurt;
+
+    private ChatColor color;
+
+    private Team() {
+    }
+
+    public Team(String name) {
+        this.name = name;
+        TeamManager.regTeam(this);
+    }
+
+    public ChatColor getColor() {
+        return color;
+    }
+
+    public void setColor(ChatColor color) {
+        switch (color) {
+            case BOLD:
+            case MAGIC:
+            case ITALIC:
+            case UNDERLINE:
+            case RESET:
+            case STRIKETHROUGH:
+                throw new IllegalArgumentException(color.name());
+        }
+        this.color = color;
+        updateColor();
+    }
+
+    public void updateColor() {
+        for (Team team1 : TeamManager.getTeams()) {
+            for (Team team2 : TeamManager.getTeams()) {
+                if (team1 != team2) {//看到别的队伍
+                    for (User u1 : team1.getTeammates()) {
+                        for (User u2 : team2.getTeammates()) {
+                            if (team2.getColor() == null) {
+                                NamePrefix.set(u1.getPlayer(), u2.getPlayer(), "§c");
+                            } else {
+                                NamePrefix.set(u1.getPlayer(), u2.getPlayer(), team2.getColor().toString());
+                            }
+                            if (team1.getColor() == null) {
+                                NamePrefix.set(u2.getPlayer(), u1.getPlayer(), "§c");
+                            } else {
+                                NamePrefix.set(u2.getPlayer(), u1.getPlayer(), team1.getColor().toString());
+                            }
+                        }
+                    }
+                } else {//看到自己队伍
+                    for (User u1 : team1.getTeammates()) {
+                        for (User u2 : team1.getTeammates()) {
+                            if (team1.getColor() == null) {
+                                NamePrefix.set(u1.getPlayer(), u2.getPlayer(), "§a");
+                                NamePrefix.set(u2.getPlayer(), u1.getPlayer(), "§a");
+                            } else {
+                                NamePrefix.set(u1.getPlayer(), u2.getPlayer(), team1.getColor().toString());
+                                NamePrefix.set(u2.getPlayer(), u1.getPlayer(), team1.getColor().toString());
+                            }
+                        }
+                    }
+                }
+            }
+        }
+//		for(User viewer : this.teammates){
+//			for(User target : this.teammates){//自己队友看自己队伍
+//				if(color == null)
+//					NamePrefix.set(viewer.getPlayer(), target.getPlayer(), "§a");
+//				else
+//					NamePrefix.set(viewer.getPlayer(), target.getPlayer(), color.toString());
+//			}
+//			for (Team ot : TeamManager.getTeams()) {
+//				if (ot == this) {
+//					continue;
+//				}
+//				for (User target : ot.getTeammates()) {
+//					//自己队伍看到别的队伍
+//					if(ot.color == null)
+//						NamePrefix.set(viewer.getPlayer(), target.getPlayer(), "§c");
+//					else
+//						NamePrefix.set(viewer.getPlayer(), target.getPlayer(), color.toString());
+//					//别的队伍看到自己队伍
+//					if(color == null)
+//						NamePrefix.set(target.getPlayer(), viewer.getPlayer(), "§c");
+//					else
+//						NamePrefix.set(target.getPlayer(), viewer.getPlayer(), color.toString());
+//				}
+//			}
+//		}
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    public List<User> getTeammates() {
+        return new ArrayList<>(this.teammates);
+    }
+
+    public boolean isEmpty() {
+        return this.teammates.isEmpty();
+    }
+
+    public void join(User teammate) {
+        if (unreg) {
+            throw new NullPointerException("Team " + this.name + " has been unregistered. It can't hold person anymore.");
+        }
+        if (teammate == null) {
+            throw new NullPointerException("Teammate cannot be null.");
+        }
+        Team tt = TeamManager.getTeam(teammate);
+        if (tt != null) {
+            if (tt == this) {
+                return;
+            } else {
+                tt.quit(teammate);
+                join(teammate);
+//				throw new RuntimeException("User " + teammate.getRealName() + "(#" + teammate.getInkID() + ") 加入Team " + this.name + " 前, 他已在Team " + tt.getName() + "中.(已退出后者)");
+                Bukkit.getLogger().severe("User " + teammate.getPlayer().getName() + "(#" + teammate.getPlayer().getUniqueId() + ") 加入Team " + this.name + " 前, 他已在Team " + tt.getName() + "中.(已退出后者)");
+            }
+        }
+
+        this.teammates.add(teammate);
+
+        updateColor();
+    }
+
+    public void quit(User teammate) {
+        for (Team ot : TeamManager.getTeams()) {
+            for (User target : ot.getTeammates()) {
+                NamePrefix.reset(teammate.getPlayer(), target.getPlayer());
+                NamePrefix.reset(target.getPlayer(), teammate.getPlayer());
+            }
+        }
+        this.teammates.remove(teammate);
+    }
+
+    public boolean containsTeammate(User user) {
+        return this.teammates.contains(user);
+    }
+
+    public void registerHandler(String name, Object handler) {
+        if (this.handlers.containsKey(name)) {
+            throw new RuntimeException("Handler " + name + " in Team " + this.name + " is exist.");
+        }
+        this.handlers.put(name, handler);
+    }
+
+    public void removehandler(String name) {
+        if (!this.handlers.containsKey(name)) {
+            throw new RuntimeException("Handler " + name + " in Team " + this.name + " wasn't exist.");
+        }
+        this.handlers.remove(name);
+    }
+
+    public void replaceHandler(String name, Object handler) {
+        if (!this.handlers.containsKey(name)) {
+            throw new RuntimeException("Handler " + name + " in Team " + this.name + " wasn't exist.");
+        }
+        this.handlers.replace(name, handler);
+    }
+
+    public boolean containsHandler(String name) {
+        return this.handlers.containsKey(name);
+    }
+
+    public Object getHandler(String name) {
+        return handlers.get(name);
+    }
+
+    public boolean friendlyHurt() {
+        return this.friendlyHurt;
+    }
+
+    public void setFriendlyHurt(boolean b) {
+        this.friendlyHurt = b;
+    }
+
+    private boolean unreg;
+
+    public void unregistered() {
+        if (unreg) {
+            throw new NullPointerException("Team " + this.name + " has been unregistered.");
+        }
+        unreg = true;
+        for (User tm : new HashSet<>(this.teammates)) {
+//			for(Player target : Bukkit.getOnlinePlayers()) {
+//				NamePrefix.reset(tm.getPlayer(), target);
+//			}
+            quit(tm);
+        }
+        TeamManager.unregTeam(this);
+    }
+
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/team/TeamListener.java

@@ -0,0 +1,26 @@
+package org.cn2b2t.core.managers.team;
+
+import org.cn2b2t.core.managers.utils.UserManager;
+import org.cn2b2t.core.modules.users.User;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+
+public class TeamListener implements Listener {
+
+    @EventHandler
+    public void onHurt(EntityDamageByEntityEvent e) {
+        if (e.getEntity() instanceof Player && e.getDamager() instanceof Player) {
+            User en = UserManager.getUser(((Player) e.getEntity()));
+            Team t = TeamManager.getTeam(en);
+            if (t != null && !t.friendlyHurt()) {
+                User d = UserManager.getUser(((Player) e.getDamager()));
+                if (t.containsTeammate(d)) {
+                    e.setCancelled(true);
+                }
+            }
+        }
+    }
+
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/team/TeamManager.java

@@ -0,0 +1,84 @@
+package org.cn2b2t.core.managers.team;
+
+
+import org.cn2b2t.core.modules.users.User;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class TeamManager {
+
+    private static final List<Team> teams = new ArrayList<>();
+
+    protected static void regTeam(Team t) {
+        teams.add(t);
+    }
+
+    protected static void unregTeam(Team t) {
+        teams.remove(t);
+    }
+
+    /**
+     * 解散所有Team
+     */
+    public static void unregAll() {
+        for (Team t : teams) {
+            t.unregistered();
+        }
+    }
+
+    /**
+     * 根据Team名获取Team，注意大小写
+     *
+     * @param name
+     * @return 若没有找到Team，返回null
+     */
+    public static Team getTeam(String name) {
+        for (Team t : teams) {
+            if (t.getName().equals(name)) {
+                return t;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * 根据Team名获取Team，忽略大小写
+     *
+     * @param name
+     * @return 若没有找到Team，返回null
+     */
+    public static Team getTeamIgnoreLetterCase(String name) {
+        for (Team t : teams) {
+            if (t.getName().equalsIgnoreCase(name)) {
+                return t;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * 得到User所在的Team
+     *
+     * @param u
+     * @return User所在的Team，若User不在Team里，则返回null
+     */
+    public static Team getTeam(User u) {
+        for (Team t : teams) {
+            if (t.containsTeammate(u)) {
+                return t;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * 得到所有Team的Set拷贝
+     *
+     * @return
+     */
+    public static List<Team> getTeams() {
+        return new ArrayList<>(teams);
+    }
+
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/users/UserValueManager.java

@@ -0,0 +1,105 @@
+package org.cn2b2t.core.managers.users;
+
+import org.bukkit.entity.Player;
+import org.cn2b2t.core.managers.utils.DataManager;
+import org.cn2b2t.core.managers.utils.database.Connection;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+
+public class UserValueManager {
+
+    public static void init() {
+        DataManager.getConnection().SQLqueryWithNoResult(
+                "CREATE TABLE IF NOT EXISTS `uservalues` (`id` INT(11) NOT NULL AUTO_INCREMENT , `uuid` varchar(64), `key` varchar(256), `value` varchar(256), PRIMARY KEY (`id`), UNIQUE KEY(`id`)) ENGINE=InnoDB DEFAULT CHARSET=utf8");
+    }
+
+
+    public static Map<String, String> getDataValues(UUID uuid) {
+        Map<String, String> values = new HashMap<>();
+        ResultSet query = getConnection().SQLquery("select * from `uservalues` where `uuid` = '" + uuid.toString() + "'");
+        try {
+            if (query != null) {
+                while (query.next()) {
+                    String key = query.getString("key");
+                    String value = query.getString("value");
+                    values.put(key, value);
+
+                }
+                query.close();
+                return values;
+            }
+        } catch (SQLException e) {
+            getConnection().info(e.getLocalizedMessage());
+        }
+        return values;
+    }
+
+    public static String getDataValuesByKey(UUID uuid, String key) {
+        //`uservalues` WHERE `uuid` = 1 AND `key` = 'afk'
+        ResultSet query = getConnection().SQLquery("select * from `uservalues` where `uuid` = '" + uuid.toString() + "' AND `key`='" + key + "'");
+        try {
+            if (query != null) {
+                String value = null;
+                if (query.next()) {
+                    value = query.getString("value");
+//					Bukkit.getConsoleSender().sendMessage(Main.color("§f#'" + uuid.toString() + "' &7key &c" + key + " &7value&c" + value));
+                }
+                query.close();
+                return value;
+            }
+        } catch (SQLException e) {
+            getConnection().info(e.getLocalizedMessage());
+        }
+        return null;
+    }
+
+
+    public static void addDataValue(UUID uuid, String key, String values) {
+        getConnection().SQLqueryWithNoResult("INSERT INTO `uservalues` " +
+                "(`uuid`,`key`,`value`) " +
+                "VALUES " +
+                "('" + uuid.toString() + "','" + key + "','" + values + "');");
+    }
+
+    public static void removeDataValueByKey(UUID uuid, String key) {
+        getConnection().SQLqueryWithNoResult("delete from `uservalues` where `uuid`='" + uuid.toString() + "' and `key`='" + key + "';");
+    }
+
+    public static void removeDataValue(UUID uuid, String value) {
+        getConnection().SQLqueryWithNoResult("delete from `uservalues` where `uuid`='" + uuid.toString() + "' and `value`=`" + value + "`;");
+    }
+
+    public static void setDataValues(UUID uuid, HashMap<String, String> values) {
+        getConnection().SQLqueryWithNoResult("delete from `uservalues` where `uuid`='" + uuid.toString() + "';");
+        values.keySet().forEach(key -> addDataValue(uuid, key, values.get(key)));
+    }
+
+    public static Map<String, String> getDataValues(Player player) {
+        return getDataValues(player.getUniqueId());
+    }
+
+    public static void addDataValue(Player player, String key, String values) {
+        addDataValue(player.getUniqueId(), key, values);
+    }
+
+    public static void removeDataValueByKey(Player player, String key) {
+        removeDataValueByKey(player.getUniqueId(), key);
+    }
+
+    public static void removeDataValue(Player player, String value) {
+        removeDataValue(player.getUniqueId(), value);
+    }
+
+    public static void setDataValues(Player player, HashMap<String, String> values) {
+        setDataValues(player.getUniqueId(), values);
+    }
+
+    public static Connection getConnection() {
+        return DataManager.getConnection();
+    }
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/utils/ConfigManager.java

@@ -0,0 +1,21 @@
+package org.cn2b2t.core.managers.utils;
+
+import org.cn2b2t.core.Main;
+import org.bukkit.configuration.Configuration;
+
+public class ConfigManager {
+
+    public static Configuration config;
+
+
+    public static void loadConfig() {
+        Main.getInstance().saveDefaultConfig();
+        Main.getInstance().saveConfig();
+        Main.getInstance().reloadConfig();
+
+
+        config = Main.getInstance().getConfig();
+
+    }
+
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/utils/DataManager.java

@@ -0,0 +1,29 @@
+package org.cn2b2t.core.managers.utils;
+
+import org.cn2b2t.core.Main;
+import org.cn2b2t.core.managers.utils.database.Connection;
+
+public class DataManager {
+
+    private static Connection connection;
+
+    public static void init() {
+        connection = new Connection(
+                ConfigManager.config.getString("Database.host", "127.0.0.1"),
+                ConfigManager.config.getInt("Database.port", 3306),
+                ConfigManager.config.getString("Database.data", "guiying"),
+                ConfigManager.config.getString("Database.user", "guiying"),
+                ConfigManager.config.getString("Database.password", "guiying"));
+        if (connection.connect()) {
+            Main.log("&7├ └ &a数据库连接成功！");
+        } else {
+            Main.log("&7├ └ &c数据库连接失败！");
+        }
+
+    }
+
+    public static Connection getConnection() {
+        return connection;
+    }
+
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/utils/MessagerManager.java

@@ -0,0 +1,143 @@
+package org.cn2b2t.core.managers.utils;
+
+import com.google.common.collect.Iterables;
+import com.google.common.io.ByteArrayDataOutput;
+import com.google.common.io.ByteStreams;
+import org.cn2b2t.core.Main;
+import org.cn2b2t.core.events.MessageReceiveEvent;
+import org.cn2b2t.core.listener.MessageListener;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.List;
+import java.util.logging.Level;
+
+public class MessagerManager {
+
+	public static List<String> registeredChannels = new ArrayList<>();
+
+	public static long timeOutTime = 1000;
+
+	public static void enable() {
+		Main.getInstance().getServer().getMessenger().registerOutgoingPluginChannel(Main.getInstance(), "BungeeCord");
+		Main.getInstance().getServer().getMessenger().registerIncomingPluginChannel(Main.getInstance(), "BungeeCord", new MessageListener());
+	}
+
+	public static void callEvent(String channel, long sendTime, String fromServer, String fromPlugin, String key, String[] values) {
+		new BukkitRunnable() {
+			@Override
+			public void run() {
+				Bukkit.getPluginManager().callEvent(
+						new MessageReceiveEvent(channel, sendTime, fromServer, fromPlugin, key, values));
+			}
+		}.runTask(Main.getInstance());
+	}
+
+
+	public static void registerChannel(String channel) {
+		if (registeredChannels.contains(channel)) {
+			System.out.println(" Channel " + channel + " has registered.");
+			return;
+		}
+		registeredChannels.add(channel);
+	}
+
+	public static void unRegisterChannel(String channel) {
+		if (!registeredChannels.contains(channel)) {
+			System.out.println(" Channel " + channel + " not registered.");
+			return;
+		}
+		registeredChannels.remove(channel);
+	}
+
+	public static boolean hasChannel(String channel) {
+		return registeredChannels.contains(channel);
+	}
+
+
+	public static void send(JavaPlugin plugin, String channel, String key, String[] values) {
+		if (values == null || values.length < 1) {
+			Main.getInstance().getLogger().log(Level.WARNING, "错误！ 发送的value = null");
+			return;
+		}
+		new BukkitRunnable() {
+			@Override
+			public void run() {
+				StringBuilder message = new StringBuilder();
+
+				for (int i = 0; i < values.length - 1; i++) {
+					message.append(Base64.getEncoder().encodeToString(values[i].getBytes()));
+					message.append(":");
+				}
+				message.append(Base64.getEncoder().encodeToString((values[values.length - 1]).getBytes()));
+
+				String value = message.toString();
+				new BukkitRunnable() {
+					@Override
+					public void run() {
+						send(plugin, channel, true, key, value);
+					}
+				}.runTask(Main.getInstance());
+			}
+		}.runTaskAsynchronously(Main.getInstance());
+	}
+
+	public static void send(String channel, String key, String[] values) {
+		send(Main.getInstance(), channel, key, values);
+	}
+
+
+	public static void send(JavaPlugin plugin, String channel, String key, String value) {
+		send(plugin, channel, false, key, value);
+	}
+
+
+	public static void send(String channel, String key, String value) {
+		send(Main.getInstance(), channel, false, key, value);
+	}
+
+
+	public static void send(String channel, boolean encoded, String key, String value) {
+		send(Main.getInstance(), channel, encoded, key, value);
+	}
+
+	public static void send(JavaPlugin plugin, String channel, boolean encoded, String key, String value) {
+		if (value == null) {
+			Main.getInstance().getLogger().log(Level.WARNING, "错误！ 发送的value = null");
+			return;
+		}
+		try {
+			ByteArrayDataOutput out = ByteStreams.newDataOutput();
+			out.writeUTF("Forward");
+			out.writeUTF("ALL");
+			out.writeUTF(channel);
+			ByteArrayOutputStream msgbytes = new ByteArrayOutputStream();
+			DataOutputStream msgout = new DataOutputStream(msgbytes);
+			//
+			msgout.writeLong(System.currentTimeMillis());
+			msgout.writeUTF(Bukkit.getServerId()); // from port
+			msgout.writeUTF(plugin.getName());
+			msgout.writeInt(encoded ? 1 : 0);
+			//
+			msgout.writeUTF(key);
+			msgout.writeUTF(value);
+
+			out.writeShort(msgbytes.toByteArray().length);
+			out.write(msgbytes.toByteArray());
+			Player player = Iterables.getFirst(Bukkit.getOnlinePlayers(), null);
+			if (player != null) {
+				player.sendPluginMessage(plugin, "BungeeCord", out.toByteArray());
+			}
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/utils/ServersManager.java

@@ -0,0 +1,105 @@
+package org.cn2b2t.core.managers.utils;
+
+import org.cn2b2t.core.Main;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+public class ServersManager
+//		implements PluginMessageListener
+{
+
+
+	public static List<Player> requests = new ArrayList<>();
+	public static List<String> allPlayers = new ArrayList<>();
+
+	public static void init() {
+		Main.getInstance().getServer().getMessenger().registerOutgoingPluginChannel(Main.getInstance(), "BungeeCord");
+		Bukkit.getMessenger().registerOutgoingPluginChannel(Main.getInstance(), "BeeSwitch");
+//		Core.getInstance().getServer().getMessenger().registerIncomingPluginChannel(Core.getInstance(), "BungeeCord", new ServersManager());
+//		new BukkitRunnable() {
+//			@Override
+//			public void run() {
+//				if (Bukkit.getOnlinePlayers().size() < 1) return;
+//				sendGetPlayerList();
+//
+//			}
+//		}.runTaskTimer(Core.getInstance(), 60L, 200L);
+	}
+
+//	public static void sendGetPlayerList() {
+//		ByteArrayOutputStream b = new ByteArrayOutputStream();
+//		DataOutputStream out = new DataOutputStream(b);
+//		try {
+//			out.writeUTF("PlayerList");
+//			out.writeUTF("ALL");
+//		} catch (IOException ex) {
+//			Logger.getLogger(Core.class.getName()).log(Level.SEVERE, null, ex);
+//		}
+//		Player player = Iterables.getFirst(Bukkit.getOnlinePlayers(), null);
+//		if (player != null) {
+//			player.sendPluginMessage(Core.getInstance(), "BungeeCord", b.toByteArray());
+//		}
+//	}
+//
+//	@Override
+//	public void onPluginMessageReceived(String tag, Player player, byte[] data) {
+//		if (!tag.equals("BungeeCord")) return;
+//
+//		ByteArrayDataInput in = ByteStreams.newDataInput(data);
+//		String server = in.readUTF();
+//
+//		if (server.equals("ALL")) {
+//			String[] players = in.readUTF().split(", ");
+//			allPlayers = Arrays.stream(players).collect(Collectors.toList());
+//		} else {
+//			return;
+//		}
+//	}
+
+	public static void teleport(Player p, String server) {
+		ByteArrayOutputStream b = new ByteArrayOutputStream();
+		DataOutputStream out = new DataOutputStream(b);
+		try {
+			out.writeUTF("ConnectOther");
+			out.writeUTF(p.getName());
+			out.writeUTF(server);
+		} catch (IOException ex) {
+			Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
+		}
+		p.sendPluginMessage(Main.getInstance(), "BungeeCord", b.toByteArray());
+	}
+
+	public static void teleport(Player player, String server, int t) {
+		requests.add(player);
+		new BukkitRunnable() {
+			@Override
+			public void run() {
+				if (requests.contains(player) && player.isOnline()) {
+					teleport(player, server);
+					requests.remove(player);
+				}
+				cancel();
+			}
+		}.runTaskLater(Main.getInstance(), 20L * t);
+	}
+
+	public static void backToLobby(Player p) {
+		teleport(p, "lobby");
+	}
+
+	public static void switchServer(Player p, String targetServerIp) {
+		p.sendPluginMessage(Main.getInstance(), "BeeSwitch", targetServerIp.getBytes(StandardCharsets.UTF_8));
+	}
+
+
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/utils/UserManager.java

@@ -0,0 +1,109 @@
+package org.cn2b2t.core.managers.utils;
+
+import org.cn2b2t.core.modules.users.AbstractUserHandler;
+import org.cn2b2t.core.modules.users.User;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+public class UserManager {
+
+    private static HashMap<String, User> users = new HashMap<>();
+
+    protected static final Map<String, Object> handlers = new HashMap<>();
+    protected static final Map<String, Class<? extends AbstractUserHandler>> classes = new HashMap<>();
+
+    public static User registeruser(Player p) {
+        User user = new User(p);
+        users.put(p.getUniqueId().toString(), user);
+        return user;
+    }
+
+    public static User getUser(Player p) {
+        return getUser(p.getUniqueId());
+    }
+
+    public static User getUser(CommandSender sender) {
+        return sender instanceof Player ? getUser((Player) sender) : null;
+    }
+
+    public static User getUser(UUID uuid) {
+        return users.getOrDefault(uuid.toString(), null);
+    }
+
+    public static void unregisterUser(Player p) {
+        users.remove(p.getUniqueId().toString());
+    }
+
+
+    public static Collection<User> getRegisteredUsers() {
+        return users.values();
+    }
+
+
+    public static boolean containsHandler(Class<? extends AbstractUserHandler> handler) {
+        int position = handler.getName().lastIndexOf('.');
+        return classes.containsKey(handler.getName().substring(position + 1));
+    }
+
+    public static boolean containsHandler(String name) {
+        return handlers.containsKey(name);
+    }
+
+    public static void regHandler(Class<? extends AbstractUserHandler> c) {
+        if (containsHandler(c)) {
+            throw new RuntimeException("Handler " + c.getName() + " is existed.");
+        } else {
+            int position = c.getName().lastIndexOf('.');
+            classes.put(c.getName().substring(position + 1), c);
+            for (User u : getRegisteredUsers()) {
+                u.registerHandler(c);
+            }
+        }
+    }
+
+    public static void regHandler(String name, Object o) {
+        if (containsHandler(name)) {
+            throw new RuntimeException("Handler " + name + " is existed.");
+        } else {
+            handlers.put(name, o);
+            for (User u : getRegisteredUsers()) {
+                u.registerHandler(name, o);
+            }
+        }
+    }
+
+    public static void removeHandler(String name) {
+        if (!containsHandler(name)) {
+            throw new RuntimeException("Handler " + name + " wasn't found.");
+        } else {
+            handlers.remove(name);
+            for (User u : getRegisteredUsers()) {
+                u.removeHandler(name);
+            }
+        }
+    }
+
+    public static void removeHandler(Class<? extends AbstractUserHandler> c) {
+        if (!containsHandler(c)) {
+            throw new RuntimeException("Handler " + c.getName() + " wasn't found.");
+        } else {
+            classes.remove(c.getName());
+            for (User u : getRegisteredUsers()) {
+                u.removeHandler(c);
+            }
+        }
+    }
+
+    public static Map<String, Object> getHandlers() {
+        return handlers;
+    }
+
+    public static Map<String, Class<? extends AbstractUserHandler>> getHandlerClasses() {
+        return classes;
+    }
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/utils/database/Builder.java

@@ -0,0 +1,8 @@
+// 
+// Decompiled by Procyon v0.5.30
+// 
+
+package org.cn2b2t.core.managers.utils.database;
+
+public interface Builder {
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/utils/database/BuilderException.java

@@ -0,0 +1,11 @@
+
+
+package org.cn2b2t.core.managers.utils.database;
+
+public class BuilderException extends RuntimeException {
+	private static final long serialVersionUID = -5189696278473157463L;
+
+	public BuilderException(final String message) {
+		super(message);
+	}
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/utils/database/Connection.java

@@ -0,0 +1,376 @@
+package org.cn2b2t.core.managers.utils.database;
+
+import org.cn2b2t.core.Main;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.logging.Level;
+
+public class Connection {
+
+	public boolean debug_outputSQL = true;
+	private Database sql;
+	private boolean databaseIsOpen;
+	private DatabaseConfig databaseConfig;
+
+	private Connection() {
+	}
+
+	public Connection(String SQL_HOST, int SQL_PORT, String SQL_DATA, String SQL_USER, String SQL_PASS) {
+		this.databaseConfig = new DatabaseConfig(SQL_HOST, SQL_PORT, SQL_DATA, SQL_USER, SQL_PASS);
+	}
+
+	public boolean connect() {
+		if (sql != null) {
+			return false;
+		}
+		sql = new MySQL(Bukkit.getLogger(), "Kettle", getDatabaseConfig().SQL_HOST, getDatabaseConfig().SQL_PORT, getDatabaseConfig().SQL_DATA, getDatabaseConfig().SQL_USER, getDatabaseConfig().SQL_PASS);
+		SQLcheck();
+		return databaseIsOpen();
+	}
+
+	public void SQLqueryWithNoResult(String query) {
+		SQLqueryWithNoResult(query, true);
+	}
+
+	public void SQLqueryWithNoResult(String query, boolean output) {
+		SQLcheck();
+		try {
+			getSQL().query(query);
+		} catch (SQLException ex) {
+			Bukkit.getLogger().severe(query);
+			if (output) {
+				info(ex.getLocalizedMessage());
+			}
+		}
+	}
+
+	public ResultSet SQLqueryInTable(String Table) {
+		SQLcheck();
+		String sqlm = "";
+		try {
+			sqlm = "SELECT * FROM " + Table;
+			ResultSet query = getSQL().getConnection().prepareStatement(sqlm, 1004, 1008).executeQuery();
+			return query;
+		} catch (SQLException ex) {
+			Bukkit.getLogger().warning(ex.getLocalizedMessage());
+			Bukkit.getLogger().log(Level.WARNING, "code: {0}", sqlm);
+		}
+		return null;
+	}
+
+	public ResultSet SQLquery(String message) {
+		SQLcheck();
+		try {
+			ResultSet query = getSQL().getConnection().prepareStatement(message, 1004, 1008).executeQuery();
+			return query;
+		} catch (SQLException ex) {
+			Bukkit.getLogger().warning(ex.getLocalizedMessage());
+			Bukkit.getLogger().log(Level.WARNING, "code: {0}", message);
+		}
+		return null;
+	}
+
+	public ResultSet SQLquery(String Table, String QueryName, Object QueryValue) {
+		SQLcheck();
+		String sqlm = "";
+		try {
+			sqlm = "SELECT * FROM " + Table + " WHERE `" + QueryName + "` = '" + QueryValue + "'";
+			ResultSet query = getSQL().getConnection().prepareStatement(sqlm, 1004, 1008).executeQuery();
+			return query;
+		} catch (SQLException ex) {
+			Bukkit.getLogger().warning(ex.getLocalizedMessage());
+			Bukkit.getLogger().log(Level.WARNING, "code: {0}", sqlm);
+		}
+		return null;
+	}
+
+	public ResultSet SQLquery(String Table, String condition) {
+		SQLcheck();
+		String sqlm = "";
+		try {
+			sqlm = "SELECT * FROM " + Table + " WHERE " + condition;
+			ResultSet query = getSQL().getConnection().prepareStatement(sqlm, 1004, 1008).executeQuery();
+			return query;
+		} catch (SQLException ex) {
+			Bukkit.getLogger().warning(ex.getLocalizedMessage());
+			Bukkit.getLogger().log(Level.WARNING, "code: {0}", sqlm);
+		}
+		return null;
+	}
+
+	public Database getSQL() {
+		return sql;
+	}
+
+	public DatabaseConfig getDatabaseConfig() {
+		return databaseConfig;
+	}
+
+	public boolean databaseIsOpen() {
+		return databaseIsOpen;
+	}
+
+	public void SQLcheck() {
+		if (!sql.isOpen()) {
+			sql.open();
+		}
+		databaseIsOpen = sql.isOpen();
+	}
+
+	public void update(String Table, String columnName, Object value, String QueryName, Object QueryValue) {
+
+		ResultSet query = SQLquery(Table, QueryName, QueryValue);
+		String sqlQuery = "";
+		try {
+			if (query != null) {
+				if (query.next()) {
+					sqlQuery = "UPDATE IGNORE " + Table + " SET " + columnName + " = '" + value + "' WHERE " + QueryName + " = '" + QueryValue + "'";
+				} else {
+					sqlQuery = "INSERT IGNORE INTO `" + Table + "`(`" + QueryName + "`, `" + columnName + "`) VALUES ('" + QueryValue + "', '" + value + "')";
+				}
+				if (debug_outputSQL) {
+					Bukkit.getLogger().log(Level.INFO, "code: {0}", sqlQuery);
+				}
+				query.close();
+				SQLqueryWithNoResult(sqlQuery);
+			} else {
+				SQLcheck();
+			}
+		} catch (SQLException e) {
+			info(e.getLocalizedMessage());
+			Bukkit.getLogger().log(Level.WARNING, "code: {0}", sqlQuery);
+		}
+	}
+
+
+	public void update(String Table, String columnName, Object value, String QueryName, Object QueryValue, String QueryName2, Object QueryValue2) {
+		ResultSet query = SQLquery(Table, "`" + QueryName + "` = '" + QueryValue + "' AND `" + QueryName2 + "` = '" + QueryValue2 + "'");
+		String sqlQuery = "";
+		try {
+			if (query != null) {
+
+				if (query.next()) {
+					sqlQuery = "UPDATE IGNORE " + Table + " SET " + columnName + " = '" + value + "' WHERE " + QueryName + " = '" + QueryValue + "'";
+				} else {
+					sqlQuery = "INSERT IGNORE INTO `" + Table + "`(`" + QueryName + "`, `" + columnName + "`) VALUES ('" + QueryValue + "', '" + value + "')";
+				}
+				if (debug_outputSQL) {
+					Bukkit.getLogger().log(Level.INFO, "code: {0}", sqlQuery);
+				}
+				query.close();
+				SQLqueryWithNoResult(sqlQuery);
+			} else {
+				SQLcheck();
+			}
+		} catch (SQLException e) {
+			info(e.getLocalizedMessage());
+			Bukkit.getLogger().log(Level.WARNING, "code: {0}", sqlQuery);
+		}
+	}
+
+	public ResultSet SQLquery(String Table, String[] queryNames, Object[] queryValues) {
+		SQLcheck();
+		StringBuilder sqlm = new StringBuilder();
+		if (queryNames.length != queryValues.length) {
+			throw new RuntimeException("请求的条件名与条件值数量不相符");
+		}
+		sqlm.append("SELECT * FROM ").append(Table).append(" WHERE ");
+		for (int i = 0; i < queryNames.length; i++) {
+			sqlm.append("`").append(queryNames[i]).append("` = '").append(queryValues[i]).append("'");
+			if (i != queryNames.length - 1) {
+				sqlm.append(" AND ");
+			}
+		}
+		if (debug_outputSQL) {
+			Bukkit.getLogger().log(Level.INFO, "code: {0}", sqlm.toString());
+		}
+		try {
+			ResultSet query = getSQL().getConnection().prepareStatement(sqlm.toString(), 1004, 1008).executeQuery();
+			return query;
+		} catch (SQLException ex) {
+			Bukkit.getLogger().warning(ex.getLocalizedMessage());
+			Bukkit.getLogger().log(Level.WARNING, "code: {0}", sqlm);
+		}
+		return null;
+	}
+
+	public void update(String table, String[] columnNames, Object[] values, String[] queryNames, Object[] queryValues) {
+		ResultSet query = SQLquery(table, queryNames, queryValues);
+		StringBuilder sqlQuery = new StringBuilder();
+		if (columnNames.length != values.length || queryNames.length != queryValues.length) {
+			throw new RuntimeException("提交的字段名与字段值数量不相符");
+		}
+		try {
+			if (query != null) {
+
+				if (query.next()) {
+					sqlQuery.append("UPDATE IGNORE ").append(table).append(" SET ");
+					for (int i = 0; i < columnNames.length; i++) {
+						sqlQuery.append(columnNames[i]).append(" = '").append(values[i]).append("'");
+						if (i != columnNames.length - 1) {
+							sqlQuery.append(", ");
+						}
+					}
+					sqlQuery.append(" WHERE ");
+					for (int i = 0; i < queryNames.length; i++) {
+						sqlQuery.append("`").append(queryNames[i]).append("` = '").append(queryValues[i]).append("'");
+						if (i != queryNames.length - 1) {
+							sqlQuery.append(" AND ");
+						}
+					}
+				} else {
+					sqlQuery.append("INSERT IGNORE INTO `").append(table).append("`(");
+					for (int i = 0; i < columnNames.length; i++) {
+						sqlQuery.append("`").append(columnNames[i]).append("`");
+						if (i != columnNames.length - 1) {
+							sqlQuery.append(", ");
+						} else {
+							if (queryNames.length > 0) {
+								sqlQuery.append(", ");
+							}
+						}
+					}
+					for (int i = 0; i < queryNames.length; i++) {
+						sqlQuery.append("`").append(queryNames[i]).append("`");
+						if (i != queryNames.length - 1) {
+							sqlQuery.append(", ");
+						}
+					}
+					sqlQuery.append(") VALUES (");
+					for (int i = 0; i < values.length; i++) {
+						sqlQuery.append("'").append(values[i]).append("'");
+						if (i != values.length - 1) {
+							sqlQuery.append(", ");
+						} else {
+							if (queryValues.length > 0) {
+								sqlQuery.append(", ");
+							}
+						}
+					}
+					for (int i = 0; i < queryValues.length; i++) {
+						sqlQuery.append("'").append(queryValues[i]).append("'");
+						if (i != queryValues.length - 1) {
+							sqlQuery.append(", ");
+						}
+					}
+					sqlQuery.append(")");
+				}
+				if (debug_outputSQL) {
+					Bukkit.getLogger().log(Level.INFO, "code: {0}", sqlQuery);
+				}
+				query.close();
+				SQLqueryWithNoResult(sqlQuery.toString());
+			} else {
+				SQLcheck();
+			}
+		} catch (SQLException e) {
+			info(e.getLocalizedMessage());
+			Bukkit.getLogger().log(Level.SEVERE, "code: {0}", sqlQuery);
+		}
+	}
+
+	public void insert(String table, String[] columnNames, Object[] values) {
+		StringBuilder sqlQuery = new StringBuilder();
+		if (columnNames.length != values.length) {
+			throw new RuntimeException("提交的字段名与字段值数量不相符");
+		}
+
+		sqlQuery.append("INSERT IGNORE INTO `").append(table).append("`(");
+		for (int i = 0; i < columnNames.length; i++) {
+			sqlQuery.append("`").append(columnNames[i]).append("`");
+			if (i != columnNames.length - 1) {
+				sqlQuery.append(", ");
+			}
+		}
+		sqlQuery.append(") VALUES (");
+		for (int i = 0; i < values.length; i++) {
+			sqlQuery.append("'").append(values[i]).append("'");
+			if (i != values.length - 1) {
+				sqlQuery.append(", ");
+			}
+		}
+		sqlQuery.append(")");
+
+		if (debug_outputSQL) {
+			Bukkit.getLogger().log(Level.INFO, "code: {0}", sqlQuery);
+		}
+
+		SQLqueryWithNoResult(sqlQuery.toString());
+	}
+
+	public void delete(String Table, String queryName, Object queryValue) {
+		SQLcheck();
+		StringBuilder sqlm = new StringBuilder();
+		sqlm.append("DELETE FROM ").append(Table).append(" WHERE `").append(queryName).append("` = '").append(queryValue).append("'");
+
+		if (debug_outputSQL) {
+			Bukkit.getLogger().log(Level.INFO, "code: {0}", sqlm);
+		}
+
+		SQLqueryWithNoResult(sqlm.toString());
+	}
+
+	public void delete(String Table, String[] queryNames, Object[] queryValues) {
+		SQLcheck();
+		StringBuilder sqlm = new StringBuilder();
+		if (queryNames.length != queryValues.length) {
+			throw new RuntimeException("请求的条件名与条件值数量不相符");
+		}
+		sqlm.append("DELETE FROM ").append(Table).append(" WHERE ");
+		for (int i = 0; i < queryNames.length; i++) {
+			sqlm.append("`").append(queryNames[i]).append("` = '").append(queryValues[i]).append("'");
+			if (i != queryNames.length - 1) {
+				sqlm.append(" AND ");
+			}
+		}
+
+		if (debug_outputSQL) {
+			Bukkit.getLogger().log(Level.INFO, "code: {0}", sqlm);
+		}
+
+		SQLqueryWithNoResult(sqlm.toString());
+	}
+
+	public void updateAsyn(String Table, String columnName, Object value, String QueryName, Object QueryValue) {
+		new BukkitRunnable() {
+			@Override
+			public void run() {
+				update(Table, columnName, value, QueryName, QueryValue);
+				cancel();
+			}
+		}.runTaskAsynchronously(Main.getInstance());
+	}
+
+	public void updateAsyn(String table, String[] columnNames, Object[] values, String[] queryNames, Object[] queryValues) {
+		new BukkitRunnable() {
+			@Override
+			public void run() {
+				update(table, columnNames, values, queryNames, queryValues);
+				cancel();
+			}
+		}.runTaskAsynchronously(Main.getInstance());
+	}
+
+	public void insertAsyn(String table, String[] columnNames, Object[] values) {
+		new BukkitRunnable() {
+			@Override
+			public void run() {
+				insert(table, columnNames, values);
+				cancel();
+			}
+		}.runTaskAsynchronously(Main.getInstance());
+	}
+
+	public void info(String msg) {
+		info(Bukkit.getConsoleSender(), msg);
+	}
+
+	public void info(CommandSender sender, String msg) {
+		sender.sendMessage(msg.replace("&", "§"));
+	}
+
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/utils/database/DBMS.java

@@ -0,0 +1,46 @@
+package org.cn2b2t.core.managers.utils.database;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public enum DBMS {
+	Other("[Other] "),
+	Firebird("[Firebird] "),
+	FrontBase("[FrontBase] "),
+	DB2("[DB2] "),
+	H2("[H2] "),
+	Informix("[Informix] "),
+	Ingres("[Ingres] "),
+	MaxDB("[MaxDB] "),
+	MicrosoftSQL("[MicrosoftSQL] "),
+	Mongo("[Mongo] "),
+	mSQL("[mSQL] "),
+	MySQL("[MySQL] "),
+	Oracle("[Oracle] "),
+	PostgreSQL("[PostgreSQL] "),
+	SQLite("[SQLite] ");
+
+	private static Map<String, DBMS> prefixes;
+
+	static {
+		DBMS.prefixes = new HashMap<String, DBMS>();
+		for (final DBMS dbms : DBMS.prefixes.values()) {
+			DBMS.prefixes.put(dbms.toString(), dbms);
+		}
+	}
+
+	private final String prefix;
+
+	DBMS(final String prefix) {
+		this.prefix = prefix;
+	}
+
+	public static DBMS getDBMS(final String prefix) {
+		return DBMS.prefixes.get(prefix);
+	}
+
+	@Override
+	public String toString() {
+		return this.prefix;
+	}
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/utils/database/Database.java

@@ -0,0 +1,209 @@
+package org.cn2b2t.core.managers.utils.database;
+
+import java.sql.Connection;
+import java.sql.*;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.logging.Logger;
+
+public abstract class Database {
+	protected final String prefix;
+	protected Logger log;
+	protected DBMS driver;
+	protected Connection connection;
+	protected Map<PreparedStatement, StatementEnum> preparedStatements = new HashMap<PreparedStatement, StatementEnum>();
+	protected int lastUpdate;
+
+	public Database(final Logger log, final String prefix, final DBMS dbms) throws DatabaseException {
+//        this.preparedStatements = new HashMap<PreparedStatement, StatementEnum>();
+		if (log == null) {
+			throw new DatabaseException("Logger cannot be null.");
+		}
+		if (prefix == null || prefix.length() == 0) {
+			throw new DatabaseException("Plugin prefix cannot be null or empty.");
+		}
+		this.log = log;
+		this.prefix = prefix;
+		this.driver = dbms;
+	}
+
+	protected final String prefix(final String message) {
+		return this.prefix + this.driver + message;
+	}
+
+	@Deprecated
+	public final void writeInfo(final String toWrite) {
+		this.info(toWrite);
+	}
+
+	@Deprecated
+	public final void writeError(final String toWrite, final boolean severe) {
+		if (severe) {
+			this.error(toWrite);
+		} else {
+			this.warning(toWrite);
+		}
+	}
+
+	public final void info(final String info) {
+		if (info != null && !info.isEmpty()) {
+			this.log.info(this.prefix(info));
+		}
+	}
+
+	public final void warning(final String warning) {
+		if (warning != null && !warning.isEmpty()) {
+			this.log.warning(this.prefix(warning));
+		}
+	}
+
+	public final void error(final String error) {
+		if (error != null && !error.isEmpty()) {
+			this.log.severe(this.prefix(error));
+		}
+	}
+
+	protected abstract boolean initialize();
+
+	public final DBMS getDriver() {
+		return this.getDBMS();
+	}
+
+	public final DBMS getDBMS() {
+		return this.driver;
+	}
+
+	public abstract boolean open();
+
+	public final boolean close() {
+		if (this.connection != null) {
+			try {
+				this.connection.close();
+				return true;
+			} catch (SQLException e) {
+				this.writeError("Could not close connection, SQLException: " + e.getMessage(), true);
+				return false;
+			}
+		}
+		this.writeError("Could not close connection, it is null.", true);
+		return false;
+	}
+
+	@Deprecated
+	public final boolean isConnected() {
+		return this.isOpen();
+	}
+
+	public final Connection getConnection() {
+		return this.connection;
+	}
+
+	public final boolean isOpen() {
+		return this.isOpen(1);
+	}
+
+	public final boolean isOpen(final int seconds) {
+		if (this.connection != null) {
+			try {
+				if (this.connection.isValid(seconds)) {
+					return true;
+				}
+			} catch (SQLException ex) {
+			}
+		}
+		return false;
+	}
+
+	@Deprecated
+	public final boolean checkConnection() {
+		return this.isOpen();
+	}
+
+	public final int getLastUpdateCount() {
+		return this.lastUpdate;
+	}
+
+	protected abstract void queryValidation(final StatementEnum p0) throws SQLException;
+
+	public final ResultSet query(final String query) throws SQLException {
+		this.queryValidation(this.getStatement(query));
+		final Statement statement = this.getConnection().createStatement();
+		if (statement.execute(query)) {
+			return statement.getResultSet();
+		}
+		final int uc = statement.getUpdateCount();
+		this.lastUpdate = uc;
+		return this.getConnection().createStatement().executeQuery("SELECT " + uc);
+	}
+
+	protected final ResultSet query(final PreparedStatement ps, final StatementEnum statement) throws SQLException {
+		this.queryValidation(statement);
+		if (ps.execute()) {
+			return ps.getResultSet();
+		}
+		final int uc = ps.getUpdateCount();
+		this.lastUpdate = uc;
+		return this.connection.createStatement().executeQuery("SELECT " + uc);
+	}
+
+	public final ResultSet query(final PreparedStatement ps) throws SQLException {
+		ResultSet output = this.query(ps, this.preparedStatements.get(ps));
+		this.preparedStatements.remove(ps);
+		return output;
+	}
+
+	public final PreparedStatement prepare(final String query) throws SQLException {
+		final StatementEnum s = this.getStatement(query);
+		final PreparedStatement ps = this.connection.prepareStatement(query);
+		this.preparedStatements.put(ps, s);
+		return ps;
+	}
+
+	public ArrayList<Long> insert(final String query) throws SQLException {
+		final ArrayList<Long> keys = new ArrayList<Long>();
+		final PreparedStatement ps = this.connection.prepareStatement(query, 1);
+		this.lastUpdate = ps.executeUpdate();
+		final ResultSet key = ps.getGeneratedKeys();
+		if (key.next()) {
+			keys.add(key.getLong(1));
+		}
+		return keys;
+	}
+
+	public ArrayList<Long> insert(final PreparedStatement ps) throws SQLException {
+		this.lastUpdate = ps.executeUpdate();
+		this.preparedStatements.remove(ps);
+		final ArrayList<Long> keys = new ArrayList<Long>();
+		final ResultSet key = ps.getGeneratedKeys();
+		if (key.next()) {
+			keys.add(key.getLong(1));
+		}
+		return keys;
+	}
+
+	public final ResultSet query(final Builder builder) throws SQLException {
+		return this.query(builder.toString());
+	}
+
+	public abstract StatementEnum getStatement(final String p0) throws SQLException;
+
+	@Deprecated
+	public boolean createTable() {
+		return false;
+	}
+
+	@Deprecated
+	public boolean checkTable(final String table) {
+		return this.isTable(table);
+	}
+
+	@Deprecated
+	public boolean wipeTable(final String table) {
+		return this.truncate(table);
+	}
+
+	public abstract boolean isTable(final String p0);
+
+	public abstract boolean truncate(final String p0);
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/utils/database/DatabaseConfig.java

@@ -0,0 +1,17 @@
+package org.cn2b2t.core.managers.utils.database;
+
+public class DatabaseConfig {
+	public final String SQL_HOST;
+	public final int SQL_PORT;
+	public final String SQL_DATA;
+	public final String SQL_USER;
+	public final String SQL_PASS;
+
+	public DatabaseConfig(String SQL_HOST, int SQL_PORT, String SQL_DATA, String SQL_USER, String SQL_PASS) {
+		this.SQL_HOST = SQL_HOST;
+		this.SQL_PORT = SQL_PORT;
+		this.SQL_DATA = SQL_DATA;
+		this.SQL_USER = SQL_USER;
+		this.SQL_PASS = SQL_PASS;
+	}
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/utils/database/DatabaseException.java

@@ -0,0 +1,13 @@
+// 
+// Decompiled by Procyon v0.5.30
+// 
+
+package org.cn2b2t.core.managers.utils.database;
+
+public class DatabaseException extends RuntimeException {
+	private static final long serialVersionUID = 3063547825200154629L;
+
+	public DatabaseException(final String message) {
+		super(message);
+	}
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/utils/database/HostnameDatabase.java

@@ -0,0 +1,70 @@
+package org.cn2b2t.core.managers.utils.database;
+
+import java.util.logging.Logger;
+
+public abstract class HostnameDatabase extends Database {
+	private String hostname = "localhost";
+	private int port = 0;
+	private String database = "minecraft";
+	private String username = "minecraft";
+	private String password = "";
+
+	public HostnameDatabase(Logger log, String prefix, DBMS dbms, String hostname, int port, String database, String username, String password) {
+		super(log, prefix, dbms);
+		setHostname(hostname);
+		setPort(port);
+		setUsername(username);
+		setPassword(password);
+		setDatabase(database);
+	}
+
+	public String getHostname() {
+		return this.hostname;
+	}
+
+	public void setHostname(String hostname) {
+		if ((hostname == null) || (hostname.length() == 0))
+			throw new RuntimeException("Hostname cannot be null or empty.");
+		this.hostname = hostname;
+	}
+
+	public int getPort() {
+		return this.port;
+	}
+
+	public void setPort(int port) {
+		if ((port < 0) || (65535 < port))
+			throw new RuntimeException("Port number cannot be below 0 or greater than 65535.");
+		this.port = port;
+	}
+
+	public String getUsername() {
+		return this.username;
+	}
+
+	public void setUsername(String username) {
+		if (username == null)
+			throw new RuntimeException("Username cannot be null.");
+		this.username = username;
+	}
+
+	public String getPassword() {
+		return this.password;
+	}
+
+	public void setPassword(String password) {
+		if (password == null)
+			throw new RuntimeException("Password cannot be null.");
+		this.password = password;
+	}
+
+	public String getDatabase() {
+		return this.database;
+	}
+
+	public void setDatabase(String database) {
+		if ((database == null) || (database.length() == 0))
+			throw new RuntimeException("Database cannot be null or empty.");
+		this.database = database;
+	}
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/utils/database/MySQL.java

@@ -0,0 +1,184 @@
+package org.cn2b2t.core.managers.utils.database;
+
+
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.logging.Logger;
+
+public class MySQL extends HostnameDatabase {
+
+	public MySQL(final Logger log, final String prefix, final String hostname, final String port, final String database, final String username, final String password) {
+		super(log, prefix, DBMS.MySQL, hostname, Integer.parseInt(port), database, username, password);
+	}
+
+	public MySQL(final Logger log, final String prefix, final String hostname, final int port, final String database, final String username, final String password) {
+		super(log, prefix, DBMS.MySQL, hostname, port, database, username, password);
+	}
+
+	public MySQL(final Logger log, final String prefix, final String database, final String username, final String password) {
+		super(log, prefix, DBMS.MySQL, "localhost", 3306, database, username, password);
+	}
+
+	public MySQL(final Logger log, final String prefix, final String database, final String username) {
+		super(log, prefix, DBMS.MySQL, "localhost", 3306, database, username, "");
+	}
+
+	public MySQL(final Logger log, final String prefix, final String database) {
+		super(log, prefix, DBMS.MySQL, "localhost", 3306, database, "", "");
+	}
+
+	@Override
+	protected boolean initialize() {
+		try {
+			Class.forName("com.mysql.jdbc.jdbc2.optional.MysqlDataSource");
+			return true;
+		} catch (ClassNotFoundException e) {
+			this.warning("MySQL DataSource class missing: " + e.getMessage() + ".");
+			return false;
+		}
+	}
+
+	@Override
+	public boolean open() {
+		try {
+			final String url = "jdbc:mysql://" + this.getHostname() + ":" + this.getPort() + "/" + this.getDatabase() + "?autoReconnect=true";
+			if (this.initialize()) {
+				this.connection = DriverManager.getConnection(url, this.getUsername(), this.getPassword());
+				return true;
+			}
+			return false;
+		} catch (SQLException e) {
+			this.error("Could not establish a MySQL connection, SQLException: " + e.getMessage());
+			return false;
+		}
+	}
+
+	@Override
+	protected void queryValidation(final StatementEnum statement) throws SQLException {
+		switch ((Statements) statement) {
+			case USE: {
+				this.warning("Please create a new connection to use a different database.");
+				throw new SQLException("Please create a new connection to use a different database.");
+			}
+			case PREPARE:
+			case EXECUTE:
+			case DEALLOCATE: {
+				this.warning("Please use the prepare() method to prepare a SoulHistory.");
+				throw new SQLException("Please use the prepare() method to prepare a SoulHistory.");
+			}
+			default: {
+			}
+		}
+	}
+
+	@Override
+	public Statements getStatement(final String query) throws SQLException {
+		final String[] statement = query.trim().split(" ", 2);
+		try {
+			final Statements converted = Statements.valueOf(statement[0].toUpperCase());
+			return converted;
+		} catch (IllegalArgumentException e) {
+			throw new SQLException("Unknown statement: \"" + statement[0] + "\".");
+		}
+	}
+
+	@Deprecated
+	public boolean createTable(final String query) {
+		Statement statement = null;
+		if (query == null || query.equals("")) {
+			this.writeError("Could not create table: SoulHistory is empty or null.", true);
+			return false;
+		}
+		try {
+			statement = this.connection.createStatement();
+			statement.execute(query);
+			statement.close();
+		} catch (SQLException e) {
+			this.writeError("Could not create table, SQLException: " + e.getMessage(), true);
+			return false;
+		}
+		return true;
+	}
+
+	@Override
+	public boolean isTable(final String table) {
+		Statement statement;
+		try {
+			statement = this.connection.createStatement();
+		} catch (SQLException e) {
+			this.error("Could not create a statement in checkTable(), SQLException: " + e.getMessage());
+			return false;
+		}
+		try {
+			statement.executeQuery("SELECT * FROM " + table);
+			return true;
+		} catch (SQLException e) {
+			return false;
+		}
+	}
+
+	@Override
+	public boolean truncate(final String table) {
+		Statement statement = null;
+		String query = null;
+		try {
+			if (!this.isTable(table)) {
+				this.error("Table \"" + table + "\" does not exist.");
+				return false;
+			}
+			statement = this.connection.createStatement();
+			query = "DELETE FROM " + table + ";";
+			statement.executeUpdate(query);
+			statement.close();
+			return true;
+		} catch (SQLException e) {
+			this.error("Could not wipe table, SQLException: " + e.getMessage());
+			return false;
+		}
+	}
+
+	public enum Statements implements StatementEnum {
+		SELECT("SELECT"),
+		INSERT("INSERT"),
+		UPDATE("UPDATE"),
+		DELETE("DELETE"),
+		DO("DO"),
+		REPLACE("REPLACE"),
+		LOAD("LOAD"),
+		HANDLER("HANDLER"),
+		CALL("CALL"),
+		CREATE("CREATE"),
+		ALTER("ALTER"),
+		DROP("DROP"),
+		TRUNCATE("TRUNCATE"),
+		RENAME("RENAME"),
+		START("START"),
+		COMMIT("COMMIT"),
+		SAVEPOINT("SAVEPOINT"),
+		ROLLBACK("ROLLBACK"),
+		RELEASE("RELEASE"),
+		LOCK("LOCK"),
+		UNLOCK("UNLOCK"),
+		PREPARE("PREPARE"),
+		EXECUTE("EXECUTE"),
+		DEALLOCATE("DEALLOCATE"),
+		SET("SET"),
+		SHOW("SHOW"),
+		DESCRIBE("DESCRIBE"),
+		EXPLAIN("EXPLAIN"),
+		HELP("HELP"),
+		USE("USE");
+
+		private final String string;
+
+		Statements(final String string) {
+			this.string = string;
+		}
+
+		@Override
+		public String toString() {
+			return this.string;
+		}
+	}
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/utils/database/StatementEnum.java

@@ -0,0 +1,4 @@
+package org.cn2b2t.core.managers.utils.database;
+
+public interface StatementEnum {
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/utils/scoreboard/CeramicScoreboard.java

@@ -0,0 +1,157 @@
+package org.cn2b2t.core.managers.utils.scoreboard;
+
+import org.cn2b2t.core.utils.ColorParser;
+import org.bukkit.Bukkit;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class CeramicScoreboard {
+
+    final String[] texts = new String[]{"", "", "", "", "", "", "", "", "", "", "", "", "", "", ""};
+    SBPriority pri;
+    String title;
+    private boolean rending = false;
+
+    public CeramicScoreboard() {
+        this("&f&lCeramic", SBPriority.NORMAL);
+    }
+
+    public CeramicScoreboard(String title, SBPriority pri) {
+        this.title = title;
+        this.pri = pri;
+    }
+
+    public CeramicScoreboard(String title) {
+        this(title, SBPriority.NORMAL);
+    }
+
+    public CeramicScoreboard(SBPriority pri) {
+        this("&f&lKa&7&lr", pri);
+    }
+
+    public String getLine(int index) {
+        if (index < 0 || index > 14) {
+            throw new IndexOutOfBoundsException(String.valueOf(index));
+        }
+        return this.texts[index];
+    }
+
+    public boolean isCleared(int index) {
+        return this.texts[index] == null || this.texts[index].equals("") || this.texts[index].equals("{clear}");
+    }
+
+    public List<String> getTexts() {
+        List<String> l = new ArrayList<>();
+        for (int i = 14; i > -1; i--) {
+            if (!this.texts[i].equals("")) {
+                for (int id = 0; id < i + 1; id++) {
+                    if (this.texts[i].equals("")) {
+                        l.add(Null());
+                    } else {
+                        l.add(this.texts[id]);
+                    }
+                }
+                break;
+            }
+        }
+        return l;
+    }
+
+    public SBPriority getPriority() {
+        return this.pri;
+    }
+
+    public void setPriority(SBPriority pri) {
+        PriorityChangeEvent e = new PriorityChangeEvent(this, this.pri, pri);
+        Bukkit.getPluginManager().callEvent(e);
+        if (e.isCancelled()) {
+            return;
+        }
+        this.pri = e.getNew();
+    }
+
+    public boolean isRending() {
+        return this.rending;
+    }
+
+    protected void setRending(boolean b) {
+        this.rending = b;
+    }
+
+    public void setTitle(String text) {
+        TitleUpdateEvent e = new TitleUpdateEvent(this, this.title, text);
+        Bukkit.getPluginManager().callEvent(e);
+        if (e.isCancelled()) {
+            return;
+        }
+        this.title = text;
+    }
+
+    public String getTitle() {
+        return this.title;
+    }
+
+    public void setLine(int index, String text) {
+        text = ColorParser.parse(text);
+
+        if (index < 0 || index > 14) {
+            throw new IndexOutOfBoundsException(String.valueOf(index));
+        }
+        if (texts[index].equals(text)) {
+            return;
+        }
+        LineUpdateEvent e = new LineUpdateEvent(this, index, texts[index], text);
+        Bukkit.getPluginManager().callEvent(e);
+        if (e.isCancelled()) {
+            return;
+        }
+        texts[index] = e.getNew();
+    }
+
+    public void clearLine(int index) {
+        setLine(index, "{clear}");
+    }
+
+    public String Null() {
+        int c = 0;
+        List<String> list = new ArrayList<>();
+        list.addAll(Arrays.asList(texts).subList(0, 15));
+        while (true) {
+            if (c < 11) {
+                if (list.contains("&" + c) || list.contains("§" + c)) {
+                    c++;
+                    continue;
+                } else {
+                    return "§" + c;
+                }
+            } else if (list.contains("§a") || list.contains("&a")) {
+                if (list.contains("§b") || list.contains("&b")) {
+                    if (list.contains("§c") || list.contains("&c")) {
+                        if (list.contains("§d") || list.contains("&d")) {
+                            if (list.contains("§e") || list.contains("&e")) {
+                                if (list.contains("§r") || list.contains("&r")) {
+                                    return null;
+                                } else {
+                                    return "§r";
+                                }
+                            } else {
+                                return "§e";
+                            }
+                        } else {
+                            return "§d";
+                        }
+                    } else {
+                        return "§c";
+                    }
+                } else {
+                    return "§b";
+                }
+            } else {
+                return "§a";
+            }
+        }
+    }
+
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/utils/scoreboard/LineUpdateEvent.java

@@ -0,0 +1,69 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.cn2b2t.core.managers.utils.scoreboard;
+
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+/**
+ *
+ * @author LSeng
+ */
+public class LineUpdateEvent extends Event {
+
+    private static final HandlerList handler = new HandlerList();
+    CeramicScoreboard sb;
+    String old,New;
+    int line;
+    boolean cancelled = false;
+    
+    private LineUpdateEvent(){}
+    
+    public LineUpdateEvent(CeramicScoreboard sb,int line,String old,String New){
+        this.sb = sb;
+        this.old = old;
+        this.New = New;
+        this.line = line;
+    }
+    
+    public CeramicScoreboard getKarScoreboard(){
+        return this.sb;
+    }
+    
+    public String getOld(){
+        return this.old;
+    }
+    
+    public String getNew(){
+        return this.New;
+    }
+    
+    public void setNew(String New){
+        this.New = New;
+    }
+    
+    public int getLine(){
+        return this.line;
+    }
+    
+    public void setCancelled(boolean b){
+        this.cancelled = b;
+    }
+    
+    public boolean isCancelled(){
+        return this.cancelled;
+    }
+    
+    @Override
+    public HandlerList getHandlers() {
+        return handler;
+    }
+    
+    public static HandlerList getHandlerList() {
+        return handler;
+    }
+    
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/utils/scoreboard/PriorityChangeEvent.java

@@ -0,0 +1,55 @@
+package org.cn2b2t.core.managers.utils.scoreboard;
+
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+public class PriorityChangeEvent extends Event {
+    
+    private static final HandlerList handler = new HandlerList();
+    
+    CeramicScoreboard sb;
+    SBPriority old,New;
+    boolean cancelled = false;
+    
+    private PriorityChangeEvent(){}
+    
+    public PriorityChangeEvent(CeramicScoreboard sb,SBPriority old,SBPriority New){
+        this.sb = sb;
+        this.old = old;
+        this.New = New;
+    }
+    
+    public CeramicScoreboard getKarScoreboard(){
+        return sb;
+    }
+    
+    public SBPriority getOld(){
+        return this.old;
+    }
+    
+    public SBPriority getNew(){
+        return this.New;
+    }
+    
+    public void setSBPriority(SBPriority p){
+        this.New = p;
+    }
+    
+    public boolean isCancelled(){
+        return this.cancelled;
+    }
+    
+    public void setCanncelled(Boolean b){
+        this.cancelled = b;
+    }
+
+    @Override
+    public HandlerList getHandlers() {
+        return handler;
+    }
+    
+    public static HandlerList getHandlerList() {
+        return handler;
+    }
+    
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/utils/scoreboard/RendedChangeEvent.java

@@ -0,0 +1,43 @@
+package org.cn2b2t.core.managers.utils.scoreboard;
+
+import org.cn2b2t.core.modules.users.User;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+public class RendedChangeEvent extends Event {
+    
+    private static final HandlerList handler = new HandlerList();
+    
+    User user;
+    CeramicScoreboard old,New;
+    
+    private RendedChangeEvent(){}
+    
+    public RendedChangeEvent(User user,CeramicScoreboard old,CeramicScoreboard New){
+        this.user = user;
+        this.old = old;
+        this.New = New;
+    }
+    
+    public User getUser(){
+        return this.user;
+    }
+    
+     public CeramicScoreboard getOld(){
+        return this.old;
+    }
+    
+    public CeramicScoreboard getNew(){
+        return this.New;
+    }
+    
+    @Override
+    public HandlerList getHandlers() {
+        return handler;
+    }
+    
+    public static HandlerList getHandlerList() {
+        return handler;
+    }
+    
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/utils/scoreboard/SBPriority.java

@@ -0,0 +1,42 @@
+package org.cn2b2t.core.managers.utils.scoreboard;
+
+public enum SBPriority {
+    
+    CANCEL(-1),
+    LOWEAST(1),
+    LOW(2),
+    NORMAL(3),
+    HIGH(4),
+    HIGHER(5),
+    ULTRA(6),
+    ULTRA_P(7),
+    ULTRA_PS(8),
+    ULTRA_X(9),
+    COSTOM(0,true);
+    
+    int pri;
+    boolean costom = false;
+    
+    private SBPriority(int pri){
+        this.pri = pri;
+    }
+    
+    private SBPriority(int pri,boolean costom){
+        this.pri = pri;
+        this.costom = costom;
+    }
+    
+    public boolean costom(int pri){
+        if(costom){
+            this.pri = pri;
+            return true;
+        }else{
+            return false;
+        }
+    }
+    
+    public int size(){
+        return this.pri;
+    }
+    
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/utils/scoreboard/ScoreBoardRender.java

@@ -0,0 +1,389 @@
+package org.cn2b2t.core.managers.utils.scoreboard;
+
+import org.cn2b2t.core.Main;
+import org.cn2b2t.core.modules.users.User;
+import org.cn2b2t.core.managers.utils.UserManager;
+import org.apache.commons.lang3.Validate;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.scoreboard.DisplaySlot;
+import org.bukkit.scoreboard.Objective;
+import org.bukkit.scoreboard.Scoreboard;
+import org.bukkit.scoreboard.Team;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * 该类为内部使用，可能会在将来版本中去除
+ *
+ * @author LSeng
+ */
+public final class ScoreBoardRender {
+
+	boolean display = true;
+
+	private CeramicScoreboard rended;
+	private static final List<ChatColor> colors = Arrays.asList(ChatColor.values()); //所有颜色
+	private final Player player;
+	private final Scoreboard sb;
+	private final Objective objective;
+	private final List<BoardLine> boardLines = new ArrayList<>();// "行"
+	private int maxLine;//用于标注最大行数
+	private Listener listener;
+
+	public ScoreBoardRender(Player p, String title, Scoreboard sb) {
+
+		this.player = p;
+		if (sb == null) {
+//            if(Bukkit.getScoreboardManager().getMainScoreboard() == null){
+			sb = Bukkit.getScoreboardManager().getNewScoreboard();
+			this.sb = sb;
+//            }else{
+//                this.sb = Bukkit.getScoreboardManager().getMainScoreboard();
+//            }
+		} else {
+			this.sb = sb;
+		}
+//        if(getBoard().getObjective(DisplaySlot.SIDEBAR)!=null){
+//            objective = getBoard().getObjective(DisplaySlot.SIDEBAR);
+//        }else{
+		objective = getBoard().registerNewObjective(p.getUniqueId().toString().substring(0, 16), "dummy");
+//        }
+		objective.setDisplaySlot(DisplaySlot.SIDEBAR);
+		try {
+//            getBoard().getTeams().clear();
+		} catch (Exception ex) {
+		}
+
+		setTitle(title.replace("&", "§"));
+		for (int i = 0; i < colors.size(); i++) { //循环所有的颜色
+			final ChatColor color = colors.get(i);
+			final Team team = getBoard().registerNewTeam("boardLine" + i); //为每个颜色注册一个队伍
+			team.addEntry(color.toString()); //为队伍设置一个"行"
+			boardLines.add(new BoardLine(color, team)); //将"行"添加至列表
+		}
+		p.setScoreboard(this.sb);
+
+		this.listener = new Listener() {
+
+			@EventHandler
+			public void onQuit(PlayerQuitEvent event) {
+				if (event.getPlayer() == player) {
+					HandlerList.unregisterAll(this);
+				}
+			}
+
+			@EventHandler
+			public void onTitleUpdata(TitleUpdateEvent event) {
+				if (!display) {
+					return;
+				}
+				if (ScoreBoardRender.this.rended == null) {
+					return;
+				}
+				if (event.getKarScoreboard() == ScoreBoardRender.this.rended) {
+					setTitle(event.getNew());
+				}
+			}
+
+			@EventHandler
+			public void onLineUpdata(LineUpdateEvent event) {
+				if (!display) {
+					return;
+				}
+				if (ScoreBoardRender.this.rended == null) {
+					return;
+				}
+				if (event.getKarScoreboard() == ScoreBoardRender.this.rended) {
+					if (event.getNew().equals("{clear}")) {
+						removeLine(event.getLine());
+					} else {
+						setLine(event.getLine(), event.getNew());
+					}
+				}
+			}
+
+			@EventHandler
+			public void onPriorityUpdata(PriorityChangeEvent event) {
+				if (ScoreBoardRender.this.rended == null) {
+					return;
+				}
+				User u = UserManager.getUser(p);
+				if (event.getKarScoreboard() == ScoreBoardRender.this.rended && event.getNew() == SBPriority.CANCEL && u.getScoreboards().size() == 1) {
+					p.getScoreboard().clearSlot(DisplaySlot.SIDEBAR);
+					ScoreBoardRender.this.rended = null;
+					u.getScoreboards().remove(event.getKarScoreboard());
+					return;
+				}
+				if (event.getKarScoreboard() == ScoreBoardRender.this.rended) {
+					CeramicScoreboard max = event.getKarScoreboard();
+					for (CeramicScoreboard sb : u.getScoreboards()) {
+						if (sb.getPriority().size() > max.getPriority().size()) {
+							max = sb;
+						}
+					}
+					setRended(event.getKarScoreboard());
+					if (display) {
+						update();
+					}
+				} else if (event.getNew().size() > ScoreBoardRender.this.rended.getPriority().size() && event.getNew() != SBPriority.CANCEL) {
+					setRended(event.getKarScoreboard());
+					if (display) {
+						update();
+					}
+				}
+			}
+
+			@EventHandler
+			public void onScoreboardEnable(ScoreboardEnableEvent event) {
+				if (!event.user.getPlayer().equals(p)) {
+					return;
+				}
+				ScoreBoardRender.this.display = event.b;
+				if (ScoreBoardRender.this.display) {
+					ScoreBoardRender.this.objective.setDisplaySlot(DisplaySlot.SIDEBAR);
+					update();
+				} else {
+					p.getScoreboard().clearSlot(DisplaySlot.SIDEBAR);
+				}
+			}
+
+			@EventHandler
+			public void onScoreboardAdd(ScoreboardAddEvent event) {
+				if (!event.user.getPlayer().equals(p)) {
+					return;
+				}
+				if (ScoreBoardRender.this.rended == null) {
+					setRended(event.getKarScoreboard());
+					return;
+				}
+				if (event.getKarScoreboard().getPriority().size() >= ScoreBoardRender.this.rended.getPriority().size()) {
+					setRended(event.getKarScoreboard());
+				}
+			}
+		};
+		Bukkit.getPluginManager().registerEvents(this.listener, Main.getInstance());
+
+	}
+
+//    public ScoreBoardRender(Player p,Scoreboard sb){
+//        this(p,"&f&lKa&7&lr",sb);
+//    }
+	public ScoreBoardRender(Player p, String title) {
+		this(p, title, Bukkit.getScoreboardManager().getMainScoreboard() == p.getScoreboard() ? null : p.getScoreboard());
+	}
+
+	public ScoreBoardRender(Player p) {
+		this(p, "&f&lKa&7&lr");
+	}
+
+	private ScoreBoardRender() {
+		this(null);
+	}
+
+	private Scoreboard getBoard() {
+		return sb;
+	}
+
+	public Objective getObjective() {
+		return objective;
+	}
+
+	public String getTitle() {
+		return objective.getDisplayName();
+	}
+
+	public void setTitle(String title) {
+		objective.setDisplayName(title.replace("&", "§"));
+	}
+
+	public Player getPlayer() {
+		return this.player;
+	}
+
+	/**
+	 * 不管优先度，直接设置为该计分板(内部使用)
+	 *
+	 * @param sb
+	 */
+	public void setRended(CeramicScoreboard sb) {
+		if (this.rended != null) {
+			this.rended.setRending(false);
+		}
+		if (sb == null) {
+			throw new NullPointerException();
+		}
+		RendedChangeEvent e = new RendedChangeEvent(UserManager.getUser(player), this.rended, sb);
+		Bukkit.getPluginManager().callEvent(e);
+		sb.setRending(true);
+		this.rended = sb;
+		update();
+	}
+
+	public CeramicScoreboard getRended() {
+		return this.rended;
+	}
+
+	public void update() {
+		if (this.rended == null) {
+			return;
+		}
+		setTitle(this.rended.getTitle());
+		setBody(this.rended.getTexts());
+	}
+
+	public String getLine(int line) {
+		line = 16 - line;
+		final BoardLine boardLine = getBoardLine(line); //得到我们的"行"
+		Validate.notNull(boardLine, "Unable to find BoardLine with index of " + line + "."); //确认是否存在
+		return boardLine.getTeam().getPrefix() + boardLine.getTeam().getSuffix();
+	}
+
+	public void setLine(int line, String value) {
+		line = 16 - line;
+		value = value.replace("&&", "§§").replace("&", "§").replace("§§", "&");
+		final BoardLine boardLine = getBoardLine(line); //得到我们的"行"
+		Validate.notNull(boardLine, "Unable to find BoardLine with index of " + line + "."); //确认是否存在
+		objective.getScore(boardLine.getColor().toString()).setScore(line); //设置"行"
+//		clear(line);
+		//分割字符串为前16个和后16个及中间16个
+		String prefix;
+		String info = "";
+		String suffix = "";
+//		if (value.length() > 16) {
+//			suffix = value.substring(16);
+//			//处理前后的颜色
+//			String sufpre = ChatColor.getLastColors(prefix);
+//			if (value.charAt(15) == '§') {
+//				sufpre = "§";
+//			} else if (!suffix.isEmpty() && suffix.charAt(0) == '§') {
+//				sufpre = "";
+//			}
+//			String ssp = sufpre + suffix;
+//			suffix = ssp.substring(0, ssp.length());
+//		}
+//		if (value.length() > 16) {
+//			prefix = value.substring(0, 16);
+//			suffix = ChatColor.getLastColors(prefix) + value.substring(16, Math.min(32, value.length()));
+//		} else {
+//			prefix = value;
+//		}
+
+//		if(value.length() > 16){
+//			prefix = value.substring(0, 16);
+//			String prefixLastColor = ChatColor.getLastColors(prefix);
+//			if(prefix.charAt(15) == '§'){
+//				prefix = prefix.substring(0, 15);
+//			}
+//			value = value.substring(16);
+//			if(!prefixLastColor.equalsIgnoreCase("§f")){
+//				value = prefixLastColor + value;
+//			}
+//			if(value.length() > 16){
+//				info = value.substring(0, 16);
+//				String infoLastColor = ChatColor.getLastColors(info);
+//				if(info.charAt(15) == '§'){
+//					info = info.substring(0, 15);
+//				}
+//				value = value.substring(16);
+//				if(!infoLastColor.equalsIgnoreCase("§f")){
+//					value = infoLastColor + value;
+//				}
+//				suffix = value.substring(0,Math.min(16,value.length()));
+//			} else {
+//				info = (prefixLastColor.equalsIgnoreCase("§f") ? "" : prefixLastColor) + value;
+//			}
+//		} else {
+//			prefix = value;
+//		}
+
+		if (value.length() > 16) {
+			prefix = value.substring(0,16);
+			String prefixLastColor = ChatColor.getLastColors(prefix);
+			if(prefixLastColor.isEmpty()) prefixLastColor = "§f";
+			if(prefix.charAt(15) == '§'){
+				prefix = prefix.substring(0, 15);
+				value = "§"+value.substring(16);
+			} else {
+				value = prefixLastColor + value.substring(16);
+			}
+			suffix = value.substring(0,Math.min(16,value.length()));
+
+//			if(prefix.charAt(15) == '§'){
+//				prefix = prefix.substring(0,15);
+//				suffix = ChatColor.getLastColors(prefix) + "§" + value.substring(16);
+//			}else{
+//				suffix = ChatColor.getLastColors(prefix) + value.substring(16);
+//			}
+//			suffix = suffix.substring(0,Math.min(16,value.length()));
+		}else{
+			prefix = value;
+		}
+
+		boardLine.getTeam().setPrefix(prefix); //设置前16个字符
+//		boardLine.getTeam().setDisplayName(info);
+		boardLine.getTeam().setSuffix(suffix); //设置后16个字符
+//		for(String entry : boardLine.getTeam().getEntries()){
+//			boardLine.getTeam().removeEntry(entry);
+//		}
+//		boardLine.getTeam().removeEntry(boardLine.getTeam().getEntries().iterator().next());
+//		boardLine.getTeam().addEntry(info);
+//		objective.getScore(info).setScore(line);
+		maxLine = line + 1;
+	}
+
+	//all 5  [0 1 2 3 4] maxLine = 5  all 3 [0 1 2] maxLine=4
+	public void clear(int size) {
+		if (maxLine > size) {
+			for (int i = size; i < maxLine; i++) {
+				removeLine(i);
+			}
+			maxLine = size;
+		}
+	}
+
+	public void removeLine(int line) {
+		line = 16 - line;
+		final BoardLine boardLine = getBoardLine(line);
+		Validate.notNull(boardLine, "Unable to find BoardLine with index of " + line + "."); //确认是否存在
+		getBoard().resetScores(boardLine.getColor().toString()); //删除这个"行"
+	}
+
+	private BoardLine getBoardLine(int line) {
+		return boardLines.get(line);
+	}
+
+	public void setBody(List<String> newContents) {
+		for (int i = 0; i < newContents.size(); i++) {
+			setLine(newContents.size() - i, newContents.get(i));
+		}
+		clear(newContents.size());
+	}
+
+	class BoardLine {
+
+		private final ChatColor color;
+		private final Team team;
+
+		public BoardLine(ChatColor color, Team team) {
+			this.color = color;
+			this.team = team;
+		}
+
+		public ChatColor getColor() {
+			return color;
+		}
+
+		public Team getTeam() {
+			return team;
+		}
+
+	}
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/utils/scoreboard/ScoreboardAddEvent.java

@@ -0,0 +1,37 @@
+package org.cn2b2t.core.managers.utils.scoreboard;
+
+import org.cn2b2t.core.modules.users.User;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+public class ScoreboardAddEvent extends Event {
+    
+    private static final HandlerList handler = new HandlerList();
+    User user;
+    CeramicScoreboard sb;
+    
+    private ScoreboardAddEvent(){}
+    
+    public ScoreboardAddEvent(User user,CeramicScoreboard sb){
+        this.user = user;
+        this.sb = sb;
+    }
+    
+    public CeramicScoreboard getKarScoreboard(){
+        return this.sb;
+    }
+    
+    public User getUser(){
+        return this.user;
+    }
+    
+    @Override
+    public HandlerList getHandlers() {
+        return handler;
+    }
+    
+    public static HandlerList getHandlerList() {
+        return handler;
+    }
+    
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/utils/scoreboard/ScoreboardEnableEvent.java

@@ -0,0 +1,38 @@
+package org.cn2b2t.core.managers.utils.scoreboard;
+
+import org.cn2b2t.core.modules.users.User;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+public class ScoreboardEnableEvent extends Event {
+    
+    private static final HandlerList handler = new HandlerList();
+    
+    User user;
+    boolean b;
+    
+    private ScoreboardEnableEvent(){}
+    
+    public ScoreboardEnableEvent(User user,boolean b){
+        this.user = user;
+        this.b = b;
+    }
+    
+    public boolean getWhetherEnable(){
+        return this.b;
+    }
+    
+    public User getUser(){
+        return this.user;
+    }
+    
+    @Override
+    public HandlerList getHandlers() {
+        return handler;
+    }
+    
+    public static HandlerList getHandlerList() {
+        return handler;
+    }
+    
+}

2b2t-core/src/main/java/org.cn2b2t.core/managers/utils/scoreboard/TitleUpdateEvent.java

@@ -0,0 +1,63 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.cn2b2t.core.managers.utils.scoreboard;
+
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+/**
+ *
+ * @author LSeng
+ */
+public class TitleUpdateEvent extends Event {
+    
+    private static final HandlerList handler = new HandlerList();
+    CeramicScoreboard sb;
+    String old,New;
+    boolean cancelled = false;
+    
+    private TitleUpdateEvent(){}
+    
+    public TitleUpdateEvent(CeramicScoreboard sb,String old,String New){
+        this.sb = sb;
+        this.old = old;
+        this.New = New;
+    }
+    
+    public CeramicScoreboard getKarScoreboard(){
+        return this.sb;
+    }
+    
+    public String getOld(){
+        return this.old;
+    }
+    
+    public String getNew(){
+        return this.New;
+    }
+    
+    public void setNew(String New){
+        this.New = New;
+    }
+    
+    public void setCancelled(boolean b){
+        this.cancelled = b;
+    }
+    
+    public boolean isCancelled(){
+        return this.cancelled;
+    }
+    
+    @Override
+    public HandlerList getHandlers() {
+        return handler;
+    }
+    
+    public static HandlerList getHandlerList() {
+        return handler;
+    }
+    
+}

2b2t-core/src/main/java/org.cn2b2t.core/modules/gui/AutoPagedGUI.java

@@ -0,0 +1,92 @@
+package org.cn2b2t.core.modules.gui;
+
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.inventory.ItemStack;
+import org.cn2b2t.core.modules.users.User;
+import org.cn2b2t.core.utils.ItemStackFactory;
+
+public class AutoPagedGUI extends CommonPagedGUI {
+
+    ItemStack lastPageUI;
+    ItemStack nextPageUI;
+    ItemStack firstPageUI;
+    ItemStack endPageUI;
+    int lastPageSlot = -1;
+    int nextPageSlot = -1;
+
+    public AutoPagedGUI(GUIType type, String name, int[] range) {
+        super(type, name, range);
+    }
+
+    public AutoPagedGUI(GUIType type, String name, int a, int b) {
+        super(type, name, a, b);
+    }
+
+    public void setLastPageUI(ItemStack lastPageUI) {
+        this.lastPageUI = lastPageUI;
+    }
+
+    public void setNextPageUI(ItemStack nextPageUI) {
+        this.nextPageUI = nextPageUI;
+    }
+
+    public void setFirstPageUI(ItemStack firstPageUI) {
+        this.firstPageUI = firstPageUI;
+    }
+
+    public void setEndPageUI(ItemStack endPageUI) {
+        this.endPageUI = endPageUI;
+    }
+
+    public void setLastPageSlot(int slot) {
+        this.lastPageSlot = slot;
+    }
+
+    public void setNextPageSlot(int slot) {
+        this.nextPageSlot = slot;
+    }
+
+    @Override
+    public void openGUI(User user) {
+        if (lastPageSlot >= 0)
+            if (hasLastPage()) {
+                setItem(lastPageSlot, new GUIItem(lastPageUI == null ? new ItemStackFactory(Material.FENCE)
+                        .setDisplayName("上一页")
+                        .toItemStack() : lastPageUI) {
+                    @Override
+                    public void ClickAction(ClickType type, User u) {
+                        lastPage();
+                        openGUI(u);
+                        u.getPlayer().playSound(u.getPlayer().getLocation(), Sound.ENTITY_CHICKEN_EGG, 0.5f, 1);
+                    }
+                });
+            } else {
+                setItem(lastPageSlot, new GUIItem(firstPageUI == null ? new ItemStackFactory(Material.FENCE)
+                        .setDisplayName("已经是首页了")
+                        .toItemStack() : firstPageUI));
+            }
+
+        if (lastPageSlot >= 0)
+            if (hasNextPage()) {
+                setItem(nextPageSlot, new GUIItem(nextPageUI == null ? new ItemStackFactory(Material.COBBLE_WALL)
+                        .setDisplayName("下一页")
+                        .toItemStack() : nextPageUI) {
+                    @Override
+                    public void ClickAction(ClickType type, User u) {
+                        nextPage();
+                        openGUI(u);
+                        u.getPlayer().playSound(u.getPlayer().getLocation(), Sound.ENTITY_CHICKEN_EGG, 0.5f, 1);
+                    }
+                });
+            } else {
+                setItem(nextPageSlot, new GUIItem(endPageUI == null ? new ItemStackFactory(Material.COBBLE_WALL)
+                        .setDisplayName("已经是尾页了")
+                        .toItemStack() : endPageUI));
+            }
+
+        super.openGUI(user);
+    }
+
+}

2b2t-core/src/main/java/org.cn2b2t.core/modules/gui/CommonPagedGUI.java

@@ -0,0 +1,125 @@
+package org.cn2b2t.core.modules.gui;
+
+import org.cn2b2t.core.modules.users.User;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class CommonPagedGUI extends PagedGUI{
+
+	private int[] range;
+
+	int a;
+	int b;
+
+	int lineA;
+	int columnA;
+	int lineB;
+	int columnB;
+
+	private CommonPagedGUI(GUIType type, String name) {
+		super(type, name);
+	}
+
+	public CommonPagedGUI(GUIType type, String Name, int[] range) {
+		super(type, Name);
+		Arrays.sort(range);
+		this.range = range;
+
+	}
+
+	public CommonPagedGUI(GUIType type, String Name, int a, int b) {
+		super(type, Name);
+		this.a = a;
+		this.b = b;
+		toRange(a,b);
+	}
+	
+	/*
+	int[] matrix = new int[]{
+	0,	1,	2,	3,	4,	5,	6,	7,	8,
+	9,	10,	11,	12,	13,	14,	15,	16,	17,
+	18,	19,	20,	21,	22,	23,	24,	25,	26,
+	27,	28,	29,	30,	31,	32,	33,	34,	35,
+	36,	37,	38,	39,	40,	41,	42,	43,	44,
+	45,	46,	47,	48,	49,	50,	51,	52,	53
+	}
+	*/
+	
+	private void toRange(int a, int b) {
+		if (a > b) {
+			a = a ^ b;b = a ^ b;a = a ^ b;
+		}
+
+		lineA = getLine(a);
+		columnA = getColumn(a);
+		lineB = getLine(b);
+		columnB = getColumn(b);
+
+		if(lineB>this.items.length/9)
+			throw new IndexOutOfBoundsException("页面内容范围超过了GUI的大小");
+
+		int[] range = new int[(lineB-lineA+1)*(columnB-columnA+1)];
+
+		for(int i=0,l=0;i<this.items.length;i++){
+			int li = getLine(i);
+			int ci = getColumn(i);
+			if(li>=lineA && li<=lineB && ci>=columnA && ci<=columnB){
+				range[l] = i;
+				l++;
+			}
+		}
+
+		this.range = range;
+	}
+
+	int getLine(int i){
+		return i/9+1;
+	}
+	
+	int getColumn(int i){
+		return i%9+1;
+	}
+
+	@Override
+	public boolean hasLastPage() {
+		return page > 1;
+	}
+
+	@Override
+	public boolean hasNextPage() {
+		return page <= this.container.size() / range.length;
+	}
+
+	@Override
+	public void openGUI(User user){
+		if(container.isEmpty()){
+			super.openGUI(user);
+			return;
+		}
+		List<GUIItem> list = new ArrayList();
+		int start = (page-1)*range.length;
+		for(int i=start;i<start+range.length;i++){
+			if(i<container.size()){
+				list.add(container.get(i));
+			}else{
+				break;
+			}
+		}
+		int i = 0;
+		for(int index : range){
+			setItem(index,null);
+		}
+		for(int index : range){
+			if(i<list.size()){
+				setItem(index, list.get(i));
+				i++;
+			}else{
+				break;
+			}
+		}
+		super.openGUI(user);
+	}
+	
+}

2b2t-core/src/main/java/org.cn2b2t.core/modules/gui/GUI.java

@@ -0,0 +1,332 @@
+package org.cn2b2t.core.modules.gui;
+
+import org.cn2b2t.core.Main;
+import org.cn2b2t.core.modules.users.User;
+import org.cn2b2t.core.managers.utils.UserManager;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.entity.HumanEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.inventory.InventoryCloseEvent;
+import org.bukkit.event.inventory.InventoryDragEvent;
+import org.bukkit.event.inventory.InventoryType;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class GUI {
+
+	GUIType type;
+	String name;
+	public GUIItem[] items;
+	public Inventory inv;
+
+	boolean setCancelledIfClickOnTarget = true;
+	boolean setCancelledIfClickOnSelf = true;
+	boolean setCancelledIfClickOnOuter = true;
+
+	Map<String,Object> flags;
+
+	Listener listener;
+
+	public GUI(GUIType type, String name) {
+		this.type = type;
+		this.name = name;
+		switch (type) {
+			case ONEBYNINE:
+				this.items = new GUIItem[9];
+				break;
+			case TWOBYNINE:
+				this.items = new GUIItem[18];
+				break;
+			case THREEBYNINE:
+				this.items = new GUIItem[27];
+				break;
+			case FOURBYNINE:
+				this.items = new GUIItem[36];
+				break;
+			case FIVEBYNINE:
+				this.items = new GUIItem[45];
+				break;
+			default:
+			case SIXBYNINE:
+				this.items = new GUIItem[54];
+				break;
+
+			case HOPPER:
+				this.items = new GUIItem[InventoryType.HOPPER.getDefaultSize()];
+				break;
+			case BEACON:
+				this.items = new GUIItem[InventoryType.BEACON.getDefaultSize()];
+				break;
+			case DISPENSER:
+				this.items = new GUIItem[InventoryType.DISPENSER.getDefaultSize()];
+				break;
+			case DROPPER:
+				this.items = new GUIItem[InventoryType.DROPPER.getDefaultSize()];
+				break;
+			case FURNACE:
+				this.items = new GUIItem[InventoryType.FURNACE.getDefaultSize()];
+				break;
+			case WORKBENCH:
+				this.items = new GUIItem[InventoryType.WORKBENCH.getDefaultSize()];
+				break;
+			case CRAFTING:
+				this.items = new GUIItem[InventoryType.CRAFTING.getDefaultSize()];
+				break;
+			case ENCHANTING:
+				this.items = new GUIItem[InventoryType.ENCHANTING.getDefaultSize()];
+				break;
+			case BREWING:
+				this.items = new GUIItem[InventoryType.BREWING.getDefaultSize()];
+				break;
+			case PLAYER:
+				this.items = new GUIItem[InventoryType.PLAYER.getDefaultSize()];
+				break;
+			case MERCHANT:
+				this.items = new GUIItem[InventoryType.MERCHANT.getDefaultSize()];
+				break;
+			case ENDER_CHEST:
+				this.items = new GUIItem[InventoryType.ENDER_CHEST.getDefaultSize()];
+				break;
+
+			case CREATIVE:
+				this.items = new GUIItem[InventoryType.CREATIVE.getDefaultSize()];
+				break;
+			case CANCEL:
+				this.items = null;
+		}
+	}
+
+	public final void setItem(int index, GUIItem item) {
+		if (item == null) {
+			this.items[index] = new GUIItem(new ItemStack(0));
+		} else {
+			this.items[index] = item;
+		}
+	}
+
+	/**
+	 * 批量添加GUI Item
+	 *
+	 * @param item
+	 * @param index
+	 */
+	public void setItem(GUIItem item, int... index) {
+		for (int i : index) {
+			setItem(i, item);
+		}
+	}
+
+	public GUIItem getItem(int index) {
+		return this.items[index];
+	}
+
+	public void updateView(){
+		if(this.inv != null){
+			List<HumanEntity> viewers = this.inv.getViewers();
+			for (int index = 0; index < this.items.length; index++) {
+				if (items[index] == null) {
+					inv.setItem(index, new ItemStack(Material.AIR));
+				} else {
+					inv.setItem(index, items[index].display);
+				}
+			}
+			for(HumanEntity p : viewers){
+				((Player)p).updateInventory();
+			}
+		}
+	}
+
+	public void setCancelledIfClickOnTarget(boolean b){
+		this.setCancelledIfClickOnTarget = b;
+	}
+
+	public void setCancelledIfClickOnSelf(boolean b){
+		this.setCancelledIfClickOnSelf = b;
+	}
+
+	public void setCancelledIfClickOnOuter(boolean b){
+		this.setCancelledIfClickOnOuter = b;
+	}
+
+	public void addFlag(String flag,Object obj){
+		if(this.flags == null) this.flags = new HashMap<>();
+		this.flags.put(flag,obj);
+	}
+
+	public Object getFlag(String flag){
+		if(this.flags == null) return null;
+		else
+			return this.flags.get(flag);
+	}
+
+	public void setFlag(String flag, Object obj){
+		if(this.flags == null) this.flags = new HashMap<>();
+		this.flags.replace(flag,obj);
+	}
+
+	public void removeFlag(String flag){
+		if(this.flags == null) this.flags = new HashMap<>();
+		this.flags.remove(flag);
+	}
+
+	public void rawClickListener(InventoryClickEvent event){}
+
+	public void openGUI(User user) {
+		Inventory inv;
+		if (this.type == GUIType.CANCEL) {
+			throw new NullPointerException("被取消或不存在的GUI");
+		}
+		switch (type) {
+			default:
+			case ONEBYNINE:
+			case TWOBYNINE:
+			case THREEBYNINE:
+			case FOURBYNINE:
+			case FIVEBYNINE:
+			case SIXBYNINE:
+				inv = Bukkit.createInventory(null, this.items.length, this.name);
+				break;
+			case HOPPER:
+				inv = Bukkit.createInventory(null, InventoryType.HOPPER, name);
+				break;
+			case BEACON:
+				inv = Bukkit.createInventory(null, InventoryType.BEACON, name);
+				break;
+			case DISPENSER:
+				inv = Bukkit.createInventory(null, InventoryType.DISPENSER, name);
+				break;
+			case DROPPER:
+				inv = Bukkit.createInventory(null, InventoryType.DROPPER, name);
+				break;
+			case FURNACE:
+				inv = Bukkit.createInventory(null, InventoryType.FURNACE, name);
+				break;
+			case WORKBENCH:
+				inv = Bukkit.createInventory(null, InventoryType.WORKBENCH, name);
+				break;
+			case CRAFTING:
+				inv = Bukkit.createInventory(null, InventoryType.CRAFTING, name);
+				break;
+			case ENCHANTING:
+				inv = Bukkit.createInventory(null, InventoryType.ENCHANTING, name);
+				break;
+			case BREWING:
+				inv = Bukkit.createInventory(null, InventoryType.BREWING, name);
+				break;
+			case PLAYER:
+				inv = Bukkit.createInventory(null, InventoryType.PLAYER, name);
+				break;
+			case CREATIVE:
+				inv = Bukkit.createInventory(null, InventoryType.CREATIVE, name);
+				break;
+			case MERCHANT:
+				inv = Bukkit.createInventory(null, InventoryType.MERCHANT, name);
+				break;
+			case ENDER_CHEST:
+				inv = Bukkit.createInventory(null, InventoryType.ENDER_CHEST, name);
+				break;
+		}
+		
+		for (int index = 0; index < this.items.length; index++) {
+			if (items[index] == null) {
+				inv.setItem(index, new ItemStack(Material.AIR));
+			} else {
+				inv.setItem(index, items[index].display);
+			}
+		}
+		user.openedGUI = this;
+		this.inv = inv;
+//		user.getPlayer().closeInventory();
+		user.getPlayer().openInventory(inv);
+
+		if(listener == null)
+		Bukkit.getPluginManager().registerEvents(listener = new Listener() {
+			@EventHandler
+			public void onInventoryClickEvent(InventoryClickEvent event) {
+				rawClickListener(event);
+				if (!(event.getWhoClicked() instanceof Player)) {
+					return;
+				}
+				Player p = (Player) event.getWhoClicked();
+				User user = UserManager.getUser(p);
+				if (event.getSlot() != -999){
+					try {
+						if (user.openedGUI == GUI.this && event.getClickedInventory() != null && event.getClickedInventory().equals(GUI.this.inv) && GUI.this.items[event.getSlot()] != null)
+							GUI.this.items[event.getSlot()].realRawClickAction(event);
+					}catch (ArrayIndexOutOfBoundsException e){
+						e.printStackTrace();
+						System.err.print("err cause by GUI("+GUI.this.toString()+"), name="+ name);
+						return;
+					}
+				}else {
+					if(setCancelledIfClickOnOuter)event.setCancelled(true);
+				}
+				if (user.openedGUI != null && /*user.openedGUI.inv.equals(event.getClickedInventory())*/ user.openedGUI == GUI.this && event.getClickedInventory() != null) {
+					if(event.getClickedInventory().equals(GUI.this.inv)) {
+						if(setCancelledIfClickOnTarget)event.setCancelled(true);
+
+						if (event.getSlot() != -999 && GUI.this.items[event.getSlot()] != null) {
+							if (GUI.this.items[event.getSlot()].isActionActive()) {
+								GUI.this.items[event.getSlot()].onClick(event.getClick());
+								GUI.this.items[event.getSlot()].ClickAction(event.getClick(), user);
+								GUI.this.items[event.getSlot()].rawClickAction(event);
+								if (!GUI.this.items[event.getSlot()].actions.isEmpty()) {
+									for (GUIItem.GUIClickAction action : GUI.this.items[event.getSlot()].actions) {
+										action.run(event.getClick(), user);
+									}
+								}
+							}
+							if (!GUI.this.items[event.getSlot()].actionsIngoreActive.isEmpty()) {
+								for (GUIItem.GUIClickAction action : GUI.this.items[event.getSlot()].actionsIngoreActive) {
+									action.run(event.getClick(), user);
+								}
+							}
+						}
+					}else if(event.getClickedInventory().equals(p.getInventory())){
+						if(setCancelledIfClickOnSelf)event.setCancelled(true);
+					}
+				}
+			}
+
+			@EventHandler
+			public void onDrag(InventoryDragEvent e){
+				if (e.getWhoClicked() instanceof Player) {
+					Player p = (Player) e.getWhoClicked();
+					if(e.getInventory().equals(inv) || e.getInventory().equals(p.getInventory())){
+						GUI.this.onDrag(e);
+					}
+				}
+			}
+
+			@EventHandler
+			public void onInventoryCloseEvent(InventoryCloseEvent event) {
+				if (event.getPlayer() instanceof Player && event.getInventory().equals(inv)) {
+					Player p = (Player) event.getPlayer();
+					User u = UserManager.getUser(p);
+					if (event.getInventory().equals(inv)) {
+						HandlerList.unregisterAll(this);
+						listener = null;
+						onClose();
+					}
+				}
+			}
+		}, Main.getInstance());
+
+	}
+
+	public void onDrag(InventoryDragEvent e){
+	}
+
+	public void onClose(){
+	}
+	
+}

2b2t-core/src/main/java/org.cn2b2t.core/modules/gui/GUIItem.java

@@ -0,0 +1,80 @@
+package org.cn2b2t.core.modules.gui;
+
+import org.cn2b2t.core.modules.users.User;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class GUIItem {
+
+	ItemStack display;
+	boolean actionActive = true;
+
+	public Set<GUIClickAction> actions = new HashSet<>();
+	public Set<GUIClickAction> actionsIngoreActive = new HashSet<>();
+
+	public GUIItem(ItemStack display) {
+		this.display = display;
+	}
+
+	public final ItemStack getDisplay() {
+		return this.display;
+	}
+
+	public final void setDisplay(ItemStack display) {
+		this.display = display;
+	}
+
+	public final boolean isActionActive(){
+		return this.actionActive;
+	}
+
+	public final void setActionActive(boolean b){
+		actionActive = b;
+	}
+
+	@Deprecated
+	public void ClickAction(ClickType type, User u) {
+
+	}
+
+	public void onClick(ClickType type){
+
+	}
+
+	public void addClickAction(GUIClickAction action){
+		actions.add(action);
+	}
+
+	public void addActionIgnoreActive(GUIClickAction action){
+		actionsIngoreActive.add(action);
+	}
+
+	public void customAction() {
+
+	}
+
+	public void rawClickAction(InventoryClickEvent event) {
+
+	}
+
+	public void realRawClickAction(InventoryClickEvent event) {
+
+	}
+
+	public void customAction(Object obj) {
+
+	}
+
+	public void customAction(User user) {
+
+	}
+
+	public abstract static class GUIClickAction{
+		public abstract void run(ClickType type, User u);
+	}
+
+}

2b2t-core/src/main/java/org.cn2b2t.core/modules/gui/GUIType.java

@@ -0,0 +1,31 @@
+package org.cn2b2t.core.modules.gui;
+
+/**
+ *
+ * @author LSeng
+ */
+public enum GUIType {
+
+	ONEBYNINE,
+	TWOBYNINE,
+	THREEBYNINE,
+	FOURBYNINE,
+	FIVEBYNINE,
+	SIXBYNINE,
+	DISPENSER,
+	DROPPER,
+	FURNACE,
+	WORKBENCH,
+	CRAFTING,
+	ENCHANTING,
+	BREWING,
+	PLAYER,
+	CREATIVE,
+	MERCHANT,
+	ENDER_CHEST,
+	BEACON,
+	HOPPER,
+	UNKNOWN,
+	CANCEL;
+
+}

2b2t-core/src/main/java/org.cn2b2t.core/modules/gui/PagedGUI.java

@@ -0,0 +1,50 @@
+package org.cn2b2t.core.modules.gui;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public abstract class PagedGUI extends GUI{
+	
+	List<GUIItem> container = new ArrayList();
+	public int page = 1;
+	
+	public PagedGUI(GUIType type, String name) {
+		super(type, name);
+	}
+	
+	public int add(GUIItem i){
+		container.add(i);
+		return container.size()-1;
+	}
+	
+	public void remove(GUIItem i){
+		container.remove(i);
+	}
+	
+	public void remove(int i){
+		container.remove(i);
+	}
+
+	public List<GUIItem> getContainer() {
+		return new ArrayList(container);
+	}
+	
+	public void lastPage(){
+		if(hasLastPage())
+			page--;
+		else
+			throw new IndexOutOfBoundsException();
+	}
+	
+	public void nextPage(){
+		if(hasNextPage())
+			page++;
+		else
+			throw new IndexOutOfBoundsException();
+	}
+	
+	public abstract boolean hasLastPage();
+	
+	public abstract boolean hasNextPage();
+	
+}

2b2t-core/src/main/java/org.cn2b2t.core/modules/gui/RollingPagedGUI.java

@@ -0,0 +1,119 @@
+package org.cn2b2t.core.modules.gui;
+
+
+import org.cn2b2t.core.modules.users.User;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class RollingPagedGUI extends PagedGUI {
+
+    private int[] range;
+
+    int a;
+    int b;
+
+    int lineA;
+    int columnA;
+    int lineB;
+    int columnB;
+
+    private RollingPagedGUI(GUIType type, String Name) {
+        super(type, Name);
+    }
+
+    public RollingPagedGUI(GUIType type, String Name, int a, int b) {
+        super(type, Name);
+        this.a = a;
+        this.b = b;
+        toRange(a, b);
+
+    }
+	
+	/*
+	int[] matrix = new int[]{
+	0,	1,	2,	3,	4,	5,	6,	7,	8,
+	9,	10,	11,	12,	13,	14,	15,	16,	17,
+	18,	19,	20,	21,	22,	23,	24,	25,	26,
+	27,	28,	29,	30,	31,	32,	33,	34,	35,
+	36,	37,	38,	39,	40,	41,	42,	43,	44,
+	45,	46,	47,	48,	49,	50,	51,	52,	53
+	}
+	*/
+
+    private void toRange(int a, int b) {
+        if (a > b) {
+            a = a ^ b;
+            b = a ^ b;
+            a = a ^ b;
+        }
+
+        lineA = getLine(a);
+        columnA = getColumn(a);
+        lineB = getLine(b);
+        columnB = getColumn(b);
+
+        if (lineB > this.items.length / 9)
+            throw new IndexOutOfBoundsException("页面内容范围超过了GUI的大小");
+
+        int[] range = new int[(lineB - lineA + 1) * (columnB - columnA + 1)];
+
+        for (int i = 0, l = 0; i < this.items.length; i++) {
+            int li = getLine(i);
+            int ci = getColumn(i);
+            if (li >= lineA && li <= lineB && ci >= columnA && ci <= columnB) {
+                range[l] = i;
+                l++;
+            }
+        }
+
+        this.range = range;
+    }
+
+    int getLine(int i) {
+        return i / 9 + 1;
+    }
+
+    int getColumn(int i) {
+        return i % 9 + 1;
+    }
+
+    @Override
+    public boolean hasLastPage() {
+        return page > 1;
+    }
+
+    @Override
+    public boolean hasNextPage() {
+        return page < this.container.size() / range.length;
+    }
+
+    @Override
+    public void openGUI(User user) {
+        if (container.isEmpty()) {
+            super.openGUI(user);
+            return;
+        }
+        List<GUIItem> list = new ArrayList<>();
+        int lineLength = lineB - lineA + 1;
+        int start = (page - 1) * lineLength;
+        for (int i = start; i < start + range.length; i++) {
+            if (i < container.size()) {
+                list.add(container.get(i));
+            } else {
+                break;
+            }
+        }
+        int i = 0;
+        for (int index : range) {
+            if (i < list.size()) {
+                setItem(index, list.get(i));
+                i++;
+            } else {
+                break;
+            }
+        }
+        super.openGUI(user);
+    }
+
+}

2b2t-core/src/main/java/org.cn2b2t.core/modules/users/AbstractUserHandler.java

@@ -0,0 +1,36 @@
+package org.cn2b2t.core.modules.users;
+
+import org.cn2b2t.core.events.UserHandlerLoadedEvent;
+import org.cn2b2t.core.managers.utils.UserManager;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.bukkit.scheduler.BukkitRunnable;
+
+public abstract class AbstractUserHandler {
+
+    protected User user;
+
+    protected AbstractUserHandler() {
+    }
+
+    public final User getUser() {
+        return this.user;
+    }
+
+    protected void init() {
+    }
+
+    protected void onDisable() {
+    }
+
+    public void callLoadedEvent(JavaPlugin main) {
+        new BukkitRunnable() {
+            @Override
+            public void run() {
+                Bukkit.getPluginManager().callEvent(new UserHandlerLoadedEvent(AbstractUserHandler.this));
+            }
+        }.runTask(main);
+    }
+
+}

2b2t-core/src/main/java/org.cn2b2t.core/modules/users/User.java

@@ -0,0 +1,221 @@
+package org.cn2b2t.core.modules.users;
+
+import org.cn2b2t.core.Main;
+import org.cn2b2t.core.events.UserLoadedEvent;
+import org.cn2b2t.core.managers.utils.UserManager;
+import org.cn2b2t.core.managers.utils.scoreboard.CeramicScoreboard;
+import org.cn2b2t.core.managers.utils.scoreboard.ScoreBoardRender;
+import org.cn2b2t.core.modules.gui.GUI;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitRunnable;
+import org.spigotmc.AsyncCatcher;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+public class User {
+
+    private final Player player;
+
+    private Map<String, Object> handler = new HashMap<>();
+
+    public GUI openedGUI;
+
+    ScoreBoardRender sbRender;
+    List<CeramicScoreboard> scoreboards = new ArrayList<>();
+
+
+    public boolean fullLoaded;
+
+    public User(Player player) {
+        this.player = player;
+
+        new BukkitRunnable() {
+            @Override
+            public void run() {
+
+                UserManager.getHandlers().forEach((key, value) -> registerHandler(key, value));
+
+                UserManager.getHandlerClasses().forEach((key, value) -> {
+                    try {
+                        registerHandler(value);
+                    } catch (Exception ex) {
+                        Logger.getLogger(User.class.getName()).log(Level.SEVERE, null, ex);
+                    }
+                });
+
+
+                new BukkitRunnable() {
+                    @Override
+                    public void run() {
+                        fullLoaded = true;
+                        new BukkitRunnable() {
+                            @Override
+                            public void run() {
+                                sbRender = new ScoreBoardRender(player);
+                            }
+                        }.runTaskLater(Main.getInstance(), 1L);
+                        Bukkit.getPluginManager().callEvent(new UserLoadedEvent(User.this));
+                    }
+                }.runTask(Main.getInstance());
+
+
+                cancel();
+            }
+        }.runTaskAsynchronously(Main.getInstance());
+    }
+
+
+
+    public List<CeramicScoreboard> getScoreboards() {
+        return this.scoreboards;
+    }
+
+    public Player getPlayer() {
+        return player;
+    }
+
+    public void unregister() {
+        //此操作疑似会重复运行onDisable();
+//		for (Map.Entry<String, Object> e : UserManager.handlers.entrySet()) {
+//			if(AbstractUserHandler.class.isAssignableFrom(e.getValue().getClass()))
+//				((AbstractUserHandler) (e.getValue())).onDisable();
+//		}
+        this.openedGUI = null;
+        this.handler.clear();
+        this.handler = null;
+        this.scoreboards.clear();
+        this.scoreboards = null;
+        this.sbRender = null;
+        UserManager.unregisterUser(this.getPlayer());
+    }
+
+    public <T extends AbstractUserHandler> T getHandler(Class<T> c) {
+        if (isUnregistered()) {
+            AsyncCatcher.catchOp("handler get when user unloaded");
+        }
+        int position = c.getName().lastIndexOf('.');
+        String name = c.getName().substring(position + 1);
+        if (containsHandler(name)) {
+            return (T) handler.get(name);
+        } else {
+            throw new NullPointerException("Handler " + name + " in User " + getPlayer().getName() + " wasn't found.");
+        }
+    }
+
+    public Object getHandler(String s) {
+        if (isUnregistered()) {
+            AsyncCatcher.catchOp("handler get when user unloaded");
+        }
+        if (containsHandler(s)) {
+            return handler.get(s);
+        } else {
+            throw new NullPointerException("Handler " + s + " in User " + getPlayer().getName() + " wasn't found.");
+        }
+    }
+
+    public <T> T getHandler(String s, Class T) {
+        if (isUnregistered()) {
+            AsyncCatcher.catchOp("handler get when user unloaded");
+        }
+        if (containsHandler(s)) {
+            return (T) handler.get(s);
+        } else {
+            throw new NullPointerException("Handler " + s + " in User " + getPlayer().getName() + " wasn't found.");
+        }
+    }
+
+    public boolean containsHandler(String s) {
+        return handler.containsKey(s);
+    }
+
+    public boolean containsHandler(Class<? extends AbstractUserHandler> c) {
+        int position = c.getName().lastIndexOf('.');
+        return handler.containsKey(c.getName().substring(position + 1));
+    }
+
+    public void registerHandler(Class<? extends AbstractUserHandler> c) {
+        if (isUnregistered()) {
+            throw new IllegalStateException("register Handler when user unloaded");
+        }
+        if (containsHandler(c)) {
+            throw new RuntimeException("Handler " + c.getName() + " in User " + getPlayer().getName() + " is existed.");
+        } else {
+            try {
+                AbstractUserHandler h = c.newInstance();
+                h.user = this;
+                h.init();
+                int position = c.getName().lastIndexOf('.');
+                this.handler.put(c.getName().substring(position + 1), h);
+            } catch (InstantiationException | IllegalAccessException ex) {
+                Logger.getLogger(User.class.getName()).log(Level.SEVERE, null, ex);
+            }
+        }
+    }
+
+    public void registerHandler(String name, Object o) {
+        if (isUnregistered()) {
+            throw new IllegalStateException("register Handler when user unloaded");
+        }
+        if (containsHandler(name)) {
+            throw new RuntimeException("Handler " + name + " in User " + getPlayer().getName() + " is existed.");
+        } else {
+            this.handler.put(name, o);
+        }
+    }
+
+    public void removeHandler(String name) {
+        if (!containsHandler(name)) {
+            throw new RuntimeException("Handler " + name + " in User " + getPlayer().getName() + " wasn't existed.");
+        } else {
+            Object h = this.handler.get(name);
+            if (h instanceof AbstractUserHandler) {
+                AbstractUserHandler absh = (AbstractUserHandler) h;
+                absh.onDisable();
+            }
+            this.handler.remove(name);
+        }
+    }
+
+    public void removeHandler(Class<? extends AbstractUserHandler> c) {
+        if (!containsHandler(c)) {
+            throw new RuntimeException("Handler " + c.getName() + " in User " + getPlayer().getName() + " wasn't existed.");
+        } else {
+            int position = c.getName().lastIndexOf('.');
+            String name = c.getName().substring(position + 1);
+            Object h = this.handler.get(name);
+            if (h instanceof AbstractUserHandler) {
+                AbstractUserHandler absh = (AbstractUserHandler) h;
+                absh.onDisable();
+            }
+            this.handler.remove(name);
+        }
+    }
+
+    public ScoreBoardRender getSbRender() {
+        return sbRender;
+    }
+
+    public void addScoreboard(CeramicScoreboard sb) {
+        this.scoreboards.add(sb);
+    }
+
+    public void replaceHandler(String name, Object o) {
+        if (!containsHandler(name)) {
+            throw new RuntimeException("Handler " + name + " in User " + getPlayer().getName() + " was existed.");
+        } else {
+            this.handler.replace(name, o);
+        }
+    }
+
+    public boolean isUnregistered() {
+        return !UserManager.getRegisteredUsers().contains(this);
+    }
+
+
+}

2b2t-core/src/main/java/org.cn2b2t.core/utils/BBCodeChatParser.java

@@ -0,0 +1,425 @@
+package org.cn2b2t.core.utils;
+
+import net.md_5.bungee.api.ChatColor;
+import net.md_5.bungee.api.chat.BaseComponent;
+import net.md_5.bungee.api.chat.ClickEvent;
+import net.md_5.bungee.api.chat.HoverEvent;
+import net.md_5.bungee.api.chat.TextComponent;
+import org.bukkit.Bukkit;
+
+import java.util.Deque;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class BBCodeChatParser {
+
+	private static final Pattern pattern;
+	private static final Pattern strip_bbcode_pattern;
+//	private final Logger logger;
+
+//	public BBCodeChatParser(final Logger logger) {
+//		this.logger = logger;
+//	}
+//
+//	public BBCodeChatParser() {
+//		this(Logger.getLogger(BBCodeChatParser.class.getName()));
+//	}
+
+	static {
+		pattern = Pattern.compile("(?is)(?=\\n)|(?:[&§](?<color>[0-9A-FK-OR]))|(?:\\[(?<tag>/?(?:b|i|u|s|nocolor|nobbcode)|(?:url|command|hover|suggest|color)=(?<value>(?:(?:[^]\\[]*)\\[(?:[^]\\[]*)\\])*(?:[^]\\[]*))|/(?:url|command|hover|suggest|color))\\])|(?:\\[(?<implicitTag>url|command|suggest)\\](?=(?<implicitValue>.*?)\\[/\\k<implicitTag>\\]))");
+		strip_bbcode_pattern = Pattern.compile("(?is)(?:\\[(?<tag>/?(?:b|i|u|s|nocolor|nobbcode)|(?:url|command|hover|suggest|color)=(?<value>(?:(?:[^]\\[]*)\\[(?:[^]\\[]*)\\])*(?:[^]\\[]*))|/(?:url|command|hover|suggest|color))\\])|(?:\\[(?<implicitTag>url|command|suggest)\\](?=(?<implicitValue>.*?)\\[/\\k<implicitTag>\\]))");
+	}
+
+//	public static BaseComponent[] parseChatColor(BaseComponent[] bcs){
+//		List<BaseComponent> list = new LinkedList();
+//		
+//		ChatColor lastColor = ChatColor.GRAY;
+//		boolean lastBold = false;
+//		boolean lastItalic = false;
+//		boolean lastObfuscated = false;
+//		boolean lastUnderlined = false;
+//		boolean lastStrikethrough = false;
+//		for(BaseComponent bc : bcs){
+//			if(bc instanceof TextComponent){
+//				TextComponent tc = (TextComponent)bc;
+//				String raw = tc.getText();
+//				System.out.print("raw: "+raw);
+//				if(raw.contains("§")){
+//					TextComponent tce = new TextComponent();
+//					while(raw.contains("§")){
+//						if(!raw.startsWith("§")){
+//							tce.setText(raw.substring(0,raw.indexOf('§')));
+//							raw = raw.substring(raw.indexOf('§'));
+//						}
+//						if(raw.length()-1>raw.indexOf('§')){
+//							char c = Character.toLowerCase(raw.charAt(raw.indexOf('§')+1));
+//							if ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f')) {
+//								if (!tce.getText().isEmpty()) {
+//									tce.setColor(lastColor);
+//									tce.setBold(lastBold);
+//									tce.setItalic(lastItalic);
+//									tce.setObfuscated(lastObfuscated);
+//									tce.setUnderlined(lastUnderlined);
+//									tce.setStrikethrough(lastStrikethrough);
+//									if(bc.getHoverEvent()!=null){
+//										tce.setHoverEvent(bc.getHoverEvent());
+//									}
+//									if(bc.getClickEvent()!=null){
+//										tce.setClickEvent(bc.getClickEvent());
+//									}
+//									list.add(tce.duplicate());
+//									tce = new TextComponent();
+//									System.out.print("动作: 输出1");
+//								}
+//								lastColor = ChatColor.getByChar(c);
+//								lastBold = lastItalic = lastObfuscated = lastUnderlined = lastStrikethrough = false;
+//								raw = raw.substring(2, raw.length()-1);
+//								System.out.print("动作: 染色");
+//							}else if(c == 'm'){
+//								lastStrikethrough = true;
+//								raw = raw.substring(2, raw.length()-1);
+//								System.out.print("动作: 划掉");
+//							}else if(c == 'n'){
+//								lastUnderlined = true;
+//								raw = raw.substring(2, raw.length()-1);
+//								System.out.print("动作: 下划线");
+//							}else if(c == 'o'){
+//								lastItalic = true;
+//								raw = raw.substring(2, raw.length()-1);
+//								System.out.print("动作: 斜体");
+//							}else if(c == 'l'){
+//								lastBold = true;
+//								raw = raw.substring(2, raw.length()-1);
+//								System.out.print("动作: 加粗");
+//							}else if(c == 'k'){
+//								lastObfuscated = true;
+//								raw = raw.substring(2, raw.length()-1);
+//								System.out.print("动作: 混乱");
+//							}else if(c == 'r'){
+//								lastColor = ChatColor.RESET;
+//								System.out.print("动作: 重设");
+//							}
+//						}else{
+//							raw = raw.substring(0, raw.length()-1);
+//						}
+//						if(!tce.getText().isEmpty()){
+//							tce.setColor(lastColor);
+//							tce.setBold(lastBold);
+//							tce.setItalic(lastItalic);
+//							tce.setObfuscated(lastObfuscated);
+//							tce.setUnderlined(lastUnderlined);
+//							tce.setStrikethrough(lastStrikethrough);
+//							if(bc.getHoverEvent()!=null){
+//								tce.setHoverEvent(bc.getHoverEvent());
+//							}
+//							if(bc.getClickEvent()!=null){
+//								tce.setClickEvent(bc.getClickEvent());
+//							}
+//							list.add((BaseComponent)tce.duplicate());
+//							tce = new TextComponent();
+//							System.out.print("动作: 输出2");
+//						}
+//					}
+//					if(!raw.isEmpty()){
+//						tce.setText(raw);
+//						tce.setColor(lastColor);
+//						tce.setBold(lastBold);
+//						tce.setItalic(lastItalic);
+//						tce.setObfuscated(lastObfuscated);
+//						tce.setUnderlined(lastUnderlined);
+//						tce.setStrikethrough(lastStrikethrough);
+//						if(bc.getHoverEvent()!=null){
+//							tce.setHoverEvent(bc.getHoverEvent());
+//						}
+//						if(bc.getClickEvent()!=null){
+//							tce.setClickEvent(bc.getClickEvent());
+//						}
+//						list.add((BaseComponent)tce.duplicate());
+//						System.out.print("动作: 输出3");
+//					}
+//				}else{
+//					bc.setColor(lastColor);
+//					bc.setBold(lastBold);
+//					bc.setItalic(lastItalic);
+//					bc.setObfuscated(lastObfuscated);
+//					bc.setUnderlined(lastUnderlined);
+//					bc.setStrikethrough(lastStrikethrough);
+//					list.add(bc);
+//					System.out.print("动作: 输出4");
+//				}
+//			}else{
+//				bc.setColor(lastColor);
+//				bc.setBold(lastBold);
+//				bc.setItalic(lastItalic);
+//				bc.setObfuscated(lastObfuscated);
+//				bc.setUnderlined(lastUnderlined);
+//				bc.setStrikethrough(lastStrikethrough);
+//				list.add(bc);
+//				System.out.print("动作: 输出5");
+//			}
+//		}
+//		
+//		return list.toArray(new BaseComponent[list.size()]);
+//	}
+
+	public static BaseComponent[] parse(final String text) {
+		final Matcher matcher = BBCodeChatParser.pattern.matcher(text);
+		TextComponent current = new TextComponent();
+		final List<BaseComponent> components = new LinkedList<>();
+		int forceBold = 0;
+		int forceItalic = 0;
+		int forceUnderlined = 0;
+		int forceStrikethrough = 0;
+		int nocolorLevel = 0;
+		int nobbcodeLevel = 0;
+		final Deque<ChatColor> colorDeque = new LinkedList<>();
+		final Deque<ClickEvent> clickEventDeque = new LinkedList<>();
+		final Deque<HoverEvent> hoverEventDeque = new LinkedList<>();
+		while (matcher.find()) {
+			boolean parsed = false;
+			final StringBuffer stringBuffer = new StringBuffer();
+			matcher.appendReplacement(stringBuffer, "");
+			final TextComponent component = new TextComponent(current);
+			current.setText(stringBuffer.toString());
+			components.add(current);
+			current = component;
+			final String group_color = matcher.group("color");
+			final String group_tag = matcher.group("tag");
+			String group_value = matcher.group("value");
+			final String group_implicitTag = matcher.group("implicitTag");
+			final String group_implicitValue = matcher.group("implicitValue");
+			if (group_color != null && nocolorLevel <= 0) {
+				ChatColor color = ChatColor.getByChar(group_color.charAt(0));
+				if (color != null) {
+					Label_0458:
+					{
+						switch (color) {
+							case MAGIC: {
+								current.setObfuscated(true);
+								break Label_0458;
+							}
+							case BOLD: {
+								current.setBold(true);
+								break Label_0458;
+							}
+							case STRIKETHROUGH: {
+								current.setStrikethrough(true);
+								break Label_0458;
+							}
+							case UNDERLINE: {
+								current.setUnderlined(true);
+								break Label_0458;
+							}
+							case ITALIC: {
+								current.setItalic(true);
+								break Label_0458;
+							}
+							case RESET: {
+								color = ChatColor.WHITE;
+								break;
+							}
+						}
+						current = new TextComponent();
+						current.setColor(color);
+						current.setBold(forceBold > 0);
+						current.setItalic(forceItalic > 0);
+						current.setUnderlined(forceUnderlined > 0);
+						current.setStrikethrough(forceStrikethrough > 0);
+						if (!colorDeque.isEmpty()) {
+							current.setColor(colorDeque.peek());
+						}
+						if (!clickEventDeque.isEmpty()) {
+							current.setClickEvent(clickEventDeque.peek());
+						}
+						if (!hoverEventDeque.isEmpty()) {
+							current.setHoverEvent(hoverEventDeque.peek());
+						}
+					}
+					parsed = true;
+				}
+			}
+			if (group_tag != null && nobbcodeLevel <= 0) {
+				if (group_tag.matches("(?is)^b$")) {
+					current.setBold(++forceBold > 0);
+					parsed = true;
+				} else if (group_tag.matches("(?is)^/b$")) {
+					current.setBold(--forceBold > 0);
+					parsed = true;
+				}
+				if (group_tag.matches("(?is)^i$")) {
+					current.setItalic(++forceItalic > 0);
+					parsed = true;
+				} else if (group_tag.matches("(?is)^/i$")) {
+					current.setItalic(--forceItalic > 0);
+					parsed = true;
+				}
+				if (group_tag.matches("(?is)^u$")) {
+					current.setUnderlined(++forceUnderlined > 0);
+					parsed = true;
+				} else if (group_tag.matches("(?is)^/u$")) {
+					current.setUnderlined(--forceUnderlined > 0);
+					parsed = true;
+				}
+				if (group_tag.matches("(?is)^s$")) {
+					current.setStrikethrough(++forceStrikethrough > 0);
+					parsed = true;
+				} else if (group_tag.matches("(?is)^/s$")) {
+					current.setStrikethrough(--forceStrikethrough > 0);
+					parsed = true;
+				}
+				if (group_tag.matches("(?is)^color=.*$")) {
+					ChatColor color = null;
+					for (final ChatColor color2 : ChatColor.values()) {
+						if (color2.getName().equalsIgnoreCase(group_value)) {
+							color = color2;
+						}
+					}
+					colorDeque.push(current.getColor());
+					if (color != null && color != ChatColor.BOLD && color != ChatColor.ITALIC && color != ChatColor.MAGIC && color != ChatColor.RESET && color != ChatColor.STRIKETHROUGH && color != ChatColor.UNDERLINE) {
+						colorDeque.push(color);
+						current.setColor(color);
+					} else {
+						Bukkit.getLogger().log(Level.WARNING, "Invalid color tag: [{0}] UNKNOWN COLOR ''{1}''", new Object[]{group_tag, group_value});
+						colorDeque.push(ChatColor.WHITE);
+						current.setColor(ChatColor.WHITE);
+					}
+					parsed = true;
+				} else if (group_tag.matches("(?is)^/color$")) {
+					if (!colorDeque.isEmpty()) {
+						colorDeque.pop();
+						current.setColor(colorDeque.pop());
+					}
+					parsed = true;
+				}
+				if (group_tag.matches("(?is)^url=.*$")) {
+					String url = group_value;
+					url = url.replaceAll("(?is)\\[/?nobbcode\\]", "");
+					if (!url.startsWith("http")) {
+						url = "http://" + url;
+					}
+					final ClickEvent clickEvent = new ClickEvent(ClickEvent.Action.OPEN_URL, url);
+					clickEventDeque.push(clickEvent);
+					current.setClickEvent(clickEvent);
+					parsed = true;
+				}
+				if (group_tag.matches("(?is)^/(?:url|command|suggest)$")) {
+					if (!clickEventDeque.isEmpty()) {
+						clickEventDeque.pop();
+					}
+					if (clickEventDeque.isEmpty()) {
+						current.setClickEvent(null);
+					} else {
+						current.setClickEvent(clickEventDeque.peek());
+					}
+					parsed = true;
+				}
+				if (group_tag.matches("(?is)^command=.*")) {
+					group_value = group_value.replaceAll("(?is)\\[/?nobbcode\\]", "");
+					final ClickEvent clickEvent2 = new ClickEvent(ClickEvent.Action.RUN_COMMAND, group_value);
+					clickEventDeque.push(clickEvent2);
+					current.setClickEvent(clickEvent2);
+					parsed = true;
+				}
+				if (group_tag.matches("(?is)^suggest=.*")) {
+					group_value = group_value.replaceAll("(?is)\\[/?nobbcode\\]", "");
+					final ClickEvent clickEvent2 = new ClickEvent(ClickEvent.Action.SUGGEST_COMMAND, group_value);
+					clickEventDeque.push(clickEvent2);
+					current.setClickEvent(clickEvent2);
+					parsed = true;
+				}
+				if (group_tag.matches("(?is)^hover=.*$")) {
+					BaseComponent[] components2 = parse(group_value);
+					if (!hoverEventDeque.isEmpty()) {
+						final BaseComponent[] components3 = hoverEventDeque.getLast().getValue();
+						final BaseComponent[] components4 = new BaseComponent[components2.length + components3.length + 1];
+						int i = 0;
+						for (final BaseComponent baseComponent : components3) {
+							components4[i++] = baseComponent;
+						}
+						components4[i++] = new TextComponent("\n");
+						for (final BaseComponent baseComponent : components2) {
+							components4[i++] = baseComponent;
+						}
+						components2 = components4;
+					}
+					final HoverEvent hoverEvent = new HoverEvent(HoverEvent.Action.SHOW_TEXT, components2);
+					hoverEventDeque.push(hoverEvent);
+					current.setHoverEvent(hoverEvent);
+					parsed = true;
+				} else if (group_tag.matches("(?is)^/hover$")) {
+					if (!hoverEventDeque.isEmpty()) {
+						hoverEventDeque.pop();
+					}
+					if (hoverEventDeque.isEmpty()) {
+						current.setHoverEvent(null);
+					} else {
+						current.setHoverEvent(hoverEventDeque.peek());
+					}
+					parsed = true;
+				}
+			}
+			if (group_implicitTag != null && nobbcodeLevel <= 0) {
+				if (group_implicitTag.matches("(?is)^url$")) {
+					String url = group_implicitValue;
+					if (!url.startsWith("http")) {
+						url = "http://" + url;
+					}
+					final ClickEvent clickEvent = new ClickEvent(ClickEvent.Action.OPEN_URL, url);
+					clickEventDeque.push(clickEvent);
+					current.setClickEvent(clickEvent);
+					parsed = true;
+				}
+				if (group_implicitTag.matches("(?is)^command$")) {
+					final ClickEvent clickEvent2 = new ClickEvent(ClickEvent.Action.RUN_COMMAND, group_implicitValue);
+					clickEventDeque.push(clickEvent2);
+					current.setClickEvent(clickEvent2);
+					parsed = true;
+				}
+				if (group_implicitTag.matches("(?is)^suggest$")) {
+					final ClickEvent clickEvent2 = new ClickEvent(ClickEvent.Action.SUGGEST_COMMAND, group_implicitValue);
+					clickEventDeque.push(clickEvent2);
+					current.setClickEvent(clickEvent2);
+					parsed = true;
+				}
+			}
+			if (group_tag != null) {
+				if (group_tag.matches("(?is)^nocolor$")) {
+					++nocolorLevel;
+					parsed = true;
+				}
+				if (group_tag.matches("(?is)^/nocolor$")) {
+					--nocolorLevel;
+					parsed = true;
+				}
+				if (group_tag.matches("(?is)^nobbcode$")) {
+					++nobbcodeLevel;
+					parsed = true;
+				}
+				if (group_tag.matches("(?is)^/nobbcode$")) {
+					--nobbcodeLevel;
+					parsed = true;
+				}
+			}
+			if (!parsed) {
+				final TextComponent component2 = new TextComponent(current);
+				current.setText(matcher.group(0));
+				components.add(current);
+				current = component2;
+			}
+		}
+		final StringBuffer stringBuffer2 = new StringBuffer();
+		matcher.appendTail(stringBuffer2);
+		current.setText(stringBuffer2.toString());
+		components.add(current);
+		return components.toArray(new BaseComponent[components.size()]);
+//		return parseChatColor(components.toArray(new BaseComponent[components.size()]));
+	}
+
+	public static String stripBBCode(final String string) {
+		return strip_bbcode_pattern.matcher(string).replaceAll("");
+	}
+
+}

2b2t-core/src/main/java/org.cn2b2t.core/utils/ColorParser.java

@@ -0,0 +1,9 @@
+package org.cn2b2t.core.utils;
+
+public class ColorParser {
+
+	public static String parse(final String text) {
+		return text.replaceAll("&", "§").replace("§§", "&");
+	}
+
+}

2b2t-core/src/main/java/org.cn2b2t.core/utils/ItemStackFactory.java

@@ -0,0 +1,144 @@
+package org.cn2b2t.core.utils;
+
+import org.bukkit.Material;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.inventory.ItemFlag;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.inventory.meta.SkullMeta;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ItemStackFactory {
+
+	ItemStack item;
+
+	private ItemStackFactory() {
+	}
+
+	public ItemStackFactory(ItemStack is) {
+		this.item = is.clone();
+	}
+
+	public ItemStackFactory(int type) {
+		this(Material.getMaterial(type), 1);
+	}
+
+	public ItemStackFactory(Material type) {
+		this(type, 1);
+	}
+
+	public ItemStackFactory(Material type, int amount) {
+		this(type, amount, (short) 0);
+	}
+
+	public ItemStackFactory(int type, int amount) {
+		this(Material.getMaterial(type), amount, (short) 0);
+	}
+
+	public ItemStackFactory(Material type, int amount, short data) {
+		this.item = new ItemStack(type, amount, data);
+	}
+
+	public ItemStackFactory(int type, int amount, short data) {
+		this.item = new ItemStack(type, amount, data);
+	}
+
+	public ItemStackFactory(int type, int amount, int data) {
+		this(type, amount, (short) data);
+	}
+
+	public ItemStackFactory(Material type, int amount, int data) {
+		this(type, amount, (short) data);
+	}
+
+	public ItemStack toItemStack() {
+		return this.item;
+	}
+
+	public ItemStackFactory setType(Material type) {
+		this.item.setType(type);
+		return this;
+	}
+
+	public ItemStackFactory setDurability(int i) {
+		this.item.setDurability((short) i);
+		return this;
+	}
+
+	public ItemStackFactory setAmount(int a) {
+		this.item.setAmount(a);
+		return this;
+	}
+
+	public ItemStackFactory setDisplayName(String name) {
+		ItemMeta im = this.item.getItemMeta();
+		im.setDisplayName(name.replace("&", "§").replace("§§", "&&"));
+		this.item.setItemMeta(im);
+		return this;
+	}
+
+	public ItemStackFactory setLore(List<String> lores) {
+		ItemMeta im = this.item.getItemMeta();
+		List<String> lores_ = new ArrayList();
+		lores.stream().forEach((lore) -> {
+			lores_.add(lore.replace("&", "§").replace("§§", "&&"));
+		});
+		im.setLore(lores_);
+		this.item.setItemMeta(im);
+		return this;
+	}
+
+	public ItemStackFactory addLore(String name) {
+		ItemMeta im = this.item.getItemMeta();
+		List<String> lores;
+		if (im.hasLore()) {
+			lores = im.getLore();
+		} else {
+			lores = new ArrayList<>();
+		}
+		lores.add(name.replace("&", "§").replace("§§", "&&"));
+		im.setLore(lores);
+		this.item.setItemMeta(im);
+		return this;
+	}
+
+	public ItemStackFactory addEnchant(Enchantment ench, int level, boolean ignoreLevelRestriction) {
+		ItemMeta im = this.item.getItemMeta();
+		im.addEnchant(ench, level, ignoreLevelRestriction);
+		this.item.setItemMeta(im);
+		return this;
+	}
+
+	public ItemStackFactory removeEnchant(Enchantment ench) {
+		ItemMeta im = this.item.getItemMeta();
+		im.removeEnchant(ench);
+		this.item.setItemMeta(im);
+		return this;
+	}
+
+	public ItemStackFactory addFlag(ItemFlag flag) {
+		ItemMeta im = this.item.getItemMeta();
+		im.addItemFlags(flag);
+		this.item.setItemMeta(im);
+		return this;
+	}
+
+	public ItemStackFactory removeFlag(ItemFlag flag) {
+		ItemMeta im = this.item.getItemMeta();
+		im.removeItemFlags(flag);
+		this.item.setItemMeta(im);
+		return this;
+	}
+
+	public ItemStackFactory setSkullOwner(String name) {
+		if (this.item.getType() == Material.SKULL_ITEM || this.item.getType() == Material.SKULL) {
+			SkullMeta im = (SkullMeta) this.item.getItemMeta();
+			im.setOwner(name);
+			this.item.setItemMeta(im);
+		}
+		return this;
+	}
+
+}

2b2t-core/src/main/java/org.cn2b2t.core/utils/TimeFormater.java

@@ -0,0 +1,44 @@
+package org.cn2b2t.core.utils;
+
+public class TimeFormater {
+
+	public static String timeLeft(long t) {
+		long left = t - System.currentTimeMillis();
+		if (left < 0) {
+			return "已过期";
+		} else if (left < 3600000) {
+			return "小于1时";
+		}
+		StringBuilder sb = new StringBuilder();
+		if (left > 31536000000L) {
+			sb.append(left / 31536000000L).append("年");
+			left %= 31536000000L;
+		}
+		if (left > 2592000000L) {
+			sb.append(left / 2592000000L).append("月");
+			left %= 2592000000L;
+		}
+		if (left > 86400000L) {
+			sb.append(left / 86400000L).append("天");
+			left %= 86400000L;
+		}
+		if (left > 3600000) {
+			sb.append(left / 3600000).append("时");
+		}
+		return sb.toString();
+	}
+
+	public static String getTime(long t) {
+		StringBuilder sb = new StringBuilder();
+		t /= 1000;
+		if (t > 3600) {
+			sb.append(t / 3600).append("h");
+		}
+		if (t > 60) {
+			sb.append(t % 3600 / 60).append("min");
+		}
+		sb.append(t % 60).append("s");
+		return sb.toString();
+	}
+
+}

2b2t-core/src/main/resources/config.yml

@@ -0,0 +1,7 @@
+
+Database:
+  host: 127.0.0.1
+  port: 3306
+  data: moci
+  user: moci
+  password: moci

2b2t-core/src/main/resources/plugin.yml

@@ -0,0 +1,14 @@
+main: org.cn2b2t.core.Main
+name: 2b2t-core
+version: 1.0-SNAPSHOT
+softdepend:
+  - Vault
+  - PlayerPoints
+  - ProtocolLib
+authors:
+  - Moci
+  - KarGames
+  - cn2b2t
+commands:
+  kar:
+    description: Developer Team.