readed some stuff cause ist mised.

Core.iml

@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module org.jetbrains.idea.maven.project.MavenProjectsManager.isMavenModule="true" type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" LANGUAGE_LEVEL="JDK_1_8" inherit-compiler-output="false">
+    <output url="file://$MODULE_DIR$/target/classes" />
+    <output-test url="file://$MODULE_DIR$/target/test-classes" />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src/main/java" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/src/main/resources" type="java-resource" />
+      <sourceFolder url="file://$MODULE_DIR$/src/test/java" isTestSource="true" />
+      <excludeFolder url="file://$MODULE_DIR$/src/test/java" />
+      <excludeFolder url="file://$MODULE_DIR$/target" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" name="spigot-1.9" level="project" />
+    <orderEntry type="library" name="Maven: org.mongodb:mongo-java-driver:3.2.2" level="project" />
+    <orderEntry type="library" name="Maven: org.mongodb:mongodb-driver-async:3.2.2" level="project" />
+    <orderEntry type="library" name="Maven: org.mongodb:mongodb-driver-core:3.2.2" level="project" />
+    <orderEntry type="library" name="Maven: org.mongodb:bson:3.2.2" level="project" />
+    <orderEntry type="library" name="Maven: io.netty:netty-all:4.0.31.Final" level="project" />
+    <orderEntry type="library" name="Maven: org.projectlombok:lombok:1.16.8" level="project" />
+    <orderEntry type="library" name="Maven: org.bukkit:craftbukkit:1.9-R0.1-SNAPSHOT" level="project" />
+    <orderEntry type="library" scope="PROVIDED" name="Maven: org.bukkit:bukkit:1.9-R0.1-SNAPSHOT" level="project" />
+    <orderEntry type="library" scope="PROVIDED" name="Maven: commons-lang:commons-lang:2.6" level="project" />
+    <orderEntry type="library" scope="PROVIDED" name="Maven: com.googlecode.json-simple:json-simple:1.1.1" level="project" />
+    <orderEntry type="library" scope="PROVIDED" name="Maven: junit:junit:4.10" level="project" />
+    <orderEntry type="library" scope="PROVIDED" name="Maven: org.hamcrest:hamcrest-core:1.1" level="project" />
+    <orderEntry type="library" scope="PROVIDED" name="Maven: com.google.guava:guava:17.0" level="project" />
+    <orderEntry type="library" scope="PROVIDED" name="Maven: com.google.code.gson:gson:2.2.4" level="project" />
+    <orderEntry type="library" scope="PROVIDED" name="Maven: org.avaje:ebean:2.8.1" level="project" />
+    <orderEntry type="library" scope="PROVIDED" name="Maven: javax.persistence:persistence-api:1.0" level="project" />
+    <orderEntry type="library" scope="PROVIDED" name="Maven: org.yaml:snakeyaml:1.15" level="project" />
+    <orderEntry type="library" scope="PROVIDED" name="Maven: org.spigotmc:spigot-api:1.9-R0.1-SNAPSHOT" level="project" />
+    <orderEntry type="library" scope="PROVIDED" name="Maven: net.md-5:bungeecord-chat:1.9-SNAPSHOT" level="project" />
+  </component>
+</module>

src/main/java/eu/univento/cloud/client/CloudClient.java

@@ -0,0 +1,33 @@
+package eu.univento.cloud.client;
+
+import io.netty.bootstrap.Bootstrap;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelInitializer;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.nio.NioSocketChannel;
+
+/**
+ * @author joethei
+ * @version 0.1
+ */
+public class CloudClient {
+
+public CloudClient() throws Exception{
+    NioEventLoopGroup child = new NioEventLoopGroup();
+    try{
+        Bootstrap bootstrap = new Bootstrap();
+        bootstrap.channel(NioSocketChannel.class);
+        bootstrap.group(child);
+        bootstrap.handler(new ChannelInitializer<Channel>() {
+            @Override
+            protected void initChannel(Channel channel) throws Exception {
+
+            }
+        });
+        bootstrap.connect("master.univento.eu", 8000).sync().channel().closeFuture().sync();
+    }finally {
+        child.shutdownGracefully();
+    }
+}
+
+}

src/main/java/eu/univento/core/Core.java

@@ -0,0 +1,135 @@
+package eu.univento.core;
+
+import eu.univento.core.api.Blackscreen;
+import eu.univento.core.api.Config;
+import eu.univento.core.api.database.MongoDB;
+import eu.univento.core.api.database.MySQL;
+import eu.univento.core.api.events.MoveEventFilter;
+import eu.univento.core.api.player.CustomPlayer;
+import eu.univento.core.api.server.ServerSettings;
+import eu.univento.core.commands.*;
+import eu.univento.core.listeners.*;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.PluginManager;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.io.IOException;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * main class
+ * @author joethei
+ * @version 1.0
+ */
+public class Core extends JavaPlugin{
+
+	//TODO: rewrite time critical database functions from MySQL to MongoDB
+	
+	/**
+	 * plugin instance
+	 */
+	public static Core instance;
+	/**
+	 * @return plugin instance
+	 */
+	public static Core getInstance() {
+		return instance;
+	}
+	
+	/**
+	 * mysql stuff
+	 */
+	private static MySQL sql = new MySQL(getInstance(),  Config.readString("MySQL.Host"), Config.readString("MySQL.Port"), Config.readString("MySQL.DB"), Config.readString("MySQL.User"),  Config.readString("MySQL.Pass"));
+	/**
+	 * @return sql
+	 */
+	public static MySQL returnSQL() {
+		return sql;
+	}
+
+    private static MongoDB mongoDB;
+    public static MongoDB getMongoDB() {
+        return mongoDB;
+    }
+
+	/**
+	 * logging and stuff
+	 */
+	private static Logger log = Bukkit.getLogger();
+
+    public static ArrayList<CustomPlayer> getOnlinePlayers() {
+        ArrayList<CustomPlayer> list = new ArrayList<>();
+        for(Player players : Bukkit.getOnlinePlayers()) {
+            CustomPlayer p = CustomPlayer.getPlayer(players);
+            list.add(p);
+        }
+        return list;
+    }
+
+	/**
+	 * @param level Log level
+	 * @param string String
+	 */
+	public static void log(Level level, String string) {
+		if(ServerSettings.isDebug()) {
+            log.log(level, "[univento Core] " + string);
+        }
+	}
+
+	@Override
+	public void onEnable() {
+		ServerSettings.setDebug(true);
+		try {
+			Config.writeDefault();
+		} catch (ClassNotFoundException | SQLException | IOException e) {
+			e.printStackTrace();
+		}
+		instance = this;
+		log(Level.INFO, "activated debug mode");
+		PluginManager pm = Bukkit.getPluginManager();
+		pm.registerEvents(new Commands(), this);
+		pm.registerEvents(new JoinQuit(), this);
+		pm.registerEvents(new Chat(), this);
+		pm.registerEvents(new Events(), this);
+		pm.registerEvents(new MoveEventFilter(getServer()), this);
+
+		if(ServerSettings.isGame()) {
+            new Fix(this, "fix", "fix");
+            new Stats(this, "stats", "statistics");
+            new Nick(this, "nick", "nick");
+        }else{
+            new Build(this, "build", "build", "b");
+            pm.registerEvents(new Blocks(), this);
+        }
+
+		new RunAs(this, "RunAs", "runas");
+		new SystemInfo(this, "SystemInfo", "systeminfo");
+		new Vanish(this, "vanish", "vanish");
+		new GameMode(this, "gamemode" , "gamemode", "gm");
+		new SetRank(this, "setrank" , "setrank", "sr");
+		new GlobalMute(this, "globalmute", "globalmute");
+		new TS(this, "ts", "ts");
+		new Ban(this, "ban", "ban");
+        new ChatClear(this, "chatclear", "chatclear", "cc");
+		
+		log(Level.INFO, "registered all commands");
+		
+	    Bukkit.getMessenger().registerOutgoingPluginChannel(this, "BungeeCord");
+
+        Blackscreen.setupUtil(getInstance());
+        //mongoDB = new MongoDB(Config.readString("MongoDB.Host"), Config.readInt("MongoDB.Port"), Config.readString("MongoDB.Username"), Config.readString("MongoDB.Password"), Config.readString("MongoDB.Database"));
+
+
+        log(Level.INFO, "Plugin ver. " + getDescription().getVersion() +  " started");
+	}
+	
+	@Override
+	public void onDisable() {
+		log(Level.INFO, "Plugin stoped");
+	}
+
+}

src/main/java/eu/univento/core/api/Actionbar.java

@@ -0,0 +1,18 @@
+package eu.univento.core.api;
+
+import net.minecraft.server.v1_9_R1.IChatBaseComponent;
+import net.minecraft.server.v1_9_R1.IChatBaseComponent.ChatSerializer;
+import net.minecraft.server.v1_9_R1.PacketPlayOutChat;
+import org.bukkit.craftbukkit.v1_9_R1.entity.CraftPlayer;
+import org.bukkit.entity.Player;
+
+public class Actionbar {
+	
+    public static void send(Player player, String message){
+        CraftPlayer p = (CraftPlayer) player;
+        IChatBaseComponent cbc = ChatSerializer.a("{\"text\": \"" + message + "\"}");
+        PacketPlayOutChat ppoc = new PacketPlayOutChat(cbc,(byte) 2);
+        p.getHandle().playerConnection.sendPacket(ppoc);
+    }
+
+}

src/main/java/eu/univento/core/api/AutoCommand.java

@@ -0,0 +1,77 @@
+package eu.univento.core.api;
+
+import eu.univento.core.Core;
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandMap;
+import org.bukkit.command.CommandSender;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Level;
+
+/**
+ * @author PostCrafter
+ * @see href http://postcrafter.de/viewtopic.php?f=15&t=143
+ * @param <P> main class
+ */
+public abstract class AutoCommand<P extends JavaPlugin> extends Command {
+	
+	private static String VERSION;
+
+	static {
+		String path = Bukkit.getServer().getClass().getPackage().getName();
+		AutoCommand.VERSION = path.substring(path.lastIndexOf(".") + 1, path.length());
+		Core.log(Level.INFO, "AutoCommand hook for Bukkit " + AutoCommand.VERSION);
+	}
+
+	protected final P plugin;
+	protected final String command;
+
+	public AutoCommand(P plugin, String command, String description, String... aliases) {
+		super(command);
+		this.plugin = plugin;
+		this.command = command;
+
+		super.setDescription(description);
+		List<String> aliasList = new ArrayList<>();
+		for (String alias : aliases) {
+			aliasList.add(alias);
+		}
+		super.setAliases(aliasList);
+		this.register();
+	}
+
+	private void register() {
+		try {
+			Field f = Class.forName("org.bukkit.craftbukkit." + AutoCommand.VERSION + ".CraftServer").getDeclaredField("commandMap");
+			f.setAccessible(true);
+
+			CommandMap map = (CommandMap) f.get(Bukkit.getServer());
+			map.register(this.plugin.getName(), this);
+		} catch (Exception exc) {
+			exc.printStackTrace();
+		}
+	}
+
+	public abstract boolean execute(CommandSender sender, String label, String[] args);
+
+	public abstract List<String> tabComplete(CommandSender sender, String label, String[] args);
+
+	public String buildString(String[] args, int start) {
+		String str = "";
+		if (args.length > start) {
+			str += args[start];
+			for (int i = start + 1; i < args.length; i++) {
+				str += " " + args[i];
+			}
+		}
+		return str;
+	}
+
+	public P getPlugin() {
+		return this.plugin;
+	}
+}

src/main/java/eu/univento/core/api/Blackscreen.java

@@ -0,0 +1,80 @@
+package eu.univento.core.api;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * 
+ * @author janhektor
+ *
+ */
+public class Blackscreen {
+  private static Object packetObject;
+  private static Class<?> packetClass;
+  private static String VERSION;
+  private static Map<UUID, Integer> ticksLeft = new HashMap<UUID, Integer>();
+
+  static { String path = Bukkit.getServer().getClass().getPackage().getName();
+    VERSION = path.substring(path.lastIndexOf(".") + 1, path.length());
+    try {
+      packetClass = Class.forName("net.minecraft.server." + VERSION + ".Packet");
+      Class<?> packetGameStateClass = Class.forName("net.minecraft.server." + VERSION + ".PacketPlayOutGameStateChange");
+      packetObject = packetGameStateClass.getConstructor(new Class[] { Integer.TYPE, Float.TYPE }).newInstance(new Object[] { Integer.valueOf(4), Integer.valueOf(0) });
+    } catch (Exception ex) {
+      ex.printStackTrace();
+    }
+  }
+
+  public static void setupUtil(Plugin instance)
+  {
+    setupUtil(instance, 2);
+  }
+
+  public static void setupUtil(Plugin instance, int repeatingTicks)
+  {
+    Bukkit.getScheduler().runTaskTimer(instance, () -> {
+      for (UUID uuid : Blackscreen.ticksLeft.keySet()) {
+        Player p = Bukkit.getPlayer(uuid);
+        if (p == null) {
+          Blackscreen.ticksLeft.remove(uuid);
+        }
+        else if (((Integer)Blackscreen.ticksLeft.get(uuid)).intValue() > 0) {
+          Blackscreen.ticksLeft.put(uuid, Integer.valueOf((Blackscreen.ticksLeft.get(uuid)).intValue() - 2));
+          Blackscreen.access(p);
+        } else {
+          Blackscreen.ticksLeft.remove(uuid);
+        }
+      }
+    }
+            , 0L, repeatingTicks);
+  }
+
+  protected static void access(Player p) {
+	
+}
+
+private static void sendPacket(Player p) {
+    try {
+      Object nmsPlayer = p.getClass().getMethod("getHandle", new Class[0]).invoke(p, new Object[0]);
+      Field playerConnectionField = nmsPlayer.getClass().getField("playerConnection");
+      Object pConnection = playerConnectionField.get(nmsPlayer);
+      Method sendPacket = pConnection.getClass().getMethod("sendPacket", new Class[] { packetClass });
+      sendPacket.invoke(pConnection, new Object[] { packetObject });
+    } catch (Exception ex) {
+      ex.printStackTrace();
+    }
+  }
+
+  public static void setBlack(Player p, int seconds)
+  {
+    ticksLeft.put(p.getUniqueId(), Integer.valueOf(seconds * 20));
+    sendPacket(p);
+  }
+}

src/main/java/eu/univento/core/api/Config.java

@@ -0,0 +1,171 @@
+package eu.univento.core.api;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+
+import java.io.File;
+import java.io.IOException;
+import java.sql.SQLException;
+
+/**
+ * gets data from config file
+ * @author joethei
+ * @version 1.1
+ */
+public class Config {
+	
+	/**config file*/
+	private static File file = new File("plugins/Core", "config.yml");
+	/**load configuration */
+	private static FileConfiguration cfg = YamlConfiguration.loadConfiguration(file);
+	
+	/**
+	 * write default data to config
+	 * @throws ClassNotFoundException Class couldn't be found
+	 * @throws SQLException SQL server not available or throwing error
+	 * @throws IOException I/O failed
+	 */
+	public static void writeDefault() throws ClassNotFoundException, SQLException, IOException {
+		//editable messages will be set here, but do not edit this messages.
+		
+		//seting the default MySQL config.
+		cfg.addDefault("MySQL.Host", "192.168.0.101");
+		cfg.addDefault("MySQL.Port", "3306");
+		cfg.addDefault("MySQL.DB", "core");
+		cfg.addDefault("MySQL.User", "root");//best user name
+		cfg.addDefault("MySQL.Pass", "");//best password
+		cfg.addDefault("TS.IP", "ts.univento.eu");
+		cfg.addDefault("TS.QueryPort", 0);
+		cfg.addDefault("TS.QueryUser", "ServerQuery");
+		cfg.addDefault("TS.QueryPass", "password");
+		
+		cfg.options().copyDefaults(true);
+		cfg.save(file);
+		
+		}
+		
+	/**
+	 * write data as string to config
+	 * @param path path to data
+	 * @param obj data
+	 */
+	public static void write(String path, String obj) {
+		cfg.set(path, obj);
+		try {
+			cfg.save(file);
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	/**
+	 * write data as integer to config
+	 * @param path path to data
+	 * @param obj data
+	 */
+	public static void write(String path, int obj) {
+		cfg.set(path, obj);
+		try {
+			cfg.save(file);
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	/**
+	 * write data as double to config
+	 * @param path path to data
+	 * @param obj data
+	 */
+	public static void write(String path, double obj) {
+		cfg.set(path, obj);
+		try {
+			cfg.save(file);
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	
+	/**
+	 * write location to config
+	 * @param path path to data
+	 * @param loc location
+	 */
+	public static void write(String path, Location loc) {
+		String world = loc.getWorld().getName();
+		double x = loc.getX();
+		double y = loc.getY();
+		double z = loc.getZ();
+		double yaw = (double) loc.getYaw();
+		double pitch = (double) loc.getPitch();
+		
+		cfg.set(path + ".World", world);
+		cfg.set(path + ".X", x);
+		cfg.set(path + ".Y", y);
+		cfg.set(path + ".Z", z);
+		cfg.set(path + ".Yaw", yaw);
+		cfg.set(path + ".Pitch", pitch);
+		
+		try {
+			cfg.save(file);
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	/**
+	 * read integer from config
+	 * @param path path to data
+	 * @return Integer
+	 */
+	public static int readInt(String path) {
+		return cfg.getInt(path);
+	}
+	
+	/**
+	 * read double from config
+	 * @param path path to data
+	 * @return Double
+	 */
+	public static double readDouble(String path) {
+		return cfg.getDouble(path);
+	}
+	
+	/**
+	 * read string from config
+	 * @param path path to data
+	 * @return String
+	 */
+	public static String readString(String path) {
+		return cfg.getString(path);
+	}
+	
+	/**
+	 * read location from config
+	 * @param path path to data
+	 * @return Location
+	 */
+	public static Location readLocation(String path) {
+		String world = cfg.getString(path + ".World");
+		double x = cfg.getDouble(path + ".X");
+		double y = cfg.getDouble(path + ".Y");
+		double z = cfg.getDouble(path + ".Z");
+		float yaw = (float) cfg.getDouble(path + ".Yaw");
+		float pitch = (float) cfg.getDouble(path + ".Pitch");
+		
+		return new Location(Bukkit.getWorld(world), x, y, z, yaw, pitch);
+	}
+	
+	/**
+	 * checks if data is existing
+	 * @param path path do data
+	 * @return true / false
+	 */
+	public static boolean isExsisting(String path) {
+		return cfg.contains(path);
+	}
+
+}

src/main/java/eu/univento/core/api/Hologram.java

@@ -0,0 +1,93 @@
+package eu.univento.core.api;
+
+import eu.univento.core.Core;
+import net.minecraft.server.v1_9_R1.EntityArmorStand;
+import net.minecraft.server.v1_9_R1.PacketPlayOutEntityDestroy;
+import net.minecraft.server.v1_9_R1.PacketPlayOutSpawnEntityLiving;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.craftbukkit.v1_9_R1.CraftWorld;
+import org.bukkit.craftbukkit.v1_9_R1.entity.CraftPlayer;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Hologram {
+
+    private List<EntityArmorStand> entitylist = new ArrayList<>();
+    private String[] Text;
+    private Location location;
+    double DISTANCE = 0.25D;
+    int count;
+
+    public Hologram(String[] Text, Location location) {
+        this.Text = Text;
+        this.location = location;
+        create();
+    }
+
+
+    public void showPlayerTemp(final Player p,int Time){
+        showPlayer(p);
+        Bukkit.getScheduler().runTaskLater(Core.getInstance(), () -> hidePlayer(p), Time);
+    }
+
+
+    public void showAllTemp(final Player p,int Time){
+        showAll();
+        Bukkit.getScheduler().runTaskLater(Core.getInstance(), () -> hideAll(), Time);
+    }
+
+    public void showPlayer(Player p) {
+        for (EntityArmorStand armor : entitylist) {
+            PacketPlayOutSpawnEntityLiving packet = new PacketPlayOutSpawnEntityLiving(armor);
+            ((CraftPlayer) p).getHandle().playerConnection.sendPacket(packet);
+        }
+    }
+
+    public void hidePlayer(Player p) {
+        for (EntityArmorStand armor : entitylist) {
+            PacketPlayOutEntityDestroy packet = new PacketPlayOutEntityDestroy(armor.getId());
+            ((CraftPlayer) p).getHandle().playerConnection.sendPacket(packet);
+
+        }
+    }
+
+    public void showAll() {
+        for (Player player : Bukkit.getOnlinePlayers()) {
+            for (EntityArmorStand armor : entitylist) {
+                PacketPlayOutSpawnEntityLiving packet = new PacketPlayOutSpawnEntityLiving(armor);
+                ((CraftPlayer) player).getHandle().playerConnection.sendPacket(packet);
+            }
+        }
+    }
+
+    public void hideAll() {
+        for (Player player : Bukkit.getOnlinePlayers()) {
+            for (EntityArmorStand armor : entitylist) {
+                PacketPlayOutEntityDestroy packet = new PacketPlayOutEntityDestroy(armor.getId());
+                ((CraftPlayer) player).getHandle().playerConnection.sendPacket(packet);
+            }
+        }
+    }
+
+    private void create() {
+        for (String Text : this.Text) {
+            EntityArmorStand entity = new EntityArmorStand(((CraftWorld) this.location.getWorld()).getHandle(),this.location.getX(), this.location.getY(),this.location.getZ());
+            entity.setCustomName(Text);
+            entity.setCustomNameVisible(true);
+            entity.setInvisible(true);
+            entity.setGravity(false);
+            entitylist.add(entity);
+            this.location.subtract(0, this.DISTANCE, 0);
+            count++;
+        }
+
+        for (int i = 0; i < count; i++) {
+            this.location.add(0, this.DISTANCE, 0);
+        }
+        this.count = 0;
+    }
+
+}

src/main/java/eu/univento/core/api/Title.java

@@ -0,0 +1,85 @@
+package eu.univento.core.api;
+
+import net.minecraft.server.v1_9_R1.IChatBaseComponent;
+import net.minecraft.server.v1_9_R1.PacketPlayOutPlayerListHeaderFooter;
+import net.minecraft.server.v1_9_R1.PacketPlayOutTitle;
+import net.minecraft.server.v1_9_R1.PlayerConnection;
+import org.bukkit.ChatColor;
+import org.bukkit.craftbukkit.v1_9_R1.entity.CraftPlayer;
+import org.bukkit.entity.Player;
+
+import java.lang.reflect.Field;
+
+//TODO: find real author, its not me
+/**
+ * sends title to player
+ * @author joethei
+ * @version 1.0
+ */
+public class Title {
+
+	/**
+	 * send title to player
+	 * @param player Player
+	 * @param fadeIn Integer
+	 * @param stay Integer
+	 * @param fadeOut Integer
+	 * @param title String
+	 * @param subtitle String
+	 */
+	public static void sendTitle(Player player, Integer fadeIn, Integer stay, Integer fadeOut, String title, String subtitle) {
+		PlayerConnection connection = ((CraftPlayer) player).getHandle().playerConnection;
+
+		PacketPlayOutTitle packetPlayOutTimes = new PacketPlayOutTitle(PacketPlayOutTitle.EnumTitleAction.TIMES, null, fadeIn, stay, fadeOut);
+		connection.sendPacket(packetPlayOutTimes);
+
+		if (subtitle != null) {
+			subtitle = subtitle.replaceAll("%player%", player.getDisplayName());
+			subtitle = ChatColor.translateAlternateColorCodes('&', subtitle);
+			IChatBaseComponent titleSub = IChatBaseComponent.ChatSerializer.a("{\"text\": \"" + subtitle + "\"}");
+			PacketPlayOutTitle packetPlayOutSubTitle = new PacketPlayOutTitle(PacketPlayOutTitle.EnumTitleAction.SUBTITLE, titleSub);
+			connection.sendPacket(packetPlayOutSubTitle);
+		}
+
+		if (title != null) {
+			title = title.replaceAll("%player%", player.getDisplayName());
+			title = ChatColor.translateAlternateColorCodes('&', title);
+			IChatBaseComponent titleMain = IChatBaseComponent.ChatSerializer.a("{\"text\": \"" + title + "\"}");
+			PacketPlayOutTitle packetPlayOutTitle = new PacketPlayOutTitle(PacketPlayOutTitle.EnumTitleAction.TITLE, titleMain);
+			connection.sendPacket(packetPlayOutTitle);
+		}
+	}
+
+	/**
+	 * sends tab title to player
+	 * @param player Player
+	 * @param header String
+	 * @param footer String
+	 */
+	public static void sendTabTitle(Player player, String header, String footer) {
+		if (header == null)
+			header = "";
+		header = ChatColor.translateAlternateColorCodes('&', header);
+
+		if (footer == null)
+			footer = "";
+		footer = ChatColor.translateAlternateColorCodes('&', footer);
+
+		header = header.replaceAll("%player%", player.getDisplayName());
+		footer = footer.replaceAll("%player%", player.getDisplayName());
+
+		PlayerConnection connection = ((CraftPlayer) player).getHandle().playerConnection;
+		IChatBaseComponent tabTitle = IChatBaseComponent.ChatSerializer.a("{\"text\": \"" + header + "\"}");
+		IChatBaseComponent tabFoot = IChatBaseComponent.ChatSerializer.a("{\"text\": \"" + footer + "\"}");
+		PacketPlayOutPlayerListHeaderFooter headerPacket = new PacketPlayOutPlayerListHeaderFooter(tabTitle);
+		try {
+			Field field = headerPacket.getClass().getDeclaredField("b");
+			field.setAccessible(true);
+			field.set(headerPacket, tabFoot);
+		} catch (Exception e) {
+			e.printStackTrace();
+		} finally {
+			connection.sendPacket(headerPacket);
+		}
+	}
+}

src/main/java/eu/univento/core/api/Utils.java

@@ -0,0 +1,176 @@
+package eu.univento.core.api;
+
+import eu.univento.core.Core;
+import org.bukkit.*;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.util.Vector;
+
+import java.io.File;
+import java.util.List;
+
+/**
+ * some utils you may need
+ * @author joethei
+ * @version 1.0
+ */
+public class Utils {
+	
+	/**
+	 * plays sound for all players
+	 * @param s Sound
+	 */
+	public static void playSoundToAll(Sound s) {
+		for (Player all : Bukkit.getOnlinePlayers())
+			all.playSound(all.getLocation(), s, 3.0F, 3.0F);
+	}
+	
+	/**
+	 * plays effect for all players
+	 * @param e Effect
+	 */
+	@SuppressWarnings("deprecation")
+	public static void playEffectToAll(Effect e) {
+		for (Player all : Bukkit.getOnlinePlayers())
+			all.playEffect(all.getLocation(), e, 3);
+	}
+	
+	/**
+	 * checks if server version is from spigot
+	 * @return true/false
+	 */
+	public static boolean isSpigot() {
+		return Bukkit.getVersion().contains("Spigot");
+	}
+	
+	/**
+	 * deletes all folders and files in directory
+	 * @param file File
+	 */
+	public static void deleteDir(File file) {
+		if (file.isDirectory()) {
+			if (file.list().length == 0) {
+				file.delete();
+			} else {
+				String[] files = file.list();
+				for (String tmp : files) {
+					File fileDelete = new File(file, tmp);
+					deleteDir(fileDelete);
+				}
+				if (file.list().length == 0)
+					file.delete();
+			}
+		} else
+			file.delete();
+	}
+
+	/**
+	 * creates a random number
+	 * @param low lowest possible value
+	 * @param high highest possible value
+	 * @return double
+	 */
+	public static double random(int low, int high) {
+		return Math.random() * (high - low) + low;
+	}
+
+	/**
+	 * checks if player has empty inventory
+	 * @param p Player
+	 * @return true/false
+	 */
+	public static boolean hasEmptyInventory(Player p) {
+		for (ItemStack item : p.getInventory().getContents()) {
+			if ((item != null) && (item.getType() != Material.AIR))
+				return false;
+		}
+		for (ItemStack item : p.getInventory().getArmorContents()) {
+			if ((item != null) && (item.getType() != Material.AIR))
+				return false;
+		}
+		return true;
+	}
+
+
+	/**
+	 * removes list of entity and counts them
+	 * @param e List<Entity>
+	 * @return Integer
+	 */
+	public static int removeEntitys(List<Entity> e) {
+		int i = 0;
+		for (Entity en : e) {
+			en.remove();
+			i++;
+		}
+		return i;
+	}
+
+	/**
+	 * clears all potion effects from player
+	 * @param player Player
+	 */
+	public static void clearPotionEffects(Player player) {
+		for (PotionEffect effect : player.getActivePotionEffects())
+			player.removePotionEffect(effect.getType());
+	}
+
+	/**
+	 * calculates vector from one location to another
+	 * @param from Location
+	 * @param to Location
+	 * @return Vector
+	 */
+	public static Vector calculateVector(Location from, Location to) {
+		Location b = to;
+
+		// calculate the distance between the locations (a => from || b => to)
+		double dX = from.getX() - b.getX();
+		double dY = from.getY() - b.getY();
+		double dZ = from.getZ() - b.getZ();
+		// -------------------------
+
+		// calculate the yaw
+		double yaw = Math.atan2(dZ, dX);
+		// -------------------------
+
+		// calculate the pitch
+		double pitch = Math.atan2(Math.sqrt(dZ * dZ + dX * dX), dY) + Math.PI;
+		// -------------------------
+
+		// calculate and create the new vector
+		double x = Math.sin(pitch) * Math.cos(yaw);
+		double y = Math.sin(pitch) * Math.sin(yaw);
+		double z = Math.cos(pitch);
+
+        // -------------------------
+
+		return new Vector(x, z, y);
+	}
+	
+	/**
+	 * restarts server
+	 */
+	public static void restart() {
+		Bukkit.getScheduler().scheduleSyncDelayedTask(Core.getInstance(), new Runnable() {
+
+			@Override
+			public void run() {
+				Bukkit.getServer().spigot().restart();
+			}
+			
+		}, 10 * 20L);
+	}
+	
+	/**
+	 * shots random firework at specified location
+	 * @param loc Location
+	 */
+	public static void randomFirework(Location loc) {
+		FireworkEffect.Builder builder = FireworkEffect.builder();
+		FireworkEffect effect = builder.flicker(false).trail(false).with(FireworkEffect.Type.BALL_LARGE).withColor(Color.RED).withFade(Color.BLUE).build();
+		//TODO: make a random fireworks effect
+	}
+}

src/main/java/eu/univento/core/api/database/Database.java

@@ -0,0 +1,72 @@
+package eu.univento.core.api.database;
+
+import org.bukkit.plugin.Plugin;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+public abstract class Database
+{
+  protected Connection connection;
+  protected Plugin plugin;
+
+  protected Database(Plugin plugin)
+  {
+    this.plugin = plugin;
+    this.connection = null;
+  }
+
+  public abstract Connection openConnection()
+    throws SQLException, ClassNotFoundException;
+
+  public boolean checkConnection()
+    throws SQLException
+  {
+    return (this.connection != null) && (!this.connection.isClosed());
+  }
+
+  public Connection getConnection()
+  {
+    return this.connection;
+  }
+
+  public boolean closeConnection()
+    throws SQLException
+  {
+    if (this.connection == null) {
+      return false;
+    }
+    this.connection.close();
+    return true;
+  }
+
+  public ResultSet querySQL(String query)
+    throws SQLException, ClassNotFoundException
+  {
+    if (!checkConnection()) {
+      openConnection();
+    }
+
+    Statement statement = this.connection.createStatement();
+
+    ResultSet result = statement.executeQuery(query);
+
+    return result;
+  }
+
+  public int updateSQL(String query)
+    throws SQLException, ClassNotFoundException
+  {
+    if (!checkConnection()) {
+      openConnection();
+    }
+
+    Statement statement = this.connection.createStatement();
+
+    int result = statement.executeUpdate(query);
+
+    return result;
+  }
+}

src/main/java/eu/univento/core/api/database/MySQL.java

@@ -0,0 +1,36 @@
+package eu.univento.core.api.database;
+
+import org.bukkit.plugin.Plugin;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+
+public class MySQL extends Database
+{
+  private final String user;
+  private final String database;
+  private final String password;
+  private final String port;
+  private final String hostname;
+
+  public MySQL(Plugin plugin, String hostname, String port, String database, String username, String password) {
+    super(plugin);
+    this.hostname = hostname;
+    this.port = port;
+    this.database = database;
+    this.user = username;
+    this.password = password;
+  }
+
+  public Connection openConnection() throws SQLException, ClassNotFoundException {
+    if (checkConnection()) {
+      return this.connection;
+    }
+    Class.forName("com.mysql.jdbc.Driver");
+    this.connection = DriverManager.getConnection("jdbc:mysql://" + 
+      this.hostname + ":" + this.port + "/" + this.database, 
+      this.user, this.password);
+    return this.connection;
+  }
+}

src/main/java/eu/univento/core/api/database/SQLite.java

@@ -0,0 +1,47 @@
+package eu.univento.core.api.database;
+
+import org.bukkit.plugin.Plugin;
+
+import java.io.File;
+import java.io.IOException;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.util.logging.Level;
+
+public class SQLite extends Database
+{
+  private final String dbLocation;
+
+  public SQLite(Plugin plugin, String dbLocation)
+  {
+    super(plugin);
+    this.dbLocation = dbLocation;
+  }
+
+  public Connection openConnection()
+    throws SQLException, ClassNotFoundException
+  {
+    if (checkConnection()) {
+      return this.connection;
+    }
+    if (!this.plugin.getDataFolder().exists()) {
+      this.plugin.getDataFolder().mkdirs();
+    }
+    File file = new File(this.plugin.getDataFolder(), this.dbLocation);
+    if (!file.exists()) {
+      try {
+        file.createNewFile();
+      } catch (IOException e) {
+        this.plugin.getLogger().log(Level.SEVERE, 
+          "Unable to create database!");
+      }
+    }
+    Class.forName("org.sqlite.JDBC");
+    this.connection = 
+      DriverManager.getConnection("jdbc:sqlite:" + 
+      this.plugin.getDataFolder().toPath().toString() + "/" + 
+      this.dbLocation);
+    return this.connection;
+  }
+}

src/main/java/eu/univento/core/api/effects/Effects.java

@@ -0,0 +1,36 @@
+package eu.univento.core.api.effects;
+
+import eu.univento.core.api.player.PlayerSettings;
+import net.minecraft.server.v1_9_R1.EnumParticle;
+import net.minecraft.server.v1_9_R1.PacketPlayOutWorldParticles;
+import org.bukkit.Location;
+import org.bukkit.craftbukkit.v1_9_R1.entity.CraftPlayer;
+import org.bukkit.entity.Player;
+
+/**
+ * some better effects
+ * @author joethei
+ * @version 1.0
+ */
+public class Effects {
+	
+	/**
+	 * plays effects from location
+	 * @param loc Location
+	 * @param ep EnumParticle
+	 * @param f float of particles
+	 * @param count count of particles
+	 */
+	public static void playEffect(Location loc, EnumParticle ep, float f, int count) {
+		PacketPlayOutWorldParticles packet = new PacketPlayOutWorldParticles(ep, true, (float) loc.getX(), (float) loc.getY(), (float) loc.getZ(), f, f, f, 0.0F, count, 0, 0);
+		for(Player p : PlayerSettings.getAllPlayersWithEffectsEnabled()) {
+			((CraftPlayer)p).getHandle().playerConnection.sendPacket(packet);
+		}
+	}
+
+    public static void playEffectToPlayer(Player p, Location loc, EnumParticle ep, float f, int count) {
+        PacketPlayOutWorldParticles packet = new PacketPlayOutWorldParticles(ep, true, (float) loc.getX(), (float) loc.getY(), (float) loc.getZ(), f, f, f, 0.0F, count, 0, 0);
+        ((CraftPlayer)p).getHandle().playerConnection.sendPacket(packet);
+    }
+
+}

src/main/java/eu/univento/core/api/effects/WorldBoarder.java

@@ -0,0 +1,129 @@
+package eu.univento.core.api.effects;
+
+import eu.univento.core.Core;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * @author MrSheepSheep
+ * @version 0.1
+ */
+public class WorldBoarder {
+
+    private static Method handle, sendPacket;
+    private static Method center, distance, time, movement;
+    private static Field player_connection;
+    private static Constructor<?> constructor, border_constructor;
+    private static Object constant;
+
+    static {
+        try {
+            handle = getClass("org.bukkit.craftbukkit", "entity.CraftPlayer").getMethod("getHandle");
+            player_connection = getClass("net.minecraft.server", "EntityPlayer").getField("playerConnection");
+            for (Method m : getClass("net.minecraft.server", "PlayerConnection").getMethods()) {
+                if (m.getName().equals("sendPacket")) {
+                    sendPacket = m;
+                    break;
+                }
+            }
+            Class<?> enumclass;
+            try {
+                enumclass = getClass("net.minecraft.server", "EnumWorldBorderAction");
+            } catch(ClassNotFoundException x) {
+                enumclass = getClass("net.minecraft.server", "PacketPlayOutWorldBorder$EnumWorldBorderAction");
+            }
+            constructor = getClass("net.minecraft.server", "PacketPlayOutWorldBorder").getConstructor(getClass("net.minecraft.server", "WorldBorder"), enumclass);
+            border_constructor = getClass("net.minecraft.server", "WorldBorder").getConstructor();
+
+            Method[] methods = getClass("net.minecraft.server", "WorldBorder").getMethods();
+
+            String setCenter = "setCenter";
+            String setWarningDistance = "setWarningDistance";
+            String setWarningTime = "setWarningTime";
+            String transitionSizeBetween = "transitionSizeBetween";
+
+            if (!inClass(methods, setCenter))
+                setCenter = "c";
+            if (!inClass(methods, setWarningDistance))
+                setWarningDistance = "c";
+            if (!inClass(methods, setWarningTime))
+                setWarningTime = "b";
+            if (!inClass(methods, transitionSizeBetween))
+                transitionSizeBetween = "a";
+
+            center = getClass("net.minecraft.server", "WorldBorder").getMethod(setCenter, double.class, double.class);
+            distance = getClass("net.minecraft.server", "WorldBorder").getMethod(setWarningDistance, int.class);
+            time = getClass("net.minecraft.server", "WorldBorder").getMethod(setWarningTime, int.class);
+            movement = getClass("net.minecraft.server", "WorldBorder").getMethod(transitionSizeBetween, double.class, double.class, long.class);
+
+            for (Object o: enumclass.getEnumConstants()) {
+                if (o.toString().equals("INITIALIZE")) {
+                    constant = o;
+                    break;
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static boolean inClass(Method[] methods, String methodName){
+        for (Method m : methods)
+            if (Objects.equals(m.getName(), methodName))
+                return true;
+        return false;
+    }
+
+    private static Class<?> getClass(String prefix, String name) throws Exception {
+        return Class.forName((prefix + ".") + Bukkit.getServer().getClass().getPackage().getName().substring(Bukkit.getServer().getClass().getPackage().getName().lastIndexOf(".") + 1) + "." + name);
+    }
+
+    Core plugin;
+    protected List<String> togglelist = new ArrayList<>();
+
+    protected WorldBoarder(Core plugin) {
+        this.plugin = plugin;
+    }
+
+    protected void sendBorder(Player p, int percentage, int intensity){
+        percentage = Math.round(percentage / intensity);
+        setBorder(p, percentage);
+        fadeBorder(p, percentage, 5);
+    }
+
+    protected void fadeBorder(Player p, int percentage, long time){
+        int dist = -10000 * percentage + 1300000;
+        sendWorldBorderPacket(p, 0, 200000D, (double) dist, (long) 1000 * time + 4000); //Add 4000 to make sure the "security" zone does not count in the fade time
+    }
+
+    protected void removeBorder(Player p) {
+        sendWorldBorderPacket(p, 0, 200000D, 200000D, 0);
+    }
+
+    protected void setBorder(Player p, int percentage){
+        int dist = -10000 * percentage + 1300000;
+        sendWorldBorderPacket(p, dist, 200000D, 200000D, 0);
+    }
+
+    protected void sendWorldBorderPacket(Player p, int dist, double oldradius, double newradius, long delay) {
+        try {
+            Object worldborder = border_constructor.newInstance();
+            center.invoke(worldborder, p.getLocation().getX(), p.getLocation().getY());
+            distance.invoke(worldborder, dist);
+            time.invoke(worldborder, 15);
+            movement.invoke(worldborder, oldradius, newradius, delay);
+
+            Object packet = constructor.newInstance(worldborder, constant);
+            sendPacket.invoke(player_connection.get(handle.invoke(p)), packet);
+        } catch(Exception x) {
+            x.printStackTrace();
+        }
+    }
+}

src/main/java/eu/univento/core/api/entity/EntityModifier.java

@@ -0,0 +1,239 @@
+package eu.univento.core.api.entity;
+
+import net.minecraft.server.v1_9_R1.EntityLiving;
+import net.minecraft.server.v1_9_R1.NBTTagCompound;
+import org.bukkit.Bukkit;
+import org.bukkit.EntityEffect;
+import org.bukkit.Location;
+import org.bukkit.craftbukkit.v1_9_R1.entity.CraftCreature;
+import org.bukkit.craftbukkit.v1_9_R1.entity.CraftEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+
+import java.lang.reflect.Field;
+
+/**
+ * 
+ * @author GerVorbis
+ * @version 1.0
+ */
+public class EntityModifier
+{
+  static org.bukkit.entity.Entity entity;
+  static CraftEntity craftentity;
+  static net.minecraft.server.v1_9_R1.Entity entityS;
+  static int scheduler;
+  static Plugin plugin;
+  static Player player = null;
+  static float Speed;
+
+  public EntityModifier(org.bukkit.entity.Entity entity, Plugin plugin)
+  {
+    EntityModifier.entity = entity;
+    craftentity = (CraftEntity)entity;
+    entityS = craftentity.getHandle();
+    EntityModifier.plugin = plugin;
+  }
+
+  public static Builder modify()
+  {
+    return new Builder();
+  }
+
+  public static final class Builder
+  {
+    public Builder setDisplayName(String display)
+    {
+      EntityModifier.entity.setCustomName(display);
+      EntityModifier.entity.setCustomNameVisible(true);
+      return this;
+    }
+
+    public Builder setDisplayNameVisible(Boolean visible)
+    {
+      EntityModifier.entity.setCustomNameVisible(visible.booleanValue());
+      return this;
+    }
+
+    public Builder playEffekt(EntityEffect entityeffect)
+    {
+      EntityModifier.entity.playEffect(entityeffect);
+      return this;
+    }
+
+    public Builder remove()
+    {
+      EntityModifier.entity.remove();
+      return this;
+    }
+
+    public Builder setPassenger(org.bukkit.entity.Entity passenger)
+    {
+      EntityModifier.entity.setPassenger(passenger);
+      return this;
+    }
+
+    public Builder setFireTicks(int ticks)
+    {
+      EntityModifier.entity.setFireTicks(ticks);
+      return this;
+    }
+
+    public Builder setLocation(Location location)
+    {
+      teleport(location);
+      return this;
+    }
+
+    public Builder setYawPitch(float yaw, float pitch)
+    {
+      Location loc = EntityModifier.entity.getLocation().clone();
+      teleport(
+        new Location(loc.getWorld(), loc.getX(), loc.getY(), 
+        loc.getZ(), yaw, pitch));
+      return this;
+    }
+
+    public Builder teleport(Location location)
+    {
+      EntityModifier.entity.teleport(location);
+      return this;
+    }
+
+    public Builder die()
+    {
+      EntityModifier.entityS.die();
+      return this;
+    }
+
+    public Builder setInvisible(boolean invisible)
+    {
+      EntityModifier.entityS.setInvisible(invisible);
+      return this;
+    }
+
+    public Builder noClip(boolean noClip)
+    {
+      EntityModifier.entityS.noclip = noClip;
+      return this;
+    }
+
+    public Builder setInvulnerable(boolean invulnerable)
+    {
+      try
+      {
+        Field invulnerableField = net.minecraft.server.v1_9_R1.Entity.class
+          .getDeclaredField("invulnerable");
+        invulnerableField.setAccessible(true);
+        invulnerableField.setBoolean(EntityModifier.entityS, invulnerable);
+      } catch (Exception ex) {
+        ex.printStackTrace();
+      }
+      return this;
+    }
+
+    public Builder setNoAI(boolean noAI)
+    {
+      NBTTagCompound tag = new NBTTagCompound();
+      EntityModifier.entityS.c(tag);
+      tag.setBoolean("NoAI", noAI);
+      EntityLiving el = (EntityLiving)EntityModifier.entityS;
+      el.a(tag);
+      return this;
+    }
+
+    public Builder setSilent(boolean silent)
+    {
+      NBTTagCompound tag = new NBTTagCompound();
+      EntityModifier.entityS.c(tag);
+      tag.setBoolean("Silent", silent);
+      EntityLiving el = (EntityLiving)EntityModifier.entityS;
+      el.a(tag);
+      return this;
+    }
+
+    public Builder setCanPickUpLoot(boolean canpickuploot)
+    {
+      NBTTagCompound tag = new NBTTagCompound();
+      EntityModifier.entityS.c(tag);
+      tag.setBoolean("CanPickUpLoot", canpickuploot);
+      EntityLiving el = (EntityLiving)EntityModifier.entityS;
+      el.a(tag);
+      return this;
+    }
+
+    public Builder setHealth(float health)
+    {
+      NBTTagCompound tag = new NBTTagCompound();
+      EntityModifier.entityS.c(tag);
+      tag.setFloat("HealF", health);
+      EntityLiving el = (EntityLiving)EntityModifier.entityS;
+      el.a(tag);
+      return this;
+    }
+
+    public Builder setCanDespawn(boolean candespawn)
+    {
+      candespawn = !candespawn;
+      NBTTagCompound tag = new NBTTagCompound();
+      EntityModifier.entityS.c(tag);
+      tag.setBoolean("PersistenceRequired", candespawn);
+      EntityLiving el = (EntityLiving)EntityModifier.entityS;
+      el.a(tag);
+      return this;
+    }
+
+    public Builder walkToLocation(Location location, float speed)
+    {
+      ((CraftCreature)EntityModifier.entity)
+        .getHandle()
+        .getNavigation()
+        .a(location.getX(), location.getY(), location.getZ(), speed);
+      return this;
+    }
+
+    public Builder followPlayer(Player target, float speed)
+    {
+      EntityModifier.player = target;
+      EntityModifier.Speed = speed;
+      EntityModifier.scheduler = Bukkit.getScheduler().scheduleSyncRepeatingTask(EntityModifier.plugin, 
+        new Runnable()
+      {
+        @SuppressWarnings("deprecation")
+		public void run() {
+          double distance = EntityModifier.entity.getLocation().distance(
+            EntityModifier.player.getLocation());
+          if (distance < 11.0D) {
+            float speed = EntityModifier.Speed;
+            if (distance < 3.0D) {
+              speed = 0.0F;
+            }
+            ((CraftCreature)EntityModifier.entity)
+              .getHandle()
+              .getNavigation()
+              .a(EntityModifier.player.getLocation().getX(), 
+              EntityModifier.player.getLocation().getY(), 
+              EntityModifier.player.getLocation().getZ(), 
+              speed);
+          }
+          else if (EntityModifier.player.isOnGround()) {
+            EntityModifier.entity.teleport(EntityModifier.player);
+          }
+        }
+      }
+      , 0L, 1L);
+      return this;
+    }
+
+    public Builder stopFollowingPlayer()
+    {
+      Bukkit.getScheduler().cancelTask(EntityModifier.scheduler);
+      return this;
+    }
+
+    public org.bukkit.entity.Entity build()
+    {
+      return EntityModifier.entity;
+    }
+  }
+}

src/main/java/eu/univento/core/api/events/MoveEventFilter.java

@@ -0,0 +1,89 @@
+package eu.univento.core.api.events;
+
+import org.bukkit.Location;
+import org.bukkit.Server;
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerMoveEvent;
+
+import java.util.WeakHashMap;
+
+/**
+ * @author Crislibaer
+ */
+public class MoveEventFilter implements Listener
+{
+    public static class PlayerBlockMoveEvent extends PlayerMoveEvent
+    {
+        public PlayerBlockMoveEvent(PlayerMoveEvent pEvent)
+        {
+            super(pEvent.getPlayer(), pEvent.getFrom(), pEvent.getTo());
+        }
+    }
+
+    private static class BlockPosition
+    {
+        public int x;
+        public int y;
+        public int z;
+        public World world;
+    }
+
+    private Server mServer;
+    private WeakHashMap<Player, BlockPosition> mLastPosition = new WeakHashMap<>();
+
+    public MoveEventFilter(Server pServer)
+    {
+        mServer = pServer;
+    }
+
+    @EventHandler
+    public void onPlayerMove(PlayerMoveEvent pEvent)
+    {
+        if(pEvent.isCancelled() || pEvent instanceof PlayerBlockMoveEvent)
+        {
+            return;
+        }
+
+        BlockPosition lastPos = mLastPosition.get(pEvent.getPlayer());
+        Location currentPos = pEvent.getTo();
+        boolean fireEvent = false;
+
+        if(lastPos == null)
+        {
+            lastPos = new BlockPosition();
+            mLastPosition.put(pEvent.getPlayer(), lastPos);
+            fireEvent = true;
+        }
+        else if(lastPos.x != currentPos.getBlockX() || lastPos.z != currentPos.getBlockZ() || lastPos.y != currentPos.getBlockY())
+        {
+            fireEvent = true;
+        }
+        else if(lastPos.world != currentPos.getWorld())
+        {
+            fireEvent = true;
+        }
+
+        if(fireEvent)
+        {
+            // make sure that our event is synchronous
+            assert !pEvent.isAsynchronous();
+
+            // fire event
+            PlayerBlockMoveEvent event = new PlayerBlockMoveEvent(pEvent);
+            mServer.getPluginManager().callEvent(event);
+
+            // check event state and only update new position if event does not gets canceled
+            if(!event.isCancelled())
+            {
+                // update new position
+                lastPos.world = currentPos.getWorld();
+                lastPos.x = currentPos.getBlockX();
+                lastPos.y = currentPos.getBlockY();
+                lastPos.z = currentPos.getBlockZ();
+            }
+        }
+    }
+}

src/main/java/eu/univento/core/api/fakeplayer/FakePlayer.java

@@ -0,0 +1,234 @@
+package eu.univento.core.api.fakeplayer;
+
+import com.mojang.authlib.GameProfile;
+import eu.univento.core.Core;
+import net.minecraft.server.v1_9_R1.*;
+import org.bukkit.Location;
+import org.bukkit.craftbukkit.v1_9_R1.entity.CraftPlayer;
+import org.bukkit.entity.ArmorStand;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitRunnable;
+import org.bukkit.scheduler.BukkitTask;
+
+import java.lang.reflect.Field;
+import java.util.Arrays;
+
+/**
+ * @author joethei
+ * @version 0.3
+ */
+public class FakePlayer {
+
+    //TODO: fix parts and add some stuff
+
+    private static final double MOVE_SPEED = 4.3D / 20;
+
+    private Player player;
+    private int entityId;
+    private GameProfile gameProfile;
+    private DataWatcher dataWatcher;
+
+    private Location location;
+    private ArmorStand armorStand;
+    private LivingEntity target;
+    private BukkitTask task;
+
+    private boolean moveable;
+
+    public FakePlayer(GameProfile gameProfile, boolean moveable, Player player) {
+
+        this.player = player;
+
+        this.moveable = moveable;
+
+        this.entityId = (int) get(Entity.class, null, "entityCount");
+        set(Entity.class, null, "entityCount", this.entityId + 1);
+        this.gameProfile = gameProfile;
+
+        this.dataWatcher = new DataWatcher(null);
+        byte status = 0;
+        //this.dataWatcher.a(0, status);
+        //this.dataWatcher.a(10, (byte) 127);
+        //this.dataWatcher.a(6, 20F);
+    }
+
+    private final BukkitRunnable tickTask = new BukkitRunnable() {
+
+        private int ticksLiving = 0;
+
+        @Override
+        public void run() {
+            if(target != null) {
+                followEntity(target);
+
+                ticksLiving++;
+            }
+        }
+    };
+
+    private byte changeMask(byte bitMask, int bit, boolean state) {
+        if(state)
+            return bitMask |= 1 << bit;
+        else
+            return bitMask &= ~(1 << bit);
+
+    }
+
+    public void setTarget(LivingEntity target) {
+        this.target = target;
+    }
+
+    public void clearTarget() {
+        this.target = null;
+    }
+
+    public void setFire(boolean fire) {
+        setStatus(0, fire);
+    }
+
+    public void setSneaking(boolean sneaking) {
+        setStatus(1, sneaking);
+    }
+
+    public void setSprinting(boolean sprinting) {
+        setStatus(3, sprinting);
+    }
+
+    public void setUseItem(boolean useItem) {
+        setStatus(4, useItem);
+    }
+
+    public void setInvisible(boolean invisible) {
+        setStatus(5, invisible);
+    }
+
+    private void setStatus(int data, boolean bool) {
+        DataWatcher dataWatcher = this.dataWatcher;
+        byte status = 0;
+        status = changeMask(status, data, bool);
+        //dataWatcher.a(0, status);
+        //dataWatcher.a(10, (byte) 127);
+        //dataWatcher.a(6, 20F);
+    }
+
+    public void followEntity(LivingEntity entity) {
+        double diffX = entity.getLocation().getX() - location.getX();
+        double diffY = (entity.getLocation().getY() + entity.getEyeHeight() * 0.9D) - location.getY() + 1.6F;
+        double diffZ = entity.getLocation().getZ() - location.getZ();
+        double hypoXZ = Math.sqrt(diffX * diffX + diffZ * diffZ);
+        float yaw = (float) (Math.atan2(diffZ, diffX) * 180D / Math.PI) - 90F;
+        float pitch = (float) -(Math.atan2(diffY, hypoXZ) * 18D / Math.PI);
+        look(yaw, pitch);
+
+        if(moveable) {
+            if(Math.abs(diffX) > 3D || Math.abs(diffZ) > 3D) {
+                yaw = (float) Math.toRadians(yaw);
+                double x = Math.sin(yaw);
+                double z = Math.cos(yaw);
+                move(x * MOVE_SPEED, 0, z * MOVE_SPEED);
+            }
+        }
+    }
+
+    private void move(double x, int y, double z) {
+        sendPackets(new PacketPlayOutEntity.PacketPlayOutRelEntityMoveLook(this.entityId, (byte) toFixedPointNumber(x), (byte) toFixedPointNumber(y), (byte) toFixedPointNumber(z), toAngle(location.getYaw()), toAngle(location.getPitch()), true));
+        this.location.add(toFixedPointNumber(x) / 32D, toFixedPointNumber(y) / 32D, toFixedPointNumber(z) / 32D);
+        this.armorStand.teleport(this.location);
+    }
+
+    public void spawn(Location location) {
+
+        PacketPlayOutNamedEntitySpawn playerSpawn = new PacketPlayOutNamedEntitySpawn();
+        set(playerSpawn, "a", this.entityId);
+        set(playerSpawn, "b", this.gameProfile.getId());
+        set(playerSpawn, "c", toFixedPointNumber(location.getX()));
+        set(playerSpawn, "d", toFixedPointNumber(location.getY()));
+        set(playerSpawn, "e", toFixedPointNumber(location.getZ()));
+        set(playerSpawn, "f", toAngle(location.getYaw()));
+        set(playerSpawn, "g", toAngle(location.getPitch()));
+        set(playerSpawn, "h", 0);
+        set(playerSpawn, "i", this.dataWatcher);
+
+        PacketPlayOutPlayerInfo playerInfo = new PacketPlayOutPlayerInfo(PacketPlayOutPlayerInfo.EnumPlayerInfoAction.ADD_PLAYER);
+        set(playerInfo, "b", Arrays.asList(playerInfo.new PlayerInfoData(this.gameProfile, 0, WorldSettings.EnumGamemode.NOT_SET, new ChatComponentText(this.gameProfile.getName()))));
+        sendPackets(playerInfo, playerSpawn);
+
+        this.location = location;
+        this.armorStand = (ArmorStand) location.getWorld().spawnEntity(location, EntityType.ARMOR_STAND);
+        this.armorStand.setGravity(true);
+        this.armorStand.setVisible(false);
+
+        this.task = tickTask.runTaskTimer(Core.getInstance(), 0L, 1L);
+    }
+
+    public void despawn() {
+        PacketPlayOutPlayerInfo playerInfo = new PacketPlayOutPlayerInfo(PacketPlayOutPlayerInfo.EnumPlayerInfoAction.REMOVE_PLAYER);
+        set(playerInfo, "b", Arrays.asList(playerInfo.new PlayerInfoData(this.gameProfile, 0, null, null)));
+        sendPackets(new PacketPlayOutEntityDestroy(this.entityId), playerInfo);
+
+        this.armorStand.remove();
+        this.armorStand = null;
+        this.task.cancel();
+    }
+
+    public void removeTablist() {
+        PacketPlayOutPlayerInfo playerInfo = new PacketPlayOutPlayerInfo(PacketPlayOutPlayerInfo.EnumPlayerInfoAction.REMOVE_PLAYER);
+        set(playerInfo, "b", Arrays.asList(playerInfo.new PlayerInfoData(this.gameProfile, 0, null, null)));
+        sendPackets(new PacketPlayOutEntityDestroy(this.entityId), playerInfo);
+    }
+
+
+    private void look(float yaw, float pitch) {
+        PacketPlayOutEntityHeadRotation headRotation = new PacketPlayOutEntityHeadRotation();
+        set(headRotation, "a", this.entityId);
+        set(headRotation, "b", toAngle(yaw));
+        sendPackets(headRotation, new PacketPlayOutEntity.PacketPlayOutEntityLook(this.entityId, toAngle(yaw), toAngle(pitch), false));
+        this.location.setYaw(yaw);
+        this.location.setPitch(pitch);
+    }
+
+    private int toFixedPointNumber(double value) {
+        return (int) Math.floor(value * 32D);
+    }
+
+    private byte toAngle(float value) {
+        return (byte) ((int) (value * 256.0F / 360.F));
+    }
+
+    public void sendPackets(Packet<?>... packets) {
+                for(Packet<?> packet : packets)
+            ((CraftPlayer) player).getHandle().playerConnection.sendPacket(packet);
+    }
+
+    private void set(Object instance, String name, Object value) {
+        set(instance.getClass(), instance, name, value);
+    }
+
+    private void set(Class<?> clazz, Object instance, String name, Object value) {
+        try{
+            Field field = clazz.getDeclaredField(name);
+            field.setAccessible(true);
+            field.set(instance, value);
+        }catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    private Object get(Object instance, String name) {
+        return get(instance.getClass(), instance, name);
+    }
+
+    private Object get(Class<?> clazz, Object instance, String name) {
+        try{
+            Field field = clazz.getDeclaredField(name);
+            field.setAccessible(true);
+            return field.get(instance);
+        }catch (Exception e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+}

src/main/java/eu/univento/core/api/fakeplayer/PlayerKi.java

@@ -0,0 +1,51 @@
+package eu.univento.core.api.fakeplayer;
+
+import com.mojang.authlib.GameProfile;
+import eu.univento.core.api.utils.GameProfileBuilder;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.player.PlayerInteractEvent;
+
+import java.util.UUID;
+
+/**
+ * @author joethei
+ * @version 0.1
+ */
+public class PlayerKi implements Listener{
+
+    FakePlayer player;
+
+    public FakePlayer createPlayer(Player p, String uuid, String name, String skinUrl, String capeUrl) {
+        GameProfile gameProfile = GameProfileBuilder.getProfile(UUID.fromString(uuid), name, skinUrl, capeUrl);
+        return new FakePlayer(gameProfile, true, p);
+    }
+
+    @EventHandler
+    public void onInteract(PlayerInteractEvent e) {
+        if(e.getAction() == Action.RIGHT_CLICK_AIR) {
+            if(e.getItem().getType() == Material.DIAMOND) {
+                if(this.player != null) {
+                    this.player.despawn();
+                }
+                FakePlayer player = createPlayer(e.getPlayer(), e.getPlayer().getUniqueId().toString(),
+                        "TestUser", "http://textures.minecraft.net/texture/a116e69a845e227f7ca1fdde8c357c8c821ebd4ba619382ea4a1f87d4ae94",
+                        "http://textures.minecraft.net/texture/3f688e0e699b3d9fe448b5bb50a3a288f9c589762b3dae8308842122dcb81");
+                this.player = player;
+                player.spawn(e.getPlayer().getLocation());
+                player.setTarget(e.getPlayer());
+                player.setSneaking(true);
+                player.removeTablist();
+            }
+            if(e.getItem().getType() == Material.DIAMOND_SWORD) {
+                player.despawn();
+            }
+            if(e.getItem().getType() == Material.NETHER_STAR) {
+                player.followEntity(e.getPlayer());
+            }
+        }
+    }
+}

src/main/java/eu/univento/core/api/gui/AnvilGUI.java

@@ -0,0 +1,224 @@
+package eu.univento.core.api.gui;
+
+import eu.univento.core.Core;
+import net.minecraft.server.v1_9_R1.*;
+import org.bukkit.Bukkit;
+import org.bukkit.craftbukkit.v1_9_R1.entity.CraftPlayer;
+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.player.PlayerQuitEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+
+import java.util.HashMap;
+
+/**
+ * Created by chasechocolate.
+ */
+public class AnvilGUI {
+    private class AnvilContainer extends ContainerAnvil {
+        public AnvilContainer(EntityHuman entity){
+            super(entity.inventory, entity.world,new BlockPosition(0, 0, 0), entity);
+        }
+
+        @Override
+        public boolean a(EntityHuman entityhuman){
+            return true;
+        }
+    }
+
+    public enum AnvilSlot {
+        INPUT_LEFT(0),
+        INPUT_RIGHT(1),
+        OUTPUT(2);
+
+        private int slot;
+
+        private AnvilSlot(int slot){
+            this.slot = slot;
+        }
+
+        public int getSlot(){
+            return slot;
+        }
+
+        public static AnvilSlot bySlot(int slot){
+            for(AnvilSlot anvilSlot : values()){
+                if(anvilSlot.getSlot() == slot){
+                    return anvilSlot;
+                }
+            }
+
+            return null;
+        }
+    }
+
+    public class AnvilClickEvent {
+        private AnvilSlot slot;
+
+        private String name;
+
+        private boolean close = true;
+        private boolean destroy = true;
+
+        public AnvilClickEvent(AnvilSlot slot, String name){
+            this.slot = slot;
+            this.name = name;
+        }
+
+        public AnvilSlot getSlot(){
+            return slot;
+        }
+
+        public String getName(){
+            return name;
+        }
+
+        public boolean getWillClose(){
+            return close;
+        }
+
+        public void setWillClose(boolean close){
+            this.close = close;
+        }
+
+        public boolean getWillDestroy(){
+            return destroy;
+        }
+
+        public void setWillDestroy(boolean destroy){
+            this.destroy = destroy;
+        }
+    }
+
+    public interface AnvilClickEventHandler {
+        public void onAnvilClick(AnvilClickEvent event);
+    }
+
+    private Player player;
+
+    private AnvilClickEventHandler handler;
+
+    private HashMap<AnvilSlot, ItemStack> items = new HashMap<AnvilSlot, ItemStack>();
+
+    private Inventory inv;
+
+    private Listener listener;
+
+    public AnvilGUI(Player player, final AnvilClickEventHandler handler){
+        this.player = player;
+        this.handler = handler;
+
+        this.listener = new Listener(){
+            @EventHandler
+            public void onInventoryClick(InventoryClickEvent event){
+                if(event.getWhoClicked() instanceof Player){
+                    Player clicker = (Player) event.getWhoClicked();
+
+                    if(event.getInventory().equals(inv)){
+                        event.setCancelled(true);
+
+                        ItemStack item = event.getCurrentItem();
+                        int slot = event.getRawSlot();
+                        String name = "";
+
+                        if(item != null){
+                            if(item.hasItemMeta()){
+                                ItemMeta meta = item.getItemMeta();
+
+                                if(meta.hasDisplayName()){
+                                    name = meta.getDisplayName();
+                                }
+                            }
+                        }
+
+                        AnvilClickEvent clickEvent = new AnvilClickEvent(AnvilSlot.bySlot(slot), name);
+
+                        handler.onAnvilClick(clickEvent);
+
+                        if(clickEvent.getWillClose()){
+                            event.getWhoClicked().closeInventory();
+                        }
+
+                        if(clickEvent.getWillDestroy()){
+                            destroy();
+                        }
+                    }
+                }
+            }
+
+            @EventHandler
+            public void onInventoryClose(InventoryCloseEvent event){
+                if(event.getPlayer() instanceof Player){
+                    Player player = (Player) event.getPlayer();
+                    Inventory inv = event.getInventory();
+
+                    if(inv.equals(AnvilGUI.this.inv)){
+                        inv.clear();
+                        destroy();
+                    }
+                }
+            }
+
+            @EventHandler
+            public void onPlayerQuit(PlayerQuitEvent event){
+                if(event.getPlayer().equals(getPlayer())){
+                    destroy();
+                }
+            }
+        };
+
+        Bukkit.getPluginManager().registerEvents(listener, Core.getInstance()); //Replace with instance of main class
+    }
+
+    public Player getPlayer(){
+        return player;
+    }
+
+    public void setSlot(AnvilSlot slot, ItemStack item){
+        items.put(slot, item);
+    }
+
+    public void open(){
+        EntityPlayer p = ((CraftPlayer) player).getHandle();
+
+        AnvilContainer container = new AnvilContainer(p);
+
+        //Set the items to the items from the inventory given
+        inv = container.getBukkitView().getTopInventory();
+
+        for(AnvilSlot slot : items.keySet()){
+            inv.setItem(slot.getSlot(), items.get(slot));
+        }
+
+        //Counter stuff that the game uses to keep track of inventories
+        int c = p.nextContainerCounter();
+
+        //Send the packet
+        p.playerConnection.sendPacket(new PacketPlayOutOpenWindow(c, "minecraft:anvil", new ChatMessage("Repairing", new Object[]{}), 0));
+
+        //Set their active container to the container
+        p.activeContainer = container;
+
+        //Set their active container window id to that counter stuff
+        p.activeContainer.windowId = c;
+
+        //Add the slot listener
+        p.activeContainer.addSlotListener(p);
+    }
+
+    public void destroy(){
+        player = null;
+        handler = null;
+        items = null;
+
+        HandlerList.unregisterAll(listener);
+
+        listener = null;
+    }
+}

src/main/java/eu/univento/core/api/items/ItemSkulls.java

@@ -0,0 +1,124 @@
+package eu.univento.core.api.items;
+
+import com.mojang.authlib.GameProfile;
+import com.mojang.authlib.properties.Property;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.SkullMeta;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Base64;
+import java.util.UUID;
+
+public class ItemSkulls
+{
+  private static Class<?> skullMetaClass;
+  private static Class<?> tileEntityClass;
+  private static Class<?> blockPositionClass;
+  private static int mcVersion;
+
+  static
+  {
+    String version = org.bukkit.Bukkit.getServer().getClass().getPackage().getName()
+      .split("\\.")[3];
+    mcVersion = Integer.parseInt(version.replaceAll("[^0-9]", ""));
+    try {
+      skullMetaClass = Class.forName("org.bukkit.craftbukkit." + version + 
+        ".inventory.CraftMetaSkull");
+      tileEntityClass = Class.forName("net.minecraft.server." + version + 
+        ".TileEntitySkull");
+      if (mcVersion > 174)
+        blockPositionClass = Class.forName("net.minecraft.server." + 
+          version + ".BlockPosition");
+      else
+        blockPositionClass = null;
+    }
+    catch (ClassNotFoundException e) {
+      e.printStackTrace();
+    }
+  }
+
+  public static ItemStack getSkull(String skinURL)
+  {
+    return getSkull(skinURL, 1);
+  }
+
+  public static ItemStack getSkull(String skinURL, int amount)
+  {
+    ItemStack skull = new ItemStack(Material.SKULL_ITEM, amount, (short) 3);
+    SkullMeta meta = (SkullMeta)skull.getItemMeta();
+    try {
+      Field profileField = skullMetaClass.getDeclaredField("profile");
+      profileField.setAccessible(true);
+      profileField.set(meta, getProfile(skinURL));
+    } catch (Exception ex) {
+      ex.printStackTrace();
+    }
+    skull.setItemMeta(meta);
+    return skull;
+  }
+
+  public static boolean setBlock(Location loc, String skinURL)
+  {
+    return setBlock(loc.getBlock(), skinURL);
+  }
+
+  public static boolean setBlock(Block block, String skinURL)
+  {
+    boolean flag = block.getType() == Material.SKULL;
+    if (!flag)
+      block.setType(Material.SKULL);
+    try
+    {
+      Object nmsWorld = block.getWorld().getClass()
+        .getMethod("getHandle", new Class[0]).invoke(block.getWorld(), new Object[0]);
+      Object tileEntity = null;
+
+      if (mcVersion <= 174) {
+        Method getTileEntity = nmsWorld.getClass().getMethod(
+          "getTileEntity", new Class[] { Integer.TYPE, Integer.TYPE, Integer.TYPE });
+        tileEntity = tileEntityClass.cast(getTileEntity.invoke(
+          nmsWorld, new Object[] { Integer.valueOf(block.getX()), Integer.valueOf(block.getY()), Integer.valueOf(block.getZ()) }));
+      } else {
+        Method getTileEntity = nmsWorld.getClass().getMethod(
+          "getTileEntity", new Class[] { blockPositionClass });
+        tileEntity = tileEntityClass.cast(getTileEntity.invoke(
+          nmsWorld, new Object[] { 
+          getBlockPositionFor(block.getX(), block.getY(), 
+          block.getZ()) }));
+      }
+
+      tileEntityClass.getMethod("setGameProfile", new Class[] { GameProfile.class })
+        .invoke(tileEntity, new Object[] { getProfile(skinURL) });
+    } catch (Exception ex) {
+      ex.printStackTrace();
+    }
+    return !flag;
+  }
+
+  private static GameProfile getProfile(String skinURL) {
+    GameProfile profile = new GameProfile(UUID.randomUUID(), null);
+    String base64encoded = Base64.getEncoder().encodeToString(
+      new String("{textures:{SKIN:{url:\"" + skinURL + "\"}}}")
+      .getBytes());
+    Property property = new Property("textures", base64encoded);
+    profile.getProperties().put("textures", property);
+    return profile;
+  }
+
+  private static Object getBlockPositionFor(int x, int y, int z) {
+    Object blockPosition = null;
+    try {
+      Constructor<?> cons = blockPositionClass.getConstructor(new Class[] { Integer.TYPE, 
+        Integer.TYPE, Integer.TYPE });
+      blockPosition = cons.newInstance(new Object[] { Integer.valueOf(x), Integer.valueOf(y), Integer.valueOf(z) });
+    } catch (Exception ex) {
+      ex.printStackTrace();
+    }
+    return blockPosition;
+  }
+}

src/main/java/eu/univento/core/api/items/Pagifier.java

@@ -0,0 +1,67 @@
+package eu.univento.core.api.items;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+/***************************
+*    Pagifier by leNic    *
+***************************/
+
+/**
+ * @author leNic
+ * @version 1.0
+ */
+	public class Pagifier<T> {
+	    // Properties
+	    private int pageSize;
+	    // List of pages
+	    private List<List<T>> pages;
+	    // Constructor
+	    public Pagifier(int pageSize){
+	        this.pageSize = pageSize;
+	        this.pages = new ArrayList<>();
+	        // Create first page
+	        this.pages.add(new ArrayList<>());
+	    }
+	    /**
+	     * Add item to pages
+	     * (Creates a new page if the previous page is not existing or full)
+	     * @param item The item you want to add
+	     */
+	    public void addItem(T item){
+	        int pageNum = pages.size() - 1;
+	        List<T> currentPage = this.pages.get(pageNum);
+	        // Add page if full
+	        if(currentPage.size() >= this.pageSize) {
+	            currentPage = new ArrayList<>();
+	            this.pages.add(currentPage);
+	            pageNum++;
+	        }
+	        currentPage.add(item);
+	    }
+	    /**
+	     * Get the items of a page
+	     * @param pageNum Number of the page (beginning at 0)
+	     * @return Optional with a list of the page's items
+	     */
+	    public Optional<List<T>> getPage(int pageNum){
+	        if(this.pages.size() == 0)
+	            return Optional.empty();
+	        return Optional.of(this.pages.get(pageNum));
+	    }
+	    /**
+	     * Get all pages
+	     * @return List containing all pages
+	     */
+	    public List<List<T>> getPages(){
+	        return this.pages;
+	    }
+	    /**
+	     * Get the current set page size
+	     * @return The current page size
+	     */
+	    public int getPageSize(){
+	        return this.pageSize;
+	    }
+}

src/main/java/eu/univento/core/api/languages/Language_DE.java

@@ -0,0 +1,557 @@
+package eu.univento.core.api.languages;
+
+import eu.univento.core.api.player.CustomPlayer;
+import eu.univento.core.api.player.Perms;
+
+/**
+ * @author joethei
+ * @version  1.0
+ */
+
+public class Language_DE implements Languages{
+
+    @Override
+    public String UNKNOWN_ERROR() {
+        return "§cEs ist ein unbekannter Fehler aufgetreten";
+    }
+
+    @Override
+    public String NO_PERMS() {
+        return "§cDu hast keine Berechtigung diesen Befehl auszuführen";
+    }
+
+    @Override
+    public String ERROR() {
+        return "§cFehler: ";
+    }
+
+    @Override
+    public String NOT_ONLINE(String name) {
+        return "§7" + name + " ist §cnicht §7online";
+    }
+
+    @Override
+    public String KICK_RESTART() {
+        return "§cDer Server wurde neu gestartet";
+    }
+
+    @Override
+    public String KICK_FULL() {
+        return "§cDieser Server ist bereits voll";
+    }
+
+    @Override
+    public String COMMAND_NOT_FOUND() {
+        return "§cDieser Befehl konnte nicht gefunden werden";
+    }
+
+    @Override
+    public String Core_FIX_OWN() {
+        return "§7Du wurdest §egefixt";
+    }
+
+    @Override
+    public String Core_FIX_OTHER(CustomPlayer p) {
+        return "§7Du hast " + p.getDisplayName() + " §egefixt";
+    }
+
+    @Override
+    public String Core_FIX_BY_OTHER(CustomPlayer p) {
+        return "§7Du wurdest von " + p.getDisplayName() + " §egefixt";
+    }
+
+    @Override
+    public String Core_NICK_ON() {
+        return "§7Du hast einen §eNicknamen §7zugewiesen bekommen";
+    }
+
+    @Override
+    public String Core_NICK_OFF() {
+        return "§7Du hast nun §ckeinen §eNicknamen §7mehr";
+    }
+
+    @Override
+    public String Core_BUILD_ON() {
+        return "§7Du hast den Baumodus §abetreten";
+    }
+
+    @Override
+    public String Core_BUILD_OFF() {
+        return "§7Du hast den Baumodus §cverlassen";
+    }
+
+    @Override
+    public String Core_BAN_NO_REASON() {
+        return "§cDieser Grund exsistiert nicht";
+    }
+
+    @Override
+    public String Core_BAN_USAGE() {
+        return "§cNutze <Spieler> <Grund>";
+    }
+
+    @Override
+    public String Core_BAN_BANNED(CustomPlayer p) {
+        return "§7Du hast " + p.getColor() + p.getDisplayName() + " §cgebannt";
+    }
+
+    @Override
+    public String Core_GM_USAGE() {
+        return "§7Nutze §e/gm <0 | 1 | 2 | 3>";
+    }
+
+    @Override
+    public String Core_GM_CHANGED() {
+        return "§7Dein Spielmodus wurde §ageändert";
+    }
+
+    @Override
+    public String Core_GLOBALMUTE_ON() {
+        return "§7Der Server wurde §cstumm gestellt";
+    }
+
+    @Override
+    public String Core_GLOBALMUTE_OFF() {
+        return "§7Der Server wurde §asozial §7gestellt";
+    }
+
+    @Override
+    public String Core_RUNAS_USAGE() {
+        return "§cFühre /runas <Spieler> <Befehl>";
+    }
+
+    @Override
+    public String Core_RUNAS_RUN(CustomPlayer p) {
+        return "§7Der Spieler " + p.getColor() + p.getDisplayName() + " §7hat deinen Befehl §eerfolgreich §7ausgeführt";
+    }
+
+    @Override
+    public String Core_SETRANK_USAGE() {
+        return "§cNutze /setrank <Spieler> <Rang>";
+    }
+
+    @Override
+    public String Core_SETRANK_KICK() {
+        return "\n§aDu hast nun einen neuen Rang.§e\nBitte joine neu§7.";
+    }
+
+    @Override
+    public String Core_SETRANK_NO_RANK() {
+        return "§cDieser Rang exsistiert nicht";
+    }
+
+    @Override
+    public String Core_SETRANK_SET(CustomPlayer p, Perms.Ranks rank) {
+        return "§7Du hast dem Spieler " + p.getDisplayName() + " auf §e" + rank.toString() + " §7gesetzt";
+    }
+    @Override
+    public String Core_TS_ALLREADY_VERIFIED() {
+        return "§cDu hast bereits einen verifizierten Account";
+    }
+
+    @Override
+    public String Core_TS_VERIFIED() {
+        return "§7Du hast deinen Account §eerfolgreich §7verifiziert";
+    }
+
+    @Override
+    public String Core_VANISH_ON() {
+        return "§7Du bist nun §aunsichtbar";
+    }
+
+    @Override
+    public String Core_VANISH_OFF() {
+        return "§7Du bist nun wieder §csichtbar";
+    }
+
+    @Override
+    public String Core_SERVER_MUTED() {
+        return "§7Der Chat ist bis auf weiteres §cgesperrt";
+    }
+
+    @Override
+    public String Core_CHAT_CLEARED(CustomPlayer p) {
+        return "§7Der Chat wurde von " + p.getColor() + p.getDisplayName() + " §cgereinigt";
+    }
+
+    @Override
+    public String Core_TAB_TITLE() {
+        return "§7Du spielst auf §e";
+    }
+
+    @Override
+    public String Lobby_PLAYERS_HIDE() {
+        return "§7Du kannst nun §ckeine §7Spieler mehr sehen";
+    }
+
+    @Override
+    public String Lobby_PLAYERS_SHOW() {
+        return "§7Du kannst nun §aalle §7Spieler sehen";
+    }
+
+    @Override
+    public String Lobby_AUTONICK_ON() {
+        return "§7Du §aerhälst §7nun einen automatischen §eNicknamen";
+    }
+
+    @Override
+    public String Lobby_AUTONICK_OFF() {
+        return "§7Du hast nun §ckeinen §7automatischen §eNicknamen §7mehr";
+    }
+
+    @Override
+    public String Lobby_FORCEFIELD_ON() {
+        return "§7Du hast das §eSchutzschild §aaktiviert";
+    }
+
+    @Override
+    public String Lobby_FORCEFIELD_OFF() {
+        return "§7Du hast das §eSchutzschild §cdeaktiviert";
+    }
+
+    @Override
+    public String Lobby_SILENT_LOBBY_ON() {
+        return "§7Du hast die §eSilent-Lobby §abetreten";
+    }
+
+    @Override
+    public String Lobby_SILENT_LOBBY_OFF() {
+        return "§7Du hast die §eSilent-Lobby §cverlassen";
+    }
+
+    @Override
+    public String Lobby_PLAYING_MUSIC_PREFIX() {
+        return "§6Jetzt spielt: ";
+    }
+
+    @Override
+    public String Lobby_FOUND_ITEM_PREFIX() {
+        return "§7Du hast etwas §egefunden";
+    }
+
+    @Override
+    public String Lobby_SET_LOCATION() {
+        return "§aPosition wurde gesetzt";
+    }
+
+    @Override
+    public String Lobby_SET_LOCATION_USAGE() {
+        return "§cNutze /setloc <Name>";
+    }
+
+    @Override
+    public String Lobby_DROP_ITEM_USAGE() {
+        return "§cNutze /dropitem <Item>";
+    }
+
+    @Override
+    public String Lobby_DROP_ITEM() {
+        return "§aDu hast ein Item gelegt";
+    }
+
+    @Override
+    public String Lobby_SET_SIGN() {
+        return "§aNeues Status Schild erstellt";
+    }
+
+    @Override
+    public String Lobby_JOIN_TITLE_1() {
+        return "§6univento§7.§eeu";
+    }
+
+    @Override
+    public String Lobby_JOIN_TITLE_2() {
+        return "§cIch putze hier nur";
+    }
+
+    @Override
+    public String Lobby_PET_ADD() {
+        return "§7Du hast nun ein §eHaustier";
+    }
+
+    @Override
+    public String Lobby_PET_REMOVE() {
+        return "§7Du hast nun §ckein §eHaustier §7mehr";
+    }
+
+    @Override
+    public String Lobby_PARKOUR_ON() {
+        return "§7Du hast den §eParkourmodus §abetreten";
+    }
+
+    @Override
+    public String Lobby_PARKOUR_OFF() {
+        return "§7Du hast den §eParkourmodus §cverlassen";
+    }
+
+    @Override
+    public String LobbyItems_NAVIGATOR() {
+        return "§eNavigator";
+    }
+
+    @Override
+    public String LobbyItems_PLAYER_HIDER_ON() {
+        return "§cSpieler verstecken";
+    }
+
+    @Override
+    public String LobbyItems_PLAYER_HIDER_OFF() {
+        return "§aSpieler anzeigen";
+    }
+
+    @Override
+    public String LobbyItems_AUTO_NICK() {
+        return "§5AutoNick";
+    }
+
+    @Override
+    public String LobbyItems_SILENT_LOBBY() {
+        return "§cSilent-Lobby";
+    }
+
+    @Override
+    public String LobbyItems_FORCEFIELD() {
+        return "§aSchutzschild";
+    }
+
+    @Override
+    public String LobbyItems_FUN_CHEST() {
+        return "§cF§aU§eN§3Chest";
+    }
+
+    @Override
+    public String LobbyItems_PROFILE() {
+        return "§eDein Profil";
+    }
+
+    @Override
+    public String LobbyItems_YOUTUBER() {
+        return "§5Youtuber Funktionen";
+    }
+
+    @Override
+    public String LobbyItems_SUGGESTION() {
+        return "§6Vorschläge";
+    }
+
+    @Override
+    public String LobbyItems_SPAWN() {
+        return "§6Spawn";
+    }
+
+    @Override
+    public String LobbyItems_PREMIUMHUB() {
+        return "§6Premium Lobby";
+    }
+
+    @Override
+    public String LobbyItems_MAYA() {
+        return "§6Maya";
+    }
+
+    @Override
+    public String LobbyItems_WOOLGET() {
+        return "§6WoolGet";
+    }
+
+    @Override
+    public String LobbyItems_BUILDSERVER() {
+        return "§aBau-Server";
+    }
+
+    @Override
+    public String LobbyItems_PLAYERS_ONLINE() {
+        return " §6Spieler online";
+    }
+
+    @Override
+    public String LobbyItems_GADGETS() {
+        return "§6Gadgets";
+    }
+
+    @Override
+    public String LobbyItems_MUSIC() {
+        return "§6Musik";
+    }
+
+    @Override
+    public String LobbyItems_PARTICLE() {
+        return "§6Partikel";
+    }
+
+    @Override
+    public String LobbyItems_PETS() {
+        return "§6Haustiere";
+    }
+
+    @Override
+    public String LobbyItems_YOUR_PET() {
+        return "§6Dein Haustier";
+    }
+
+    @Override
+    public String LobbyItems_PETS_NAME() {
+        return "§6Namen ändern";
+    }
+
+    @Override
+    public String LobbyItems_PETS_AGE() {
+        return "§6Alter ändern";
+    }
+
+    @Override
+    public String LobbyItems_PETS_RIDE() {
+        return "§6Reiten";
+    }
+
+    @Override
+    public String LobbyItems_PETS_REMOVE() {
+        return "§6Haustier entfernen";
+    }
+
+    @Override
+    public String LobbyItems_PETS_PIG() {
+        return "§6Schwein";
+    }
+
+    @Override
+    public String LobbyItems_PETS_COW() {
+        return "§6Kuh";
+    }
+
+    @Override
+    public String LobbyItems_PETS_CHICKEN() {
+        return "§6Hühnchen";
+    }
+
+    @Override
+    public String LobbyItems_PETS_RABBIT() {
+        return "§6Hase";
+    }
+
+    @Override
+    public String LobbyItems_PETS_MUSHROM_COW() {
+        return "§6Pilzkuh";
+    }
+
+    @Override
+    public String LobbyItems_PLAYER_MENU() {
+        return " Menü";
+    }
+
+    @Override
+    public String LobbyItems_PLAYER_FRIEND() {
+        return "§6Freundschaftsanfrage senden";
+    }
+
+    @Override
+    public String LobbyItems_PLAYER_PARTY() {
+        return "§6Party Anfrage senden";
+    }
+
+    @Override
+    public String LobbyItems_PLAYER_PROFILE() {
+        return "§6Profil";
+    }
+
+    @Override
+    public String LobbyItems_PLAYER_STATS() {
+        return "§6Statistiken";
+    }
+
+    @Override
+    public String LobbyItems_STATS() {
+        return "§6Deine Statistiken";
+    }
+
+    @Override
+    public String LobbyItems_FRIENDS() {
+        return "§6Freunde";
+    }
+
+    @Override
+    public String LobbyItems_SETTINGS() {
+        return "§eEinstellungen";
+    }
+
+    @Override
+    public String LobbyItems_SETTINGS_FASTMENU() {
+        return "§6Inventar Animation";
+    }
+
+    @Override
+    public String LobbyItems_SETTINGS_SERVER_TELEPORT() {
+        return "§6Server-Teleport";
+    }
+
+    @Override
+    public String LobbyItems_SETTINGS_PARTY_REQUESTS() {
+        return "§6Party Anfragen";
+    }
+
+    @Override
+    public String LobbyItems_SETTINGS_FRIEND_REQUESTS() {
+        return "§6Freundschafts Anfragen";
+    }
+
+    @Override
+    public String LobbyItems_SETTINGS_CHATSOUNDS() {
+        return "§6Chat Geräusche";
+    }
+
+    @Override
+    public String LobbyItems_SETTINGS_EFFECTS() {
+        return "§6Effekte";
+    }
+
+    @Override
+    public String LobbyItems_SETTINGS_LANGUAGES() {
+        return "§6Sprachen";
+    }
+
+    @Override
+    public String LobbyItems_SETTINGS_ON() {
+        return "§aaktiviert";
+    }
+
+    @Override
+    public String LobbyItems_SETTINGS_OFF() {
+        return "§cdeaktiviert";
+    }
+
+    @Override
+    public String LobbyItems_BACK() {
+        return "§cZurück";
+    }
+
+    @Override
+    public String LobbyBoard_FOUND_SECRETS() {
+        return "§eVerstecke§7:";
+    }
+
+    @Override
+    public String LobbyBoard_COINS() {
+        return "§eDeine Coins§7:";
+    }
+
+    @Override
+    public String LobbyBoard_TS() {
+        return "§eTeamSpeak§7:";
+    }
+
+    @Override
+    public String LobbyBoard_FORUM() {
+        return "§eForum§7:";
+    }
+
+    @Override
+    public String LobbyBoard_NEW() {
+        return "§e§lJetzt neu:";
+    }
+
+    @Override
+    public String LobbyBoard_NEWS() {
+        return "Scheibenwischer";
+    }
+
+}

src/main/java/eu/univento/core/api/languages/Language_EN.java

@@ -0,0 +1,556 @@
+package eu.univento.core.api.languages;
+
+import eu.univento.core.api.player.CustomPlayer;
+import eu.univento.core.api.player.Perms;
+
+/**
+ * @author joethei
+ * @version 0.1
+ */
+public class Language_EN implements Languages{
+
+        @Override
+        public String UNKNOWN_ERROR() {
+            return "§cEs ist ein unbekannter Fehler aufgetreten";
+        }
+
+        @Override
+        public String NO_PERMS() {
+            return "§cYou're not allowed do use this command";
+        }
+
+        @Override
+        public String ERROR() {
+            return "§cERROR: ";
+        }
+
+        @Override
+        public String NOT_ONLINE(String name) {
+            return "§7" + name + " is §cnot §7online";
+        }
+
+        @Override
+        public String KICK_RESTART() {
+            return "§cThe server has been restarted";
+        }
+
+        @Override
+        public String KICK_FULL() {
+            return "§cThe server is full";
+        }
+
+        @Override
+        public String COMMAND_NOT_FOUND() {
+            return "§cThis command hasn't been found.";
+        }
+
+        @Override
+        public String Core_FIX_OWN() {
+            return "§7You were §efixed";
+        }
+
+        @Override
+        public String Core_FIX_OTHER(CustomPlayer p) {
+            return "§7You §efixed " + p.getDisplayName();
+        }
+
+        @Override
+        public String Core_FIX_BY_OTHER(CustomPlayer p) {
+            return "§7You've been §efixed §7by " + p.getDisplayName();
+        }
+
+        @Override
+        public String Core_NICK_ON() {
+            return "§7You got a §enickname";
+        }
+
+        @Override
+        public String Core_NICK_OFF() {
+            return "§7Now you have §cno more keinen §enickname";
+        }
+
+        @Override
+        public String Core_BUILD_ON() {
+            return "§7You've §ajoined §7the building-mode";
+        }
+
+        @Override
+        public String Core_BUILD_OFF() {
+            return "§7You've §cleft §7the building-mode";
+        }
+
+        @Override
+        public String Core_BAN_NO_REASON() {
+            return "§cThis reason doesn't exist";
+        }
+
+        @Override
+        public String Core_BAN_USAGE() {
+            return "§cUse <player> <reason>";
+        }
+
+        @Override
+        public String Core_BAN_BANNED(CustomPlayer p) {
+            return "§7You've §cbanned " + p.getColor() + p.getDisplayName();
+        }
+
+        @Override
+        public String Core_GM_USAGE() {
+            return "§7Use §e/gm <0 | 1 | 2 | 3>";
+        }
+
+        @Override
+        public String Core_GM_CHANGED() {
+            return "§7You're gamemode has been §achanged";
+        }
+
+        @Override
+        public String Core_GLOBALMUTE_ON() {
+            return "§7The server has been §cmuted";
+        }
+
+        @Override
+        public String Core_GLOBALMUTE_OFF() {
+            return "§7The server has been §aunmuted";
+        }
+
+        @Override
+        public String Core_RUNAS_USAGE() {
+            return "§cUse /runas <player> <command>";
+        }
+
+        @Override
+        public String Core_RUNAS_RUN(CustomPlayer p) {
+            return "§7The player " + p.getColor() + p.getDisplayName() + " §7has executed your command §esuccesfully";
+        }
+
+        @Override
+        public String Core_SETRANK_USAGE() {
+            return "§cUse /setrank <player> <rank>";
+        }
+
+        @Override
+        public String Core_SETRANK_KICK() {
+            return "\n§aYou've got a new rank,§e\nplease rejoin§7.";
+        }
+
+        @Override
+        public String Core_SETRANK_NO_RANK() {
+            return "§cThis rank doesn't exist";
+        }
+
+        @Override
+        public String Core_SETRANK_SET(CustomPlayer p, Perms.Ranks rank) {
+            return "§7You gave " + p.getDisplayName() + " the rank §e" + rank.toString();
+        }
+
+        @Override
+        public String Core_TS_ALLREADY_VERIFIED() {
+            return "§cYou've already had a verificated account";
+        }
+
+        @Override
+        public String Core_TS_VERIFIED() {
+            return "§7You verificated your account §esuccesfully";
+        }
+
+        @Override
+        public String Core_VANISH_ON() {
+            return "§7You are now §aunvisible";
+        }
+
+        @Override
+        public String Core_VANISH_OFF() {
+            return "§7You are now §cvisible §7again";
+        }
+
+        @Override
+        public String Core_SERVER_MUTED() {
+            return "§7The chat has been §cblocked";
+        }
+
+        @Override
+        public String Core_CHAT_CLEARED(CustomPlayer p) {
+            return "§7The chat has been §ccleaned §7by " + p.getColor() + p.getDisplayName();
+        }
+
+        @Override
+        public String Core_TAB_TITLE() {
+            return "§7You're playing on §e";
+        }
+
+        @Override
+        public String Lobby_PLAYERS_HIDE() {
+            return "§7You've §chidden §7all other players";
+        }
+
+        @Override
+        public String Lobby_PLAYERS_SHOW() {
+            return "§7Now you can §asee §7all other players ";
+        }
+
+        @Override
+        public String Lobby_AUTONICK_ON() {
+            return "§7You'll §aget an automatical §enickname";
+        }
+
+        @Override
+        public String Lobby_AUTONICK_OFF() {
+            return "§7You're §cnot getting an automatical §enickname §eanymore";
+        }
+
+        @Override
+        public String Lobby_FORCEFIELD_ON() {
+            return "§7You §aactivated §7your §eforcefield";
+        }
+
+        @Override
+        public String Lobby_FORCEFIELD_OFF() {
+            return "§7You §cdeactivated §7your §eforcefield";
+        }
+
+        @Override
+        public String Lobby_SILENT_LOBBY_ON() {
+            return "§7You §ajoined §7the §esilent-lobby";
+        }
+
+        @Override
+        public String Lobby_SILENT_LOBBY_OFF() {
+            return "§7You §eleft §7the §esilent-lobby";
+        }
+
+        @Override
+        public String Lobby_PLAYING_MUSIC_PREFIX() {
+            return "§6Now playing: ";
+        }
+
+        @Override
+        public String Lobby_FOUND_ITEM_PREFIX() {
+            return "§7You've §efound §7something";
+        }
+
+        @Override
+        public String Lobby_SET_LOCATION() {
+            return "§aPoisition has been set";
+        }
+
+        @Override
+        public String Lobby_SET_LOCATION_USAGE() {
+            return "§cUse /setloc <name>";
+        }
+
+        @Override
+        public String Lobby_DROP_ITEM_USAGE() {
+            return "§cUse /dropitem <item>";
+        }
+
+        @Override
+        public String Lobby_DROP_ITEM() {
+            return "§aYou set an item";
+        }
+
+        @Override
+        public String Lobby_SET_SIGN() {
+            return "§aNeues Status Schild erstellt";
+        }
+
+        @Override
+        public String Lobby_JOIN_TITLE_1() {
+            return "§6univento§7.§eeu";
+        }
+
+        @Override
+        public String Lobby_JOIN_TITLE_2() {
+            return "§cI'm just cleaning hear";
+        }
+
+        @Override
+        public String Lobby_PET_ADD() {
+            return "§7Now you have a §epet";
+        }
+
+        @Override
+        public String Lobby_PET_REMOVE() {
+            return "§7Du hast nun §ckein §eHaustier §7mehr";
+        }
+
+        @Override
+        public String Lobby_PARKOUR_ON() {
+            return "§7You §ajoined §7the §eparkour mode";
+        }
+
+        @Override
+        public String Lobby_PARKOUR_OFF() {
+            return "§7You §cleft §7the §eparkour mode";
+        }
+
+        @Override
+        public String LobbyItems_NAVIGATOR() {
+            return "§eNavigator";
+        }
+
+        @Override
+        public String LobbyItems_PLAYER_HIDER_ON() {
+            return "§cHide players";
+        }
+
+        @Override
+        public String LobbyItems_PLAYER_HIDER_OFF() {
+            return "§aShow players";
+        }
+
+        @Override
+        public String LobbyItems_AUTO_NICK() {
+            return "§5AutoNick";
+        }
+
+        @Override
+        public String LobbyItems_SILENT_LOBBY() {
+            return "§cSilent-Lobby";
+        }
+
+        @Override
+        public String LobbyItems_FORCEFIELD() {
+            return "§aForcefield";
+        }
+
+        @Override
+        public String LobbyItems_FUN_CHEST() {
+            return "§cF§aU§eN§3Chest";
+        }
+
+        @Override
+        public String LobbyItems_PROFILE() {
+            return "§eYour profile";
+        }
+
+        @Override
+        public String LobbyItems_YOUTUBER() {
+            return "§5Youtuber Funktionen";
+        }
+
+        @Override
+        public String LobbyItems_SUGGESTION() {
+            return "§6Suggestions";
+        }
+
+        @Override
+        public String LobbyItems_SPAWN() {
+            return "§6Spawn";
+        }
+
+        @Override
+        public String LobbyItems_PREMIUMHUB() {
+            return "§6Premium Lobby";
+        }
+
+        @Override
+        public String LobbyItems_MAYA() {
+            return "§6Maya";
+        }
+
+        @Override
+        public String LobbyItems_WOOLGET() {
+            return "§6WoolGet";
+        }
+
+        @Override
+        public String LobbyItems_BUILDSERVER() {
+            return "§aBuilding-Server";
+        }
+
+        @Override
+        public String LobbyItems_PLAYERS_ONLINE() {
+            return " §6players online";
+        }
+
+        @Override
+        public String LobbyItems_GADGETS() {
+            return "§6Gadgets";
+        }
+
+        @Override
+        public String LobbyItems_MUSIC() {
+            return "§6Music";
+        }
+
+        @Override
+        public String LobbyItems_PARTICLE() {
+            return "§6Particles";
+        }
+
+        @Override
+        public String LobbyItems_PETS() {
+            return "§6Pets";
+        }
+
+        @Override
+        public String LobbyItems_YOUR_PET() {
+            return "§6your pet";
+        }
+
+        @Override
+        public String LobbyItems_PETS_NAME() {
+            return "§6change name";
+        }
+
+        @Override
+        public String LobbyItems_PETS_AGE() {
+            return "§6change age";
+        }
+
+        @Override
+        public String LobbyItems_PETS_RIDE() {
+            return "§6ride";
+        }
+
+        @Override
+        public String LobbyItems_PETS_REMOVE() {
+            return "§6ride pet";
+        }
+
+        @Override
+        public String LobbyItems_PETS_PIG() {
+            return "§6pig";
+        }
+
+        @Override
+        public String LobbyItems_PETS_COW() {
+            return "§6cow";
+        }
+
+        @Override
+        public String LobbyItems_PETS_CHICKEN() {
+            return "§6chicken";
+        }
+
+        @Override
+        public String LobbyItems_PETS_RABBIT() {
+            return "§6rabbit";
+        }
+
+        @Override
+        public String LobbyItems_PETS_MUSHROM_COW() {
+            return "§6mushroom-cow";
+        }
+
+        @Override
+        public String LobbyItems_PLAYER_MENU() {
+            return " menu";
+        }
+
+        @Override
+        public String LobbyItems_PLAYER_FRIEND() {
+            return "§6send freind request";
+        }
+
+        @Override
+        public String LobbyItems_PLAYER_PARTY() {
+            return "§6send party request";
+        }
+
+        @Override
+        public String LobbyItems_PLAYER_PROFILE() {
+            return "§6Profil";
+        }
+
+        @Override
+        public String LobbyItems_PLAYER_STATS() {
+            return "§6stats";
+        }
+
+        @Override
+        public String LobbyItems_STATS() {
+            return "§6Deine Statistiken";
+        }
+
+        @Override
+        public String LobbyItems_FRIENDS() {
+            return "§6friends";
+        }
+
+        @Override
+        public String LobbyItems_SETTINGS() {
+            return "§eSettings";
+        }
+
+        @Override
+        public String LobbyItems_SETTINGS_FASTMENU() {
+            return "§6inventory animations";
+        }
+
+        @Override
+        public String LobbyItems_SETTINGS_SERVER_TELEPORT() {
+            return "§6Server-Teleport";
+        }
+
+        @Override
+        public String LobbyItems_SETTINGS_PARTY_REQUESTS() {
+            return "§6party requests";
+        }
+
+        @Override
+        public String LobbyItems_SETTINGS_FRIEND_REQUESTS() {
+            return "§6friend requests";
+        }
+
+        @Override
+        public String LobbyItems_SETTINGS_CHATSOUNDS() {
+            return "§6chat sounds";
+        }
+
+        @Override
+        public String LobbyItems_SETTINGS_EFFECTS() {
+            return "§6effects";
+        }
+
+        @Override
+        public String LobbyItems_SETTINGS_LANGUAGES() {
+            return "§6languages";
+        }
+
+        @Override
+        public String LobbyItems_SETTINGS_ON() {
+            return "§aactivated";
+        }
+
+        @Override
+        public String LobbyItems_SETTINGS_OFF() {
+            return "§cdeactivated";
+        }
+
+        @Override
+        public String LobbyItems_BACK() {
+            return "§cback";
+        }
+
+        @Override
+        public String LobbyBoard_FOUND_SECRETS() {
+            return "§eSecrets§7:";
+        }
+
+        @Override
+        public String LobbyBoard_COINS() {
+            return "§eYour coins§7:";
+        }
+
+        @Override
+        public String LobbyBoard_TS() {
+            return "§eTeamSpeak§7:";
+        }
+
+        @Override
+        public String LobbyBoard_FORUM() {
+            return "§eForum§7:";
+        }
+
+        @Override
+        public String LobbyBoard_NEW() {
+            return "§e§lNew:";
+        }
+
+        @Override
+        public String LobbyBoard_NEWS() {
+            return "Scheibenwischer";
+        }
+}

src/main/java/eu/univento/core/api/languages/Language_IT.java

@@ -0,0 +1,556 @@
+package eu.univento.core.api.languages;
+
+import eu.univento.core.api.player.CustomPlayer;
+import eu.univento.core.api.player.Perms;
+
+/**
+ * @author joethei
+ * @version 0.1
+ */
+public class Language_IT implements Languages{
+
+    @Override
+    public String UNKNOWN_ERROR() {
+        return "§cSi è presentato un errore sconosciuto";
+    }
+
+    @Override
+    public String NO_PERMS() {
+        return "§cNon hai accesso a quel commando";
+    }
+
+    @Override
+    public String ERROR() {
+        return "§cErrore: ";
+    }
+
+    @Override
+    public String NOT_ONLINE(String name) {
+        return "§7" + name + " §cnon §7è online";
+    }
+
+    @Override
+    public String KICK_RESTART() {
+        return "§cIl server è stato riavviato";
+    }
+
+    @Override
+    public String KICK_FULL() {
+        return "§cQuesto server è pieno";
+    }
+
+    @Override
+    public String COMMAND_NOT_FOUND() {
+        return "§cNon è stato trovato questo commando";
+    }
+
+    @Override
+    public String Core_FIX_OWN() {
+        return "§7Tu sei stato §efissato";
+    }
+
+    @Override
+    public String Core_FIX_OTHER(CustomPlayer p) {
+        return "§7Tu hai §efissato " + p.getDisplayName();
+    }
+
+    @Override
+    public String Core_FIX_BY_OTHER(CustomPlayer p) {
+        return "§7Tu sei stato §efissato §7da" + p.getDisplayName();
+    }
+
+    @Override
+    public String Core_NICK_ON() {
+        return "§7Hai ricevuto un §eNickname";
+    }
+
+    @Override
+    public String Core_NICK_OFF() {
+        return "§7Adesso §cnon §7hai più un §eNickname";
+    }
+
+    @Override
+    public String Core_BUILD_ON() {
+        return "§7Tu sei §aentrato §7nel §emodo di costruzione";
+    }
+
+    @Override
+    public String Core_BUILD_OFF() {
+        return "§7Tu sei §auscito §7dal §emodo di costruzione";
+    }
+
+    @Override
+    public String Core_BAN_NO_REASON() {
+        return "§cQuesto motivo non esiste";
+    }
+
+    @Override
+    public String Core_BAN_USAGE() {
+        return "§cDevi usare /ban <giocatore> <motivo>";
+    }
+
+    @Override
+    public String Core_BAN_BANNED(CustomPlayer p) {
+        return "§7Tu hai §ebannato " + p.getColor() + p.getDisplayName();
+    }
+
+    @Override
+    public String Core_GM_USAGE() {
+        return "§7Usi §e/gm <0 | 1 | 2 | 3>";
+    }
+
+    @Override
+    public String Core_GM_CHANGED() {
+        return "§7La tua modalitá del gioco è stata §aaggiornata";
+    }
+
+    @Override
+    public String Core_GLOBALMUTE_ON() {
+        return "§7Il server è stato messo §csilenzioso";
+    }
+
+    @Override
+    public String Core_GLOBALMUTE_OFF() {
+        return "§7Il server è stato rimesso §cnormale";
+    }
+
+    @Override
+    public String Core_RUNAS_USAGE() {
+        return "§cUsi /runas <giocatore> <commando>";
+    }
+
+    @Override
+    public String Core_RUNAS_RUN(CustomPlayer p) {
+        return p.getColor() + p.getDisplayName() + " §7ha eseguito il tuo commando";
+    }
+
+    @Override
+    public String Core_SETRANK_USAGE() {
+        return "§cUsi /setrank <giocatore> <gruppo>";
+    }
+
+    @Override
+    public String Core_SETRANK_KICK() {
+        return "\n§aHai un nuovo gruppo§e\nti prego di rientrare il server§7.";
+    }
+
+    @Override
+    public String Core_SETRANK_NO_RANK() {
+        return "§cQuesto gruppo non esiste";
+    }
+
+    @Override
+    public String Core_SETRANK_SET(CustomPlayer p, Perms.Ranks rank) {
+        return "§7Hai dato " + p.getDisplayName() + " il gruppo §e" + rank.toString();
+    }
+    @Override
+    public String Core_TS_ALLREADY_VERIFIED() {
+        return "§cTu hai già un account verificato";
+    }
+
+    @Override
+    public String Core_TS_VERIFIED() {
+        return "§7Hai verificato il tuo account con §esuccesso";
+    }
+
+    @Override
+    public String Core_VANISH_ON() {
+        return "§7Adesso sei §ainvisibile §7per gli altri";
+    }
+
+    @Override
+    public String Core_VANISH_OFF() {
+        return "§7Adesso sei §crivisibile §7per gli altri";
+    }
+
+    @Override
+    public String Core_SERVER_MUTED() {
+        return "§7Il chat è stato §cmutato";
+    }
+
+    @Override
+    public String Core_CHAT_CLEARED(CustomPlayer p) {
+        return "§7La chat è stata §cpulita §7da " + p.getColor() + p.getDisplayName();
+    }
+
+    @Override
+    public String Core_TAB_TITLE() {
+        return "§7Stai giocando su §e";
+    }
+
+    @Override
+    public String Lobby_PLAYERS_HIDE() {
+        return "§7Adesso gli altri sono §cinvisibili §7per te";
+    }
+
+    @Override
+    public String Lobby_PLAYERS_SHOW() {
+        return "§7Adesso gli altri sono §avisibili §7per te";
+    }
+
+    @Override
+    public String Lobby_AUTONICK_ON() {
+        return "§7Adesso ti viene dato un §esoprannome §7automatico";
+    }
+
+    @Override
+    public String Lobby_AUTONICK_OFF() {
+        return "§7Adesso §cnon §7ti viene dato un più §esoprannome §7automatico";
+    }
+
+    @Override
+    public String Lobby_FORCEFIELD_ON() {
+        return "§7Hai §aattivato §7il §eForcefield";
+    }
+
+    @Override
+    public String Lobby_FORCEFIELD_OFF() {
+        return "§7Hai §cdisattivato §7il §eForcefield";
+    }
+
+    @Override
+    public String Lobby_SILENT_LOBBY_ON() {
+        return "§7Sei §aentrato §7nella §eSilent-Lobby";
+    }
+
+    @Override
+    public String Lobby_SILENT_LOBBY_OFF() {
+        return "§7Sei §cuscita §7della §eSilent-Lobby";
+    }
+
+    @Override
+    public String Lobby_PLAYING_MUSIC_PREFIX() {
+        return "§6In riproduzione: ";
+    }
+
+    @Override
+    public String Lobby_FOUND_ITEM_PREFIX() {
+        return "§7Hai §etrovato §7qualcosa";
+    }
+
+    @Override
+    public String Lobby_SET_LOCATION() {
+        return "§aPosizione è stata fissata";
+    }
+
+    @Override
+    public String Lobby_SET_LOCATION_USAGE() {
+        return "§cUsi /setloc <nome>";
+    }
+
+    @Override
+    public String Lobby_DROP_ITEM_USAGE() {
+        return "§cUsi /dropitem <item>";
+    }
+
+    @Override
+    public String Lobby_DROP_ITEM() {
+        return "§aHai messo un nuovo item qui.";
+    }
+
+    @Override
+    public String Lobby_SET_SIGN() {
+        return "§aNeues Status Schild erstellt";
+    }
+
+    @Override
+    public String Lobby_JOIN_TITLE_1() {
+        return "§6univento§7.§eeu";
+    }
+
+    @Override
+    public String Lobby_JOIN_TITLE_2() {
+        return "§cIo solo pulisco qui";
+    }
+
+    @Override
+    public String Lobby_PET_ADD() {
+        return "§7Adesso hai un §eanimale domestico";
+    }
+
+    @Override
+    public String Lobby_PET_REMOVE() {
+        return "§cNon §7hai più un §eanimale domestico";
+    }
+
+    @Override
+    public String Lobby_PARKOUR_ON() {
+        return "§7Sei §aentrato §7nel §emodo del parkour";
+    }
+
+    @Override
+    public String Lobby_PARKOUR_OFF() {
+        return "§7Sei §cuscito §7del §emodo del parkour";
+    }
+
+    @Override
+    public String LobbyItems_NAVIGATOR() {
+        return "§eNavigatore";
+    }
+
+    @Override
+    public String LobbyItems_PLAYER_HIDER_ON() {
+        return "§cNascondere i giocatori";
+    }
+
+    @Override
+    public String LobbyItems_PLAYER_HIDER_OFF() {
+        return "§aMostrare i giocatori";
+    }
+
+    @Override
+    public String LobbyItems_AUTO_NICK() {
+        return "§5AutoNick";
+    }
+
+    @Override
+    public String LobbyItems_SILENT_LOBBY() {
+        return "§cSilent-Lobby";
+    }
+
+    @Override
+    public String LobbyItems_FORCEFIELD() {
+        return "§aForcefield";
+    }
+
+    @Override
+    public String LobbyItems_FUN_CHEST() {
+        return "§cF§aU§eN§3Chest";
+    }
+
+    @Override
+    public String LobbyItems_PROFILE() {
+        return "§eIl tuo profilo";
+    }
+
+    @Override
+    public String LobbyItems_YOUTUBER() {
+        return "§5Altri funzioni";
+    }
+
+    @Override
+    public String LobbyItems_SUGGESTION() {
+        return "§6Suggestioni";
+    }
+
+    @Override
+    public String LobbyItems_SPAWN() {
+        return "§6Spawn";
+    }
+
+    @Override
+    public String LobbyItems_PREMIUMHUB() {
+        return "§6Lobby dei VIP";
+    }
+
+    @Override
+    public String LobbyItems_MAYA() {
+        return "§6Maya";
+    }
+
+    @Override
+    public String LobbyItems_WOOLGET() {
+        return "§6WoolGet";
+    }
+
+    @Override
+    public String LobbyItems_BUILDSERVER() {
+        return "§aServer per costruire";
+    }
+
+    @Override
+    public String LobbyItems_PLAYERS_ONLINE() {
+        return " §6giocatori sono online";
+    }
+
+    @Override
+    public String LobbyItems_GADGETS() {
+        return "§6Gadgets";
+    }
+
+    @Override
+    public String LobbyItems_MUSIC() {
+        return "§6Musica";
+    }
+
+    @Override
+    public String LobbyItems_PARTICLE() {
+        return "§6Particelle";
+    }
+
+    @Override
+    public String LobbyItems_PETS() {
+        return "§6Animali domestici";
+    }
+
+    @Override
+    public String LobbyItems_YOUR_PET() {
+        return "§6Il tuo animale domestico";
+    }
+
+    @Override
+    public String LobbyItems_PETS_NAME() {
+        return "§6Cambiare il nome";
+    }
+
+    @Override
+    public String LobbyItems_PETS_AGE() {
+        return "§6Cambiare l'età";
+    }
+
+    @Override
+    public String LobbyItems_PETS_RIDE() {
+        return "§6Cavalcarlo";
+    }
+
+    @Override
+    public String LobbyItems_PETS_REMOVE() {
+        return "§6Cancellarlo";
+    }
+
+    @Override
+    public String LobbyItems_PETS_PIG() {
+        return "§6Maiale";
+    }
+
+    @Override
+    public String LobbyItems_PETS_COW() {
+        return "§6Mucca";
+    }
+
+    @Override
+    public String LobbyItems_PETS_CHICKEN() {
+        return "§6Gallina";
+    }
+
+    @Override
+    public String LobbyItems_PETS_RABBIT() {
+        return "§6Coniglio";
+    }
+
+    @Override
+    public String LobbyItems_PETS_MUSHROM_COW() {
+        return "§6Muucelio";
+    }
+
+    @Override
+    public String LobbyItems_PLAYER_MENU() {
+        return ": menu";
+    }
+
+    @Override
+    public String LobbyItems_PLAYER_FRIEND() {
+        return "§6Inviare una richiesta di amicizia";
+    }
+
+    @Override
+    public String LobbyItems_PLAYER_PARTY() {
+        return "§6Inviare una richiesta per una party";
+    }
+
+    @Override
+    public String LobbyItems_PLAYER_PROFILE() {
+        return "§6Il suo profilo";
+    }
+
+    @Override
+    public String LobbyItems_PLAYER_STATS() {
+        return "§6Statistiche";
+    }
+
+    @Override
+    public String LobbyItems_STATS() {
+        return "§6Le tue statistiche";
+    }
+
+    @Override
+    public String LobbyItems_FRIENDS() {
+        return "§6Amici";
+    }
+
+    @Override
+    public String LobbyItems_SETTINGS() {
+        return "§eOpzioni";
+    }
+
+    @Override
+    public String LobbyItems_SETTINGS_FASTMENU() {
+        return "§6Animazioni dell'inventario";
+    }
+
+    @Override
+    public String LobbyItems_SETTINGS_SERVER_TELEPORT() {
+        return "§6Server-Teleport";
+    }
+
+    @Override
+    public String LobbyItems_SETTINGS_PARTY_REQUESTS() {
+        return "§6Richieste per una party";
+    }
+
+    @Override
+    public String LobbyItems_SETTINGS_FRIEND_REQUESTS() {
+        return "§6Richieste di amicizia";
+    }
+
+    @Override
+    public String LobbyItems_SETTINGS_CHATSOUNDS() {
+        return "§6Suoni del chat";
+    }
+
+    @Override
+    public String LobbyItems_SETTINGS_EFFECTS() {
+        return "§6Effetti";
+    }
+
+    @Override
+    public String LobbyItems_SETTINGS_LANGUAGES() {
+        return "§6Lingue";
+    }
+
+    @Override
+    public String LobbyItems_SETTINGS_ON() {
+        return "§aattivo";
+    }
+
+    @Override
+    public String LobbyItems_SETTINGS_OFF() {
+        return "§cdisattivo";
+    }
+
+    @Override
+    public String LobbyItems_BACK() {
+        return "§cIndietro";
+    }
+
+    @Override
+    public String LobbyBoard_FOUND_SECRETS() {
+        return "§eSegreti§7:";
+    }
+
+    @Override
+    public String LobbyBoard_COINS() {
+        return "§eVenties§7:";
+    }
+
+    @Override
+    public String LobbyBoard_TS() {
+        return "§eTeamSpeak§7:";
+    }
+
+    @Override
+    public String LobbyBoard_FORUM() {
+        return "§eForum§7:";
+    }
+
+    @Override
+    public String LobbyBoard_NEW() {
+        return "§e§lNovità:";
+    }
+
+    @Override
+    public String LobbyBoard_NEWS() {
+        return "Scheibenwischer";
+    }
+
+}

src/main/java/eu/univento/core/api/languages/Languages.java

@@ -0,0 +1,125 @@
+package eu.univento.core.api.languages;
+
+import eu.univento.core.api.player.CustomPlayer;
+import eu.univento.core.api.player.Perms;
+
+/**
+ * @author joethei
+ * @version 0.3
+ */
+public interface Languages{
+
+    String UNKNOWN_ERROR();
+    String NO_PERMS();
+    String ERROR();
+    String NOT_ONLINE(String name);
+    String KICK_RESTART();
+    String KICK_FULL();
+    String COMMAND_NOT_FOUND();
+
+    String Core_FIX_OWN();
+    String Core_FIX_OTHER(CustomPlayer p);
+    String Core_FIX_BY_OTHER(CustomPlayer p);
+    String Core_NICK_ON();
+    String Core_NICK_OFF();
+    String Core_BUILD_ON();
+    String Core_BUILD_OFF();
+    String Core_BAN_NO_REASON();
+    String Core_BAN_USAGE();
+    String Core_BAN_BANNED(CustomPlayer p);
+    String Core_GM_USAGE();
+    String Core_GM_CHANGED();
+    String Core_GLOBALMUTE_ON();
+    String Core_GLOBALMUTE_OFF();
+    String Core_RUNAS_USAGE();
+    String Core_RUNAS_RUN(CustomPlayer p);
+    String Core_SETRANK_USAGE();
+    String Core_SETRANK_KICK();
+    String Core_SETRANK_NO_RANK();
+    String Core_SETRANK_SET(CustomPlayer p, Perms.Ranks rank);
+    String Core_TS_ALLREADY_VERIFIED();
+    String Core_TS_VERIFIED();
+    String Core_VANISH_ON();
+    String Core_VANISH_OFF();
+    String Core_SERVER_MUTED();
+    String Core_CHAT_CLEARED(CustomPlayer p);
+    String Core_TAB_TITLE();
+
+    String Lobby_PLAYERS_HIDE();
+    String Lobby_PLAYERS_SHOW();
+    String Lobby_AUTONICK_ON();
+    String Lobby_AUTONICK_OFF();
+    String Lobby_FORCEFIELD_ON();
+    String Lobby_FORCEFIELD_OFF();
+    String Lobby_SILENT_LOBBY_ON();
+    String Lobby_SILENT_LOBBY_OFF();
+    String Lobby_PLAYING_MUSIC_PREFIX();
+    String Lobby_FOUND_ITEM_PREFIX();
+    String Lobby_SET_LOCATION();
+    String Lobby_SET_LOCATION_USAGE();
+    String Lobby_DROP_ITEM_USAGE();
+    String Lobby_DROP_ITEM();
+    String Lobby_SET_SIGN();
+    String Lobby_JOIN_TITLE_1();
+    String Lobby_JOIN_TITLE_2();
+    String Lobby_PET_ADD();
+    String Lobby_PET_REMOVE();
+    String Lobby_PARKOUR_ON();
+    String Lobby_PARKOUR_OFF();
+
+    String LobbyItems_NAVIGATOR();
+    String LobbyItems_PLAYER_HIDER_ON();
+    String LobbyItems_PLAYER_HIDER_OFF();
+    String LobbyItems_AUTO_NICK();
+    String LobbyItems_SILENT_LOBBY();
+    String LobbyItems_FORCEFIELD();
+    String LobbyItems_FUN_CHEST();
+    String LobbyItems_PROFILE();
+    String LobbyItems_YOUTUBER();
+    String LobbyItems_SUGGESTION();
+    String LobbyItems_SPAWN();
+    String LobbyItems_PREMIUMHUB();
+    String LobbyItems_MAYA();
+    String LobbyItems_WOOLGET();
+    String LobbyItems_BUILDSERVER();
+    String LobbyItems_PLAYERS_ONLINE();
+    String LobbyItems_GADGETS();
+    String LobbyItems_MUSIC();
+    String LobbyItems_PARTICLE();
+    String LobbyItems_PETS();
+    String LobbyItems_YOUR_PET();
+    String LobbyItems_PETS_NAME();
+    String LobbyItems_PETS_AGE();
+    String LobbyItems_PETS_RIDE();
+    String LobbyItems_PETS_REMOVE();
+    String LobbyItems_PETS_PIG();
+    String LobbyItems_PETS_COW();
+    String LobbyItems_PETS_CHICKEN();
+    String LobbyItems_PETS_RABBIT();
+    String LobbyItems_PETS_MUSHROM_COW();
+    String LobbyItems_PLAYER_MENU();
+    String LobbyItems_PLAYER_FRIEND();
+    String LobbyItems_PLAYER_PARTY();
+    String LobbyItems_PLAYER_PROFILE();
+    String LobbyItems_PLAYER_STATS();
+    String LobbyItems_STATS();
+    String LobbyItems_FRIENDS();
+    String LobbyItems_SETTINGS();
+    String LobbyItems_SETTINGS_FASTMENU();
+    String LobbyItems_SETTINGS_SERVER_TELEPORT();
+    String LobbyItems_SETTINGS_PARTY_REQUESTS();
+    String LobbyItems_SETTINGS_FRIEND_REQUESTS();
+    String LobbyItems_SETTINGS_CHATSOUNDS();
+    String LobbyItems_SETTINGS_EFFECTS();
+    String LobbyItems_SETTINGS_LANGUAGES();
+    String LobbyItems_SETTINGS_ON();
+    String LobbyItems_SETTINGS_OFF();
+    String LobbyItems_BACK();
+
+    String LobbyBoard_FOUND_SECRETS();
+    String LobbyBoard_COINS();
+    String LobbyBoard_NEW();
+    String LobbyBoard_NEWS();
+    String LobbyBoard_TS();
+    String LobbyBoard_FORUM();
+}

src/main/java/eu/univento/core/api/languages/Messages.java

@@ -0,0 +1,314 @@
+package eu.univento.core.api.languages;
+
+import eu.univento.core.api.player.CustomPlayer;
+import eu.univento.core.api.player.Perms;
+
+
+/**
+ * @author joethei
+ * @version 2.0
+ */
+public class Messages {
+
+     CustomPlayer player;
+
+    Language_DE de = new Language_DE();
+    Language_EN en = new Language_EN();
+    Language_IT it = new Language_IT();
+
+    Languages lang;
+
+    public Messages(CustomPlayer player) {
+        this.player = player;
+        if(player.getLanguage().equals("DE")) this.lang = de;
+        if(player.getLanguage().equals("IT")) this.lang = it;
+        if(player.getLanguage().equals("EN")) this.lang = en;
+    }
+
+    public String PREFIX() {
+        return " §6univento §8» ";
+    }
+    public String TAB_PREFIX() { return "§8• §6U N I V E N T O §8• ";}
+
+    public String UNKNOWN_ERROR() {
+        return lang.UNKNOWN_ERROR();
+    }
+    public String NO_PERMS() {
+        return lang.NO_PERMS();
+    }
+    public String ERROR() {
+        return lang.ERROR();
+    }
+    public String NOT_ONLINE(String name) {
+        return lang.NOT_ONLINE(name);
+    }
+    public String KICK_RESTART() {
+        return lang.KICK_RESTART();
+    }
+    public String KICK_FULL() {
+        return lang.KICK_FULL();
+    }
+    public String COMMAND_NOT_FOUND() {
+        return lang.COMMAND_NOT_FOUND();
+    }
+
+    public String Core_FIX_OWN() {
+        return lang.Core_FIX_OWN();
+    }
+    public String Core_FIX_OTHER(CustomPlayer p) {
+        return lang.Core_FIX_OTHER(p);
+    }
+    public String Core_FIX_BY_OTHER(CustomPlayer p) {
+        return lang.Core_FIX_BY_OTHER(p);
+    }
+    public String Core_NICK_ON() {
+        return lang.Core_NICK_ON();
+    }
+    public String Core_NICK_OFF() {
+        return lang.Core_NICK_OFF();
+    }
+    public String Core_BUILD_ON() {
+        return lang.Core_BUILD_ON();
+    }
+    public String Core_BUILD_OFF() {
+        return lang.Core_BUILD_OFF();
+    }
+    public String Core_BAN_NO_REASON() {
+        return lang.Core_BAN_NO_REASON();
+    }
+    public String Core_BAN_USAGE() {
+        return lang.Core_BAN_USAGE();
+    }
+    public String Core_BAN_BANNED(CustomPlayer p) {
+        return lang.Core_BAN_BANNED(p);
+    }
+    public String Core_GM_USAGE() {
+        return lang.Core_GM_USAGE();
+    }
+    public String Core_GM_CHANGED() {
+        return lang.Core_GM_CHANGED();
+    }
+    public String Core_GLOBALMUTE_ON() {
+        return lang.Core_GLOBALMUTE_ON();
+    }
+    public String Core_GLOBALMUTE_OFF() {
+        return lang.Core_GLOBALMUTE_OFF();
+    }
+    public String Core_RUNAS_USAGE() {
+        return lang.Core_RUNAS_USAGE();
+    }
+    public String Core_RUNAS_RUN(CustomPlayer p) {
+        return lang.Core_RUNAS_RUN(p);
+    }
+    public String Core_SETRANK_USAGE() {
+        return lang.Core_SETRANK_USAGE();
+    }
+    public String Core_SETRANK_KICK() {
+        return lang.Core_SETRANK_KICK();
+    }
+    public String Core_SETRANK_NO_RANK() {
+        return lang.Core_SETRANK_NO_RANK();
+    }
+    public String Core_SETRANK_SET(CustomPlayer p, Perms.Ranks rank) {
+        return lang.Core_SETRANK_SET(p, rank);
+    }
+    public String Core_TS_ALLREADY_VERIFIED() {
+        return lang.Core_TS_ALLREADY_VERIFIED();
+    }
+    public String Core_TS_VERIFIED() {
+        return lang.Core_TS_VERIFIED();
+    }
+    public String Core_VANISH_ON() {
+        return lang.Core_VANISH_ON();
+    }
+    public String Core_VANISH_OFF() {
+        return lang.Core_VANISH_OFF();
+    }
+    public String Core_SERVER_MUTED() {
+        return lang.Core_SERVER_MUTED();
+    }
+    public String Core_CHAT_CLEARED(CustomPlayer p) { return lang.Core_CHAT_CLEARED(p);}
+    public String Core_TAB_TITLE() { return lang.Core_TAB_TITLE(); }
+
+    public String Lobby_PLAYERS_HIDE() {
+        return lang.Lobby_PLAYERS_HIDE();
+    }
+    public String Lobby_PLAYERS_SHOW() {
+        return lang.Lobby_PLAYERS_SHOW();
+    }
+    public String Lobby_AUTONICK_ON() {
+        return lang.Lobby_AUTONICK_ON();
+    }
+    public String Lobby_AUTONICK_OFF() {
+        return lang.Lobby_AUTONICK_OFF();
+    }
+    public String Lobby_FORCEFIELD_ON() {
+        return lang.Lobby_FORCEFIELD_ON();
+    }
+    public String Lobby_FORCEFIELD_OFF() {
+        return lang.Lobby_FORCEFIELD_OFF();
+    }
+    public String Lobby_SILENT_LOBBY_ON() {
+        return lang.Lobby_SILENT_LOBBY_ON();
+    }
+    public String Lobby_SILENT_LOBBY_OFF() {
+        return lang.Lobby_SILENT_LOBBY_OFF();
+    }
+    public String Lobby_PLAYING_MUSIC_PREFIX() {
+        return lang.Lobby_PLAYING_MUSIC_PREFIX();
+    }
+    public String Lobby_FOUND_ITEM_PREFIX() {
+        return lang.Lobby_FOUND_ITEM_PREFIX();
+    }
+    public String Lobby_SET_LOCATION() {
+        return lang.Lobby_SET_LOCATION();
+    }
+    public String Lobby_SET_LOCATION_USAGE() {
+        return lang.Lobby_SET_LOCATION_USAGE();
+    }
+    public String Lobby_DROP_ITEM_USAGE() {
+        return lang.Lobby_DROP_ITEM_USAGE();
+    }
+    public String Lobby_DROP_ITEM() {
+        return lang.Lobby_DROP_ITEM();
+    }
+    public String Lobby_SET_SIGN() {
+        return lang.Lobby_SET_SIGN();
+    }
+    public String Lobby_JOIN_TITLE_1() {
+        return lang.Lobby_JOIN_TITLE_1();
+    }
+    public String Lobby_JOIN_TITLE_2() {
+        return lang.Lobby_JOIN_TITLE_2();
+    }
+    public String Lobby_PET_ADD() {
+        return lang.Lobby_PET_ADD();
+    }
+    public String Lobby_PET_REMOVE() {
+        return lang.Lobby_PET_REMOVE();
+    }
+    public String Lobby_PARKOUR_ON() {
+        return lang.Lobby_PARKOUR_ON();
+    }
+    public String Lobby_PARKOUR_OFF() {
+        return lang.Lobby_PARKOUR_OFF();
+    }
+
+    public String LobbyItems_NAVIGATOR() {
+        return lang.LobbyItems_NAVIGATOR();
+    }
+    public String LobbyItems_PLAYER_HIDER_ON() {
+        return lang.LobbyItems_PLAYER_HIDER_ON();
+    }
+    public String LobbyItems_PLAYER_HIDER_OFF() {
+        return lang.LobbyItems_PLAYER_HIDER_OFF();
+    }
+    public String LobbyItems_AUTO_NICK() {
+        return lang.LobbyItems_AUTO_NICK();
+    }
+    public String LobbyItems_SILENT_LOBBY() {
+        return lang.LobbyItems_SILENT_LOBBY();
+    }
+    public String LobbyItems_FORCEFIELD() {
+        return lang.LobbyItems_FORCEFIELD();
+    }
+    public String LobbyItems_FUN_CHEST() {
+        return lang.LobbyItems_FUN_CHEST();
+    }
+    public String LobbyItems_PROFILE() {
+        return lang.LobbyItems_PROFILE();
+    }
+    public String LobbyItems_YOUTUBER() { return lang.LobbyItems_YOUTUBER(); }
+    public String LobbyItems_SUGGESTION() { return lang.LobbyItems_SUGGESTION(); }
+    public String LobbyItems_SPAWN() {
+        return lang.LobbyItems_SPAWN();
+    }
+    public String LobbyItems_PREMIUMHUB() {
+        return lang.LobbyItems_PREMIUMHUB();
+    }
+    public String LobbyItems_MAYA() {
+        return lang.LobbyItems_MAYA();
+    }
+    public String LobbyItems_WOOLGET() { return lang.LobbyItems_WOOLGET(); }
+    public String LobbyItems_BUILDSERVER() {
+        return lang.LobbyItems_BUILDSERVER();
+    }
+    public String LobbyItems_PLAYERS_ONLINE() {
+        return lang.LobbyItems_PLAYERS_ONLINE();
+    }
+    public String LobbyItems_GADGETS() {
+        return lang.LobbyItems_GADGETS();
+    }
+    public String LobbyItems_MUSIC() {
+        return lang.LobbyItems_MUSIC();
+    }
+    public String LobbyItems_PARTICLE() {
+        return lang.LobbyItems_PARTICLE();
+    }
+    public String LobbyItems_PETS() {
+        return lang.LobbyItems_PETS();
+    }
+    public String LobbyItems_YOUR_PET() { return lang.LobbyItems_YOUR_PET(); }
+    public String LobbyItems_PETS_NAME() { return lang.LobbyItems_PETS_NAME(); }
+    public String LobbyItems_PETS_AGE() { return lang.LobbyItems_PETS_AGE(); }
+    public String LobbyItems_PETS_RIDE() { return lang.LobbyItems_PETS_RIDE(); }
+    public String LobbyItems_PETS_REMOVE() { return lang.LobbyItems_PETS_REMOVE(); }
+    public String LobbyItems_PETS_PIG() { return lang.LobbyItems_PETS_PIG(); }
+    public String LobbyItems_PETS_COW() { return lang.LobbyItems_PETS_COW(); }
+    public String LobbyItems_PETS_CHICKEN() { return lang.LobbyItems_PETS_CHICKEN(); }
+    public String LobbyItems_PETS_RABBIT() { return lang.LobbyItems_PETS_RABBIT(); }
+    public String LobbyItems_PETS_MUSHROM_COW () { return lang.LobbyItems_PETS_MUSHROM_COW(); }
+    public String LobbyItems_PLAYER_MENU() { return lang.LobbyItems_PLAYER_MENU(); }
+    public String LobbyItems_PLAYER_FRIEND() { return lang.LobbyItems_PLAYER_FRIEND(); }
+    public String LobbyItems_PLAYER_PARTY() { return lang.LobbyItems_PLAYER_PARTY(); }
+    public String LobbyItems_PLAYER_PROFILE() { return lang.LobbyItems_PLAYER_PROFILE(); }
+    public String LobbyItems_PLAYER_STATS() { return lang.LobbyItems_PLAYER_STATS();}
+    public String LobbyItems_STATS() {
+        return lang.LobbyItems_STATS();
+    }
+    public String LobbyItems_FRIENDS() {
+        return lang.LobbyItems_FRIENDS();
+    }
+    public String LobbyItems_SETTINGS() {
+        return lang.LobbyItems_SETTINGS();
+    }
+    public String LobbyItems_SETTINGS_FASTMENU() { return lang.LobbyItems_SETTINGS_FASTMENU();}
+    public String LobbyItems_SETTINGS_SERVER_TELEPORT() { return lang.LobbyItems_SETTINGS_SERVER_TELEPORT(); }
+    public String LobbyItems_SETTINGS_PARTY_REQUESTS() {
+        return lang.LobbyItems_SETTINGS_PARTY_REQUESTS();
+    }
+    public String LobbyItems_SETTINGS_FRIEND_REQUESTS() {
+        return lang.LobbyItems_SETTINGS_FRIEND_REQUESTS();
+    }
+    public String LobbyItems_SETTINGS_CHATSOUNDS() {
+        return lang.LobbyItems_SETTINGS_CHATSOUNDS();
+    }
+    public String LobbyItems_SETTINGS_EFFECTS() {
+        return lang.LobbyItems_SETTINGS_EFFECTS();
+    }
+    public String LobbyItems_SETTINGS_LANGUAGES() {
+        return lang.LobbyItems_SETTINGS_LANGUAGES();
+    }
+    public String LobbyItems_SETTINGS_ON() {
+        return lang.LobbyItems_SETTINGS_ON();
+    }
+    public String LobbyItems_SETTINGS_OFF() {
+        return lang.LobbyItems_SETTINGS_OFF();
+    }
+    public String LobbyItems_BACK() { return lang.LobbyItems_BACK(); }
+
+    public String LobbyBoard_COINS() { return lang.LobbyBoard_COINS(); }
+    public String LobbyBoard_NEW() { return lang.LobbyBoard_NEW(); }
+    public String LobbyBoard_NEWS() { return lang.LobbyBoard_NEWS(); }
+    public String LobbyBoard_TS() { return lang.LobbyBoard_TS(); }
+    public String LobbyBoard_FORUM() { return lang.LobbyBoard_FORUM(); }
+    public String LobbyBoard_FOUND_SECRETS() { return lang.LobbyBoard_FOUND_SECRETS(); }
+
+        public class Build {
+            public String PREFIX = "• §bTeam§3Vento • ";
+        }
+
+    public static class Console{
+        public static String NOT_A_PLAYER = "You are not a valid player";
+    }
+}

src/main/java/eu/univento/core/api/player/BanSystem.java

@@ -0,0 +1,148 @@
+package eu.univento.core.api.player;
+
+import eu.univento.core.Core;
+import eu.univento.core.api.database.MySQL;
+import eu.univento.core.api.utils.NameFetcher;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.UUID;
+
+/**
+ * bans and unbans players
+ * @author joethei
+ * @version 1.2
+ */
+public class BanSystem{
+	
+ /**
+ * sets player banned
+ * @param p player
+ * @param reason reason
+ * @param who who banned
+ * @param time duration
+ * @throws SQLException SQL server not available or throwing error
+ * @throws ClassNotFoundException class couldn't be found
+ */
+static void setBanned(CustomPlayer p, String reason, CustomPlayer who, int time)throws SQLException, ClassNotFoundException {
+    int id = p.getID();
+	MySQL sql = Core.returnSQL();
+	sql.openConnection();
+    
+    Date date = new Date();
+    date.setTime(date.getTime() + (time * 24));
+    Timestamp timestamp = new Timestamp(date.getTime());
+    
+    PreparedStatement st = sql.getConnection().prepareStatement("INSERT INTO bans (BID, Reason, until, BannerID) VALUES ('" + id + "', '" + reason + "', '" + who.getID() + "', '" + timestamp + "');");
+    st.execute();
+    p.kickPlayer("§cYou have been banned. §6Reason: " + reason + "\nUntil: " + timestamp);
+    who.sendMessage("§cDu hast den Spieler " + p.getColor() + p.getName() + "§c für " + time + " Tage gebannt wegen " + reason);
+    sql.closeConnection();
+  }
+
+/**
+ * unbans a player
+ * @param p player
+ * @throws SQLException SQL server not available or throwing error
+ * @throws ClassNotFoundException class couldn't be found
+ */
+static void removeAllBans(CustomPlayer p) throws SQLException, ClassNotFoundException{
+    int id = p.getID();
+	MySQL sql = Core.returnSQL();
+	sql.openConnection();
+	PreparedStatement st = sql.getConnection().prepareStatement("DELETE FROM bans WHERE ID ='" + id + "';");
+	st.execute();
+    sql.closeConnection();
+  }
+
+/**
+ * checks if player is banned
+ * @param p player
+ * @return true /false
+ * @throws SQLException SQL server not available or throwing error
+ * @throws ClassNotFoundException class couldn't be found
+ */
+static boolean isBanned(CustomPlayer p) throws SQLException, ClassNotFoundException {
+    int id = p.getID();
+	MySQL sql = Core.returnSQL();
+	PreparedStatement st = sql.getConnection().prepareStatement("SELECT * FROM bans WHERE BID='" + id + "';");
+    ResultSet rs = st.executeQuery();
+    if(rs.next()) {
+        Date date = new Date();
+        Timestamp time = new Timestamp(date.getTime());
+        sql.closeConnection();
+        return time.before(getBanTime(p));
+    }else {
+    	sql.closeConnection();
+    	return false;
+    }
+
+  }
+
+    static Timestamp getBanTime(CustomPlayer p) throws SQLException {
+        int id = p.getID();
+        MySQL sql = Core.returnSQL();
+        PreparedStatement st = sql.getConnection().prepareStatement("SELECT * FROM bans WHERE ID='" + id + "';");
+        ResultSet rs = st.executeQuery();
+        if(rs.next()) {
+            Timestamp time = rs.getTimestamp("until");
+            sql.closeConnection();
+            return time;
+        }
+        sql.closeConnection();
+        return null;
+    }
+
+/**
+ * return reason for ban
+ * @param p player
+ * @return String
+ * @throws SQLException SQL server not available or throwing error
+ * @throws ClassNotFoundException class couldn't be found
+ */
+static String getBanReason(CustomPlayer p)throws SQLException, ClassNotFoundException {
+    int id = p.getID();
+	MySQL sql = Core.returnSQL();
+	sql.openConnection();
+	PreparedStatement st = sql.getConnection().prepareStatement("SELECT * FROM bans WHERE ID='" + id + "';");
+    ResultSet rs = st.executeQuery();
+    if(rs.next()) {
+    	String reason = rs.getString("Reason");
+    	sql.closeConnection();
+    	return reason;
+    }else {
+    	sql.closeConnection();
+    	return null;
+    }
+  }
+
+/**
+ * gets the name of the player who banned the player
+ * @param p player
+ * @return String
+ * @throws SQLException SQL server not available or throwing error
+ * @throws ClassNotFoundException class couldn't be found
+ */
+static String getWhoBanned(CustomPlayer p)throws SQLException, ClassNotFoundException {
+    int id = p.getID();
+	MySQL sql = Core.returnSQL();
+	sql.openConnection();
+    ResultSet rs = Core.returnSQL().getConnection().createStatement().executeQuery("SELECT * FROM bans WHERE ID='" + id + "';");
+    if (!rs.next()) {
+    	sql.closeConnection();
+    	return null;
+    }
+    String whouuid = rs.getString("who");
+    UUID who = UUID.fromString(whouuid);
+    List<UUID> list = new ArrayList<>();
+    list.add(who);
+    NameFetcher name = new NameFetcher(list);
+    sql.closeConnection();
+    return name.toString();
+  }
+}

src/main/java/eu/univento/core/api/player/Coins.java

@@ -0,0 +1,60 @@
+package eu.univento.core.api.player;
+
+import eu.univento.core.Core;
+import eu.univento.core.api.database.MySQL;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+/**
+ * coins management
+ * @author joethei
+ * @version 1.0
+ */
+public class Coins{
+	
+	/**
+	 * gets coins from player
+	 * @param p CustomPlayer
+	 * @return coins as integer
+	 */
+	static int getCoins(CustomPlayer p) {
+		int id = p.getID();
+		MySQL sql = Core.returnSQL();
+		try {
+			sql.openConnection();
+			PreparedStatement st = sql.getConnection().prepareStatement("SELECT Coins FROM users WHERE ID='" + id + "';");
+			ResultSet rs = st.executeQuery();
+			if(rs.next()) {
+				int coins = rs.getInt("Coins");
+				sql.closeConnection();
+				return coins;
+			}
+			return 0;
+		} catch (ClassNotFoundException | SQLException e) {
+			e.printStackTrace();
+			return 0;
+		}
+	}
+	
+	/**
+	 * sets coins of player
+	 * @param p CustomPlayer
+	 * @param coins coins to set
+	 */
+	static void setCoins(CustomPlayer p, int coins) {
+		int id = p.getID();
+		MySQL sql = Core.returnSQL();
+		try {
+			sql.openConnection();
+			PreparedStatement st = sql.getConnection().prepareStatement("UPDATE users SET Coins='" + coins + "' WHERE ID='" + id + "';");
+			st.execute();
+			sql.closeConnection();
+		} catch (ClassNotFoundException | SQLException e) {
+			e.printStackTrace();
+		}
+		
+	}
+
+}

src/main/java/eu/univento/core/api/player/CustomPlayer.java

@@ -0,0 +1,832 @@
+package eu.univento.core.api.player;
+
+import eu.univento.core.Core;
+import eu.univento.core.api.Actionbar;
+import eu.univento.core.api.Utils;
+import eu.univento.core.api.database.MySQL;
+import eu.univento.core.api.effects.Effects;
+import eu.univento.core.api.languages.Messages;
+import eu.univento.core.api.server.Game;
+import eu.univento.core.api.server.ServerSettings;
+import eu.univento.core.api.server.Servers;
+import eu.univento.core.api.utils.NameFetcher;
+import net.minecraft.server.v1_9_R1.EnumParticle;
+import org.bukkit.Bukkit;
+import org.bukkit.Color;
+import org.bukkit.Location;
+import org.bukkit.Sound;
+import org.bukkit.attribute.Attribute;
+import org.bukkit.attribute.AttributeModifier;
+import org.bukkit.craftbukkit.v1_9_R1.CraftServer;
+import org.bukkit.craftbukkit.v1_9_R1.entity.CraftPlayer;
+import org.bukkit.entity.Player;
+import org.bukkit.scoreboard.Team;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Timestamp;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * custom player implementation
+ * @author joethei
+ * @version 1.0
+ */
+public class CustomPlayer extends CraftPlayer {
+
+    /**
+     * all normal players
+     */
+    private static final HashMap<String, CustomPlayer> PLAYERS = new HashMap<>();
+
+    /**
+     * normal player
+     */
+    private final Player PLAYER;
+
+    /**
+     * custom prefix for chat
+     */
+    private String customPrefix;
+    /**
+     * custom suffix for chat
+     */
+    private String customSuffix;
+    /**
+     * custom color for chat
+     */
+    private String customColor;
+
+    /**
+     * player id from database
+     */
+    private int id = 0;
+
+    /**
+     * if player has open inventory
+     */
+    private boolean openInventory;
+
+    //private MongoDB mongoDB = Core.getMongoDB();
+    //private MongoCollection userCollection = mongoDB.getDatabase().getCollection("users");
+
+    /**
+     * inits player
+     *
+     * @param player Player
+     */
+    private CustomPlayer(Player player) {
+        super((CraftServer) Bukkit.getServer(), ((CraftPlayer) player).getHandle());
+        PLAYERS.put(player.getName().toLowerCase(), this);
+        PLAYER = player;
+        id = getID();
+    }
+
+    /**
+     * called on player leaving
+     */
+    public void onLeave() {
+        /**
+        Date date = new Date();
+        Document doc = new Document("uuid", getUniqueId());
+        userCollection.updateOne(doc, new Document("$set", new Document("lastOnline", date)));
+
+        HashMap<String, Object> location = new HashMap<>();
+        location.put("X", getLocation().getX());
+        location.put("Y", getLocation().getY());
+        location.put("Z", getLocation().getZ());
+        location.put("Yaw", getLocation().getYaw());
+        location.put("Pitch", getLocation().getPitch());
+
+        userCollection.updateOne(doc, new Document("$set", new Document("Pos", new Document("Loc", location))));
+
+         */
+        if (PLAYERS.containsKey(getName().toLowerCase())) PLAYERS.remove(getName().toLowerCase());
+    }
+
+    /**
+     * init player
+     *
+     * @param player Player
+     * @return CustomPlayer
+     */
+    public static CustomPlayer getPlayer(String player) {
+        if (PLAYERS.containsKey(player.toLowerCase())) {
+            return PLAYERS.get(player.toLowerCase());
+        } else {
+            Player p = Bukkit.getPlayer(player);
+            return p == null ? null : new CustomPlayer(p);
+        }
+    }
+
+    /**
+     * gets custom player from player
+     *
+     * @param player Player
+     * @return CustomPlayer
+     */
+    public static CustomPlayer getPlayer(Player player) {
+        return getPlayer(player.getName());
+    }
+
+    /**
+     * gets custom player from database id
+     *
+     * @param id database id of player
+     * @return CustomPlayer
+     */
+    public static CustomPlayer getPlayer(int id) {
+        MySQL sql = Core.returnSQL();
+        try {
+            sql.openConnection();
+            PreparedStatement st = sql.getConnection().prepareStatement("SELECT ID, UUID FROM users WHERE ID='" + id + "');");
+            ResultSet rs = st.executeQuery();
+            String uuidString = rs.getString("UUID");
+            sql.closeConnection();
+            UUID uuid = UUID.fromString(uuidString);
+            NameFetcher names = new NameFetcher(Arrays.asList(uuid));
+            Map<UUID, String> map = null;
+            try {
+                map = names.call();
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+            String name = map.toString();
+            String Name = name.substring(name.indexOf('=') + 1, name.indexOf('}'));
+
+            return CustomPlayer.getPlayer(Name);
+
+        } catch (ClassNotFoundException | SQLException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    /**
+     * gets database id of player
+     *
+     * @return Integer
+     */
+    public int getID() {
+        if (id == 0) {
+            MySQL sql = Core.returnSQL();
+            try {
+                sql.openConnection();
+                String uuid = this.getUniqueId().toString();
+                PreparedStatement st = sql.getConnection().prepareStatement("SELECT * FROM users WHERE UUID ='" + uuid + "';");
+                ResultSet rs = st.executeQuery();
+                if (rs.next()) {
+                    int id = rs.getInt("ID");
+                    this.id = id;
+                    sql.closeConnection();
+                    return id;
+                } else {
+                    sql.closeConnection();
+
+                    return 0;
+                }
+            } catch (ClassNotFoundException | SQLException e) {
+                e.printStackTrace();
+                return 0;
+            }
+        } else {
+            return id;
+        }
+    }
+
+    /**
+     * get normal player
+     *
+     * @return Player
+     */
+    public Player getPLAYER() {
+        return PLAYER;
+    }
+
+    /**
+    public void insertToDatabase() {
+        DBObject obj = new BasicDBObject("uuid", getUniqueId());
+        Date date = new Date();
+
+        obj.put("rank", "Player");
+        obj.put("firstLogin", date);
+        obj.put("lastLogin", date);
+        obj.put("lastOnline", date);
+        obj.put("lastIP", spigot().getRawAddress().getHostName());
+        obj.put("tsid", 0);
+        obj.put("timesJoined", 1);
+        obj.put("timePlayed", 0);
+        obj.put("coins", 0);
+        obj.put("experience", 0);
+        obj.put("secrets", 0);
+        obj.put("foundSecrets", new ArrayList<String>());
+        obj.put("foundEggs", new ArrayList<String>());
+
+        HashMap<String, Object> settings = new HashMap<>();
+        settings.put("playerVisibility", "all");
+        settings.put("inventoryAnimation", true);
+        settings.put("teleportAnimation", true);
+        settings.put("partyRequests", true);
+        settings.put("friendRequests", true);
+        settings.put("friendJump", true);
+        settings.put("chatSounds", true);
+        settings.put("effects", true);
+        settings.put("storyMode", true);
+        settings.put("language", "EN");
+
+        obj.put("Settings", settings);
+
+        HashMap<String, Object> location = new HashMap<>();
+        location.put("X", getLocation().getX());
+        location.put("Y", getLocation().getY());
+        location.put("Z", getLocation().getZ());
+        location.put("Yaw", getLocation().getYaw());
+        location.put("Pitch", getLocation().getPitch());
+
+        obj.put("Pos", location);
+        userCollection.insertOne(obj);
+    }
+
+    public void updateDatabaseEntry() {
+        Date date = new Date();
+        Document doc = new Document("uuid", getUniqueId());
+        userCollection.updateOne(doc, new Document("$set", new Document("lastLogin", date)));
+        userCollection.updateOne(doc, new Document("$set", new Document("lastIP", spigot().getRawAddress().getHostName().toString())));
+        userCollection.updateOne(doc, new Document("$set", new Document("timesPlayed", getTimesJoined() + 1)));
+    }
+
+
+    public void setRank(Perms.Ranks rank) {
+        userCollection.updateOne(new Document("uuid", getUniqueId()), new Document("$set", new Document("rank", rank.toString())));
+    }
+
+    public void setTSID(int id) {
+        userCollection.updateOne(new Document("uuid", getUniqueId()), new Document("$set", new Document("tsid", id)));
+    }
+
+    public void setCoins(int coins) {
+        userCollection.updateOne(new Document("uuid", getUniqueId()), new Document("$set", new Document("coins", coins)));
+    }
+
+    public void setExperience(int experience) {
+        userCollection.updateOne(new Document("uuid", getUniqueId()), new Document("$set", new Document("experience", experience)));
+    }
+
+    public void setSecrets(int secrets) {
+        userCollection.updateOne(new Document("uuid", getUniqueId()), new Document("$set", new Document("secrets", secrets)));
+    }
+
+
+    private Object getObjectFromDatbase(String name) {
+        FindIterable<Document> cursor = userCollection.find(new Document("uuid", getUniqueId()));
+        cursor.cursorType(CursorType.NonTailable);
+
+        Document doc = cursor.first();
+        if (doc == null) {
+            return null;
+        }
+        return doc.get(name);
+    }
+
+    private int getIntegerFromDatabase(String name) {
+        FindIterable<Document> cursor = userCollection.find(new Document("uuid", getUniqueId()));
+        cursor.cursorType(CursorType.NonTailable);
+
+        Document doc = cursor.first();
+        if (doc == null) {
+            return 0;
+        }
+        return doc.getInteger(name);
+    }
+
+    private String getStringFromDatabase(String name) {
+        FindIterable<Document> cursor = userCollection.find(new Document("uuid", getUniqueId()));
+        cursor.cursorType(CursorType.NonTailable);
+
+        Document doc = cursor.first();
+        if (doc == null) {
+            return null;
+        }
+        return doc.getString(name);
+    }
+
+    private Date getDateFromDatabase(String name) {
+        FindIterable<Document> cursor = userCollection.find(new Document("uuid", getUniqueId()));
+        cursor.cursorType(CursorType.NonTailable);
+
+        Document doc = cursor.first();
+        if (doc == null) {
+            return null;
+        }
+        return doc.getDate(name);
+    }
+
+    public Perms.Ranks getRank() {
+        return Perms.Ranks.valueOf(getStringFromDatabase("rank"));
+    }
+
+    public Date getFirstLogin() {
+        return getDateFromDatabase("firstLogin");
+    }
+
+    public Date getLastLogin() {
+        return getDateFromDatabase("lastLogin");
+    }
+
+    public Date getLastOnline() {
+        return getDateFromDatabase("lastOnline");
+    }
+
+    public String getLastIP() {
+        return getStringFromDatabase("lastIP");
+    }
+
+    public int getTSID() {
+        return getIntegerFromDatabase("tsid");
+    }
+
+    public int getTimesJoined() {
+    return getIntegerFromDatabase("timesJoined");
+    }
+
+    public int getCoins() {
+        return getIntegerFromDatabase("coins");
+    }
+
+    public int getExperience() {
+        return getIntegerFromDatabase("experience");
+    }
+
+    public int getSecrets() {
+        return getIntegerFromDatabase("secrets");
+    }
+
+    public ArrayList<String> getFoundSecrets() {
+        return (ArrayList<String>) getObjectFromDatbase("foundSecrets");
+    }
+
+    public ArrayList<String> getFoundEggs() {
+        return (ArrayList<String>) getObjectFromDatbase("foundEggs");
+    }
+
+    public HashMap<String, Object> getSettings() {
+        return (HashMap<String, Object>) getObjectFromDatbase("settings");
+    }
+     */
+	/**
+	 * connects player to server in bungeecord
+	 * @param server ServerPinger to connect to
+	 */
+	public void connectToServer(String server) {
+		Servers.connectServer(PLAYER, server);
+	}
+	
+	/**
+	 * if player is allowed to do stuff
+	 * @param rank Ranks
+	 * @return true/false
+	 */
+	public boolean isAllowed(Perms.Ranks rank) {
+		try {
+			return Perms.isAllowed(this, rank);
+		} catch (ClassNotFoundException | SQLException e) {
+			e.printStackTrace();
+			return false;
+		}
+	}
+		
+	/**
+	 * rank of player
+	 * @return Ranks
+	 */
+	public Perms.Ranks getRank() {
+		try {
+			return Perms.getRank(this);
+		} catch (ClassNotFoundException | SQLException e) {
+			e.printStackTrace();
+			return Perms.Ranks.Player;
+		}
+	}
+
+	public Perms.Ranks getFreshRank() {
+		try{
+			return Perms.getRankFresh(this);
+		}catch (ClassNotFoundException | SQLException e) {
+			e.printStackTrace();
+			return Perms.Ranks.Player;
+		}
+	}
+
+    /**
+     * sets rank of this custom player
+     * @param r Ranks
+     */
+	public void setRank(Perms.Ranks r) {
+        try {
+            Perms.setRank(this, r);
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+	
+	/**
+	 * prefix of player
+	 * @return String
+	 */
+	public String getPrefix() {
+		if(customPrefix != null) return customPrefix;
+        if(isNicked()) return Perms.getPrefix(Perms.Ranks.Premium);
+        return Perms.getPrefix(getRank());
+	}
+	
+	/**
+	 * suffix of player
+	 * @return String
+	 */
+	public String getSuffix() {
+		if(customSuffix != null) return customSuffix;
+        if(isNicked()) return Perms.getSuffix(Perms.Ranks.Premium);
+		return Perms.getSuffix(getRank());
+	}
+	
+	/**
+	 * color of player (Ranks)
+	 * @return String
+	 */
+	public String getColor() {
+		if(customColor != null) return customColor;
+        if(isNicked()) return Perms.getColor(Perms.Ranks.Premium);
+		return Perms.getColor(getRank());
+	}
+
+	public Color getArmorColor() {
+        return Perms.getArmorColor(getRank());
+    }
+	
+	/**
+	 * sets a custom prefix
+	 * @param prefix String
+	 */
+	public void setCustomPrefix(String prefix) {
+		customPrefix = prefix;
+	}
+	
+	/**
+	 * sets a custom suffix
+	 * @param suffix String
+	 */
+	public void setCustomSuffix(String suffix) {
+		customSuffix = suffix;
+	}
+	
+	/**
+	 * sets a custom color
+	 * @param color String
+	 */
+	public void setCustomColor(String color) {
+		customColor = color;
+	}
+	
+	/**
+	 * gets scoreboard team for player
+	 * @return Team
+	 */
+	public Team getTeam() {
+        Perms.Teams teams = new Perms.Teams(this);
+		if(isNicked()) {
+			return teams.Premium;
+		}else {
+            return Perms.Teams.getTeam(this);
+		}
+	}
+		
+	/**
+	 * bans player
+	 * @param reason why ban him ?
+	 * @param who who banned him ?
+	 * @param time ban duration
+	 */
+	public void ban(String reason, CustomPlayer who, Integer time) {
+		try {
+			BanSystem.setBanned(this, reason, who, time);
+		} catch (SQLException | ClassNotFoundException e) {
+			e.printStackTrace();
+		}
+	}
+	/**
+	 * if player is banned
+	 * @return true/false
+	 */
+	public boolean isBanned() {
+		try {
+			return BanSystem.isBanned(this);
+		} catch (SQLException | ClassNotFoundException e) {
+			e.printStackTrace();
+			return false;
+		}
+	}
+	
+	/**
+	 * get ban reason
+	 * @return String
+	 */
+	public String getBanReason() {
+		try {
+			return BanSystem.getBanReason(this);
+		} catch (SQLException | ClassNotFoundException e) {
+			e.printStackTrace();
+			return null;
+		}
+		
+	}
+	
+	/**
+	 * get uuid of player who banned
+	 * @return String
+	 */
+	public String getWhoBanned() {
+		try {
+			return BanSystem.getWhoBanned(this);
+		} catch (SQLException | ClassNotFoundException e) {
+			e.printStackTrace();
+			return null;
+		}
+	}
+
+	public Timestamp getBanTime() {
+        try {
+            return BanSystem.getBanTime(this);
+        } catch (SQLException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+	
+	/**
+	 * unbans the player
+	 */
+	public void removeAllBans() {
+		try {
+			BanSystem.removeAllBans(this);
+		} catch (SQLException | ClassNotFoundException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	/**
+	 * get nickname of player
+	 * @return String
+	 */
+	public String getNick() {
+		return NickName.getNick(this);
+	}
+	
+	/**
+	 * if player is nicked
+	 * @return true/false
+	 */
+	public boolean isNicked() {
+        if(ServerSettings.isGame()) {
+            try {
+                return NickName.isNicked(this);
+            } catch (SQLException | ClassNotFoundException e) {
+                e.printStackTrace();
+                return false;
+            }
+        }
+        return false;
+	}
+
+    /**
+     * checks if player is nicked
+     * @return true/false
+     */
+	public boolean isNickedReal() {
+        try {
+            return NickName.isNicked(this);
+        } catch (SQLException | ClassNotFoundException e) {
+            e.printStackTrace();
+        }
+        return false;
+    }
+	
+	/**
+	 * sets nickname
+	 * @param is boolean
+	 */
+	public void setNicked(boolean is) {
+		try {
+			NickName.setNick(this, is);
+		} catch (SQLException | ClassNotFoundException e) {
+			e.printStackTrace();
+		}
+	}
+
+    public void nick(String nick) {
+        NickName.setName(this, nick);
+        NickName.changeSkin(this, nick);
+    }
+
+    public void unnick() {
+        NickName.changeSkin(this, getName());
+        NickName.setName(this, getName());
+    }
+	
+	/**
+	 * checks if player has played on the network before
+	 * @return true/false
+	 */
+	@Override
+	public boolean hasPlayedBefore() {
+		MySQL sql = Core.returnSQL();
+		try {
+			sql.openConnection();
+			String uuid = this.getUniqueId().toString();
+			ResultSet rs = sql.getConnection().createStatement().executeQuery("SELECT * FROM users WHERE UUID= '" + uuid + "';");
+			if (rs.next()) {
+				sql.closeConnection();
+				return true;
+			}else {
+				sql.closeConnection();
+				return false;
+			}
+				
+		} catch (ClassNotFoundException | SQLException e) {
+			e.printStackTrace();
+			return false;
+		}
+	}
+	
+	/**
+	 * checks if inventory is empty
+	 * @return true/false
+	 */
+	public boolean hasEmptyInventory() {
+		return Utils.hasEmptyInventory(PLAYER);
+	}
+	
+	/**
+	 * clears all potion effects from player
+	 */
+	public void clearPotionEffects() {
+		Utils.clearPotionEffects(PLAYER);
+	}
+	
+	/**
+	 * checks if players has a open inventory
+	 * @return true/false
+	 */
+	public boolean hasOpenInventory() {
+		return openInventory;
+	}
+	
+	/**
+	 * sets opened inventory
+	 * @param openInventory true/false
+	 */
+	public void setOpenInventory(boolean openInventory) {
+		this.openInventory = openInventory;
+	}
+	
+	/**
+	 * gets coins from player
+	 * @return coins as integer
+	 */
+	public int getCoins() {
+		return Coins.getCoins(this);
+	}
+	
+	/**
+	 * sets coins if player
+	 * @param coins coins as integer
+	 */
+	public void setCoins(int coins) {
+		Coins.setCoins(this, coins);
+	}
+	
+	/**
+	 * adds coins to player coins
+	 * @param coins coins as integer
+	 */
+	public void addCoins(int coins) {
+		int temp = Coins.getCoins(this);
+		Coins.setCoins(this, temp + coins);
+	}
+	
+	/**
+	 * substracts coins from player coins
+	 * @param coins coins as integer
+	 */
+	public void substractCoins(int coins) {
+		int temp = Coins.getCoins(this);
+		Coins.setCoins(this, temp - coins);
+	}
+	
+	/**
+	 * sends message with actionbar to player
+	 * @param text String
+	 */
+	public void sendActionBar(String text) {
+		Actionbar.send(PLAYER, text);
+	}
+
+	/**
+	 * gets experience from player
+	 * @return experience experience as integer
+	 */
+	public int getExperience() {
+		return Experience.getExperience(this);
+	}
+	
+	/**
+	 * sets experience of player
+	 * @param experience experience to set
+	 */
+	public void setExperience(int experience) {
+		Experience.setExperience(this, experience);
+	}
+	
+	/**
+	 * adds experience to player
+	 * @param experience experience to add
+	 */
+	public void addExperience(int experience) {
+		int temp = Experience.getExperience(this);
+		Experience.setExperience(this, temp + experience);
+		setExp(0F);
+		giveExp(getExperience());
+		playSound(getLocation(), Sound.ENTITY_PLAYER_LEVELUP, 1.0F, 1.0F);
+	}
+	
+	/**
+	 * removes experience from player
+	 * @param experience experience to remove
+	 */
+	public void substractExperience(int experience) {
+		int temp = Experience.getExperience(this);
+		Experience.setExperience(this, temp - experience);
+		setExp(0F);
+		giveExp(getExperience());
+	}
+
+    public void refreshExperience() {
+        setLevel(0);
+        setExp(0F);
+        giveExp(getExperience());
+    }
+
+	public int getFoundSecrets() {
+		return 0;
+	}
+
+	public String getLanguage() {
+		return "DE";
+    }
+
+    public void setLanguage(String lang) {
+        PlayerSettings.set(lang, "lang", this);
+    }
+	
+	public boolean isSetting(String setting) {
+		return PlayerSettings.isSet(setting, this);
+	}
+
+    public String getSetting(String setting) { return PlayerSettings.get(setting, this); }
+
+    public void changeSetting(String setting) {
+        PlayerSettings.change(setting, this);
+    }
+
+    public void playParticle(Location loc, EnumParticle ep, float f, int count) {
+        if(isSetting("effects"))
+            Effects.playEffectToPlayer(PLAYER, loc, ep, f, count);
+    }
+
+    public void setAttackSpeed(double speed) {
+        AttributeModifier modifier = new AttributeModifier("Core", speed, AttributeModifier.Operation.ADD_NUMBER);
+        getAttribute(Attribute.GENERIC_ATTACK_SPEED).addModifier(modifier);
+    }
+
+    public double getAttackSpeed() {
+        return getAttribute(Attribute.GENERIC_ATTACK_SPEED).getValue();
+    }
+
+    public void resetAttackSpeed() {
+        AttributeModifier modifier = new AttributeModifier("Core", getAttackSpeed(), AttributeModifier.Operation.ADD_NUMBER);
+        getAttribute(Attribute.GENERIC_ATTACK_SPEED).removeModifier(modifier);
+    }
+
+    public Messages getMessages() {
+        return new Messages(this);
+    }
+
+    public Statistics getStatistics(Game game) {
+        return new Statistics(this, game);
+    }
+}

src/main/java/eu/univento/core/api/player/Experience.java

@@ -0,0 +1,60 @@
+package eu.univento.core.api.player;
+
+import eu.univento.core.Core;
+import eu.univento.core.api.database.MySQL;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+/**
+ * experience management
+ * @author joethei
+ * @version 1.0
+ */
+public class Experience{
+	
+	/**
+	 * gets experience from player
+	 * @param p CustomPlayer
+	 * @return experience as integer
+	 */
+	static int getExperience(CustomPlayer p) {
+		int id = p.getID();
+		MySQL sql = Core.returnSQL();
+		try {
+			sql.openConnection();
+			PreparedStatement st = sql.getConnection().prepareStatement("SELECT Experience FROM users WHERE ID='" + id + "';");
+			ResultSet rs = st.executeQuery();
+			if(rs.next()) {
+				int coins = rs.getInt("Experience");
+				sql.closeConnection();
+				return coins;
+			}
+			return 0;
+		} catch (ClassNotFoundException | SQLException e) {
+			e.printStackTrace();
+			return 0;
+		}
+	}
+	
+	/**
+	 * sets experience of player
+	 * @param p CustomPlayer
+	 * @param experience experience to set
+	 */
+	static void setExperience(CustomPlayer p, int experience) {
+		int id = p.getID();
+		MySQL sql = Core.returnSQL();
+		try {
+			sql.openConnection();
+			PreparedStatement st = sql.getConnection().prepareStatement("UPDATE users SET Experience='" + experience + "' WHERE ID='" + id + "';");
+			st.execute();
+			sql.closeConnection();
+		} catch (ClassNotFoundException | SQLException e) {
+			e.printStackTrace();
+		}
+		
+	}
+
+}

src/main/java/eu/univento/core/api/player/Friends.java

@@ -0,0 +1,109 @@
+package eu.univento.core.api.player;
+
+import eu.univento.core.Core;
+import eu.univento.core.api.database.MySQL;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+
+/**
+ * api for friends
+ * @author joethei
+ * @version 1.1
+ */
+public class Friends {
+	
+	/**
+	 * player object
+	 */
+	CustomPlayer player;
+	
+	/**
+	 * creates the friends object
+	 * @param player CustomPlayer
+	 */
+	public Friends(CustomPlayer player) {
+		this.player = player;
+	}
+	
+	/**
+	 * gets database IDs of friends
+	 * @return ArrayList<Integer>
+	 */
+	public ArrayList<Integer> getFriends() {
+		MySQL sql = Core.returnSQL();
+		try {
+			sql.openConnection();
+			ArrayList<Integer> list = new ArrayList<Integer>();
+			ResultSet rs = sql.getConnection().createStatement().executeQuery("SELECT * FROM Friends WHERE Player_ID = '" + player.getID());
+			while(rs.next()) {
+				list.add(rs.getInt("Friend_ID"));
+			}
+			sql.closeConnection();
+			return list;
+		} catch (ClassNotFoundException | SQLException e) {
+			e.printStackTrace();
+			return null;
+		}
+	}
+	
+	/**
+	 * add player to friends
+	 * @param p CustomPlayer
+	 */
+	public void addFriend(CustomPlayer p) {
+		MySQL sql = Core.returnSQL();
+		try {
+			sql.openConnection();
+			PreparedStatement ps = sql.getConnection().prepareStatement("INSERT INTO Friends ('Player_ID', 'Friend_ID') VALUES ('" + player.getID() + "', '" + p.getID() + "');");
+			ps.execute();
+			sql.closeConnection();
+		} catch (ClassNotFoundException | SQLException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	/**
+	 * removes player from friends
+	 * @param p CustomPlayer
+	 */
+	public void removeFriend(CustomPlayer p) {
+		MySQL sql = Core.returnSQL();
+		try {
+			sql.openConnection();
+			PreparedStatement ps = sql.getConnection().prepareStatement("DELETE FROM Friends WHERE Player_ID='" + player.getID() + "' AND Friend_ID='" + p.getID() + "');");
+			ps.execute();
+			sql.closeConnection();
+		} catch (ClassNotFoundException | SQLException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	/**
+	 * checks if player is friend
+	 * @param p CustomPlayer
+	 * @return true/false
+	 */
+	public boolean isFriend(CustomPlayer p) {
+		return getFriends().contains(p.getID());
+	}
+	
+	/**
+	 * counts friends
+	 * @return int
+	 */
+	public int countFriends() {
+		return getFriends().size();
+	}
+	
+	/**
+	 * checks if player has friends
+	 * @return true/false
+	 */
+	public boolean hasFriends() {
+		return getFriends().size() >= 0;
+	}
+	
+}

src/main/java/eu/univento/core/api/player/NickName.java

@@ -0,0 +1,219 @@
+package eu.univento.core.api.player;
+
+import com.mojang.authlib.GameProfile;
+import com.mojang.authlib.properties.Property;
+import eu.univento.core.Core;
+import eu.univento.core.api.database.MySQL;
+import net.minecraft.server.v1_9_R1.Packet;
+import net.minecraft.server.v1_9_R1.PacketPlayOutEntityDestroy;
+import net.minecraft.server.v1_9_R1.PacketPlayOutNamedEntitySpawn;
+import net.minecraft.server.v1_9_R1.PacketPlayOutPlayerInfo;
+import org.bukkit.Bukkit;
+import org.bukkit.craftbukkit.v1_9_R1.entity.CraftPlayer;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import java.lang.reflect.Field;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Random;
+
+/**
+ * gets nick settings for players
+ * @author joethei
+ * @version 1.1
+ */
+public class NickName {
+
+	private static HashMap<CustomPlayer, String> nicks = new HashMap<>();
+
+    private static Field nameField = getField(GameProfile.class, "name");
+	/**
+	 * 
+	 * @param p remove nickname from player
+	 */
+	public static void remove(CustomPlayer p) {
+		if (nicks.containsKey(p))
+			nicks.remove(p);
+	}
+
+	/**
+	 * sets nick boolean
+	 * @param p player
+	 * @param nick boolean
+	 * @throws ClassNotFoundException Class couldn't be found
+	 * @throws SQLException SQL server not available or throwing error
+	 */
+	static void setNick(CustomPlayer p, boolean nick) throws SQLException, ClassNotFoundException {
+		MySQL sql = Core.returnSQL();
+		sql.openConnection();
+		if (nick)
+			sql.getConnection().createStatement().executeUpdate("UPDATE PlayerSettings SET nick = '1' WHERE ID = '" + p.getID() + "';");
+		else
+			sql.getConnection().createStatement().executeUpdate("UPDATE PlayerSettings SET nick = '0' WHERE ID = '" + p.getID() + "';");
+			sql.closeConnection();
+	}
+
+	/**
+	 * gets if player is nicked
+	 * @param p player
+	 * @return true / false
+	 * @throws ClassNotFoundException Class couldn't be found
+	 * @throws SQLException SQL server not available or throwing error
+	 */
+	static boolean isNicked(CustomPlayer p) throws SQLException, ClassNotFoundException {
+		MySQL sql = Core.returnSQL();
+		sql.openConnection();
+		ResultSet rs = sql.getConnection().createStatement().executeQuery("SELECT nick FROM PlayerSettings WHERE ID = '" + p.getID() + "';");
+		if (rs.next()) {
+            boolean is = rs.getInt("nick") == 1;
+			sql.closeConnection();
+            return is;
+		}
+		sql.closeConnection();
+		return false;
+	}
+
+	/**
+	 * gets nickname of player
+	 * @param p player
+	 * @return String
+	 */
+	static String getNick(CustomPlayer p) {
+		if (nicks.containsKey(p)) {
+			return nicks.get(p);
+		}else if(p.isNicked()){
+            nicks.put(p, getRandomNick());
+            return nicks.get(p);
+        }
+		return null;
+	}
+
+	/**
+	 * gets random Nickname
+	 * @return String
+	 */
+	private static String getRandomNick() {
+		ArrayList<String> names = new ArrayList<>();
+		names.add("GommeHD");
+		names.add("Notch");
+		names.add("12ms");
+		names.add("Coriux");
+        names.add("Kekse");
+        names.add("AFK");
+        names.add("13ms");
+        names.add("Inhaltsangabe");
+        names.add("LassMichEinfach");
+        names.add("Inventar");
+        names.add("DDoS");
+        names.add("Upps");
+        names.add("Hater");
+        names.add("ServerOwner");
+        names.add("HastDuMinecraft");
+        names.add("Telekom");
+        names.add("TeamBlauNurGute");
+        names.add("Stats");
+        names.add("Herbst");
+        names.add("IchHabTwitter");
+        names.add("Versager");
+        names.add("ImmerAmSterben");
+        names.add("Lagmolia");
+        names.add("Bowspammer");
+        names.add("Behindert");
+        names.add("DasProgramm");
+        names.add("DasPlugin");
+        names.add("Staubsauger");
+        names.add("Buchstabe");
+        names.add("gekickt");
+        names.add("Einfachpermaban");
+        names.add("KeinNameWarFrei");
+        names.add("KlopapierIstLeer");
+        names.add("Packungsbeilage");
+        names.add("HabKeinRewiPremium");
+        names.add("PermaBanAufGomme");
+        names.add("Vorteil");
+        names.add("Nachteil");
+        names.add("Oberteil");
+        names.add("Einstellung");
+        names.add("Verbindung");
+        names.add("WarAFKWasWar");
+
+		Random r = new Random();
+		int i = r.nextInt(names.size());
+
+		return names.get(i);
+	}
+
+    static void changeSkin(CustomPlayer p, String name) {
+        Skin skin = new Skin(Bukkit.getOfflinePlayer(name).getUniqueId().toString().replace("_", ""));
+        if(skin.getName() != null) {
+            GameProfile profile = p.getProfile();
+            profile.getProperties().clear();
+            profile.getProperties().put(skin.getName(), new Property(skin.getName(), skin.getValue(), skin.getSignature()));
+            Bukkit.getScheduler().runTaskLater(Core.getInstance(), () -> {
+                for(Player players : Bukkit.getOnlinePlayers()) {
+                    players.hidePlayer(p);
+                }
+            }, 1L);
+            Bukkit.getScheduler().runTaskLater(Core.getInstance(), () -> {
+                for(Player players : Bukkit.getOnlinePlayers()) {
+                    players.showPlayer(p);
+                }
+             }, 1L);
+        }
+    }
+
+    static void setName(CustomPlayer p, String name) {
+        p.setDisplayName(name);
+        try {
+            nameField.set(p.getProfile(), name);
+            PacketPlayOutEntityDestroy destroy = new PacketPlayOutEntityDestroy(p.getEntityId());
+            sendPacket(destroy);
+            removeFromTablist(p);
+
+            new BukkitRunnable() {
+
+                @Override
+                public void run() {
+                    addToTablist(p);
+                    PacketPlayOutNamedEntitySpawn spawn = new PacketPlayOutNamedEntitySpawn(p.getHandle());
+                    Bukkit.getOnlinePlayers().stream().filter(players -> !players.equals(p)).forEach(players -> {
+                        ((CraftPlayer) players).getHandle().playerConnection.sendPacket(spawn);
+                    });
+                }
+
+            }.runTaskLater(Core.getInstance(), 4);
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static void addToTablist(CraftPlayer p) {
+        PacketPlayOutPlayerInfo packet = new PacketPlayOutPlayerInfo(PacketPlayOutPlayerInfo.EnumPlayerInfoAction.ADD_PLAYER, p.getHandle());
+        sendPacket(packet);
+    }
+
+    private static void removeFromTablist(CraftPlayer cp) {
+        PacketPlayOutPlayerInfo packet = new PacketPlayOutPlayerInfo(PacketPlayOutPlayerInfo.EnumPlayerInfoAction.REMOVE_PLAYER, cp.getHandle());
+        sendPacket(packet);
+    }
+
+    private static void sendPacket(Packet<?> packet) {
+        for(Player players : Bukkit.getOnlinePlayers()) {
+            ((CraftPlayer)players).getHandle().playerConnection.sendPacket(packet);
+        }
+    }
+
+    private static Field getField(Class<?> clazz, String name) {
+        try{
+            Field field = clazz.getDeclaredField(name);
+            field.setAccessible(true);
+            return field;
+        }catch (NoSuchFieldException | SecurityException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+}

src/main/java/eu/univento/core/api/player/Perms.java

@@ -0,0 +1,307 @@
+package eu.univento.core.api.player;
+
+import eu.univento.core.Core;
+import eu.univento.core.api.database.MySQL;
+import org.bukkit.Color;
+import org.bukkit.scoreboard.Scoreboard;
+import org.bukkit.scoreboard.Team;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.HashMap;
+
+/**
+ * some permission management
+ * @author joethei
+ * @version 1.0
+ */
+public class Perms{
+
+	private static HashMap<CustomPlayer, Ranks> ranks = new HashMap<>();
+	public static HashMap<CustomPlayer, Ranks> getRanks() {
+		return ranks;
+	}
+	
+/**
+ * gets the prefix of a player
+ * @param r Ranks
+ * @return String
+ */
+static String getPrefix(Ranks r) {
+	  switch(r) {
+	  	case Admin: return "§8[§4Admin§8]§4 ";
+        case SrDeveloper: return "§8[§3Dev+§8]§3 ";
+	  	case Developer: return "§8[§3Dev§8]§3 ";
+        case SrModerator: return "§8[§cSrMod§8]§c ";
+	  	case HeadBuilder: return "§8[§aHead-Builder§8]§a ";
+        case Moderator: return "§8[§cMod§8]§c ";
+	  	case Builder: return "§8[§2Builder§8]§2 ";
+	  	case Supporter: return "§8[§9Supporter§8]§9 ";
+	  	case Youtuber: return "§5";
+	  	case Premium: return "§6";
+	  	case Player: return "§e";
+	  	default: return "§cFehler ";
+	  }
+  }
+  
+/**
+ * gets the suffix of a player
+ * @param r Ranks
+ * @return String
+ */
+static String getSuffix(Ranks r) {
+	  switch(r) {
+	  case Admin: return "§8 »§7 ";
+      case SrDeveloper: return "§8 »§7";
+	  case Developer: return "§8 »§7 ";
+      case SrModerator: return "§8 »§7 ";
+	  case HeadBuilder: return "§8 »§7 ";
+      case Moderator: return "§8 »§7 ";
+	  case Builder: return "§8 »§7 ";
+	  case Supporter: return "§8 »§7 ";
+	  case Youtuber: return "§8 »§7 ";
+	  case Premium: return "§8 »§7 ";
+	  case Player: return "§8 »§7 ";
+	  default: return "§cFehler";
+	  }
+  }
+  
+/**
+ * gets color of a player
+ * @param r Ranks
+ * @return String
+ */
+static String getColor(Ranks r) {
+	  switch(r) {
+	  case Admin: return "§4";
+      case SrDeveloper: return "§3";
+	  case Developer: return "§3";
+      case SrModerator: return "§c";
+	  case HeadBuilder: return "§a";
+      case Moderator: return "§c";
+	  case Builder: return "§2";
+	  case Supporter: return "§9";
+	  case Youtuber: return "§5";
+	  case Premium: return "§6";
+	  case Player: return "§e";
+	  default: return "§cFehler";
+	  }
+  }
+
+static Color getArmorColor(Ranks r) {
+    switch (r) {
+        case Admin: return Color.MAROON;
+        case SrDeveloper: return Color.TEAL;
+        case Developer: return Color.TEAL;
+        case SrModerator: return Color.RED;
+        case HeadBuilder: return Color.LIME;
+        case Moderator: return Color.RED;
+        case Builder: return Color.GREEN;
+        case Supporter: return Color.PURPLE;
+        default: return null;
+    }
+}
+
+/**
+ * contains all scoreboard ranks
+ * @author joethei
+ * @version 1.0
+ */
+static class Teams {
+
+    CustomPlayer player;
+    Scoreboard board;
+
+    Team Admin;
+    Team SrDeveloper;
+    Team Developer;
+    Team SrModerator;
+    Team Moderator;
+    Team HeadBuilder;
+    Team Builder;
+    Team Supporter;
+    Team Youtuber;
+    Team Premium;
+    Team Player;
+
+	Teams(CustomPlayer player) {
+        this.player = player;
+        board = player.getScoreboard();
+        Admin = board.getTeam("a");
+        SrDeveloper = board.getTeam("b");
+        Developer = board.getTeam("c");
+        SrModerator = board.getTeam("d");
+        HeadBuilder = board.getTeam("e");
+        Moderator = board.getTeam("f");
+        Builder = board.getTeam("g");
+        Supporter = board.getTeam("h");
+        Youtuber = board.getTeam("i");
+        Premium = board.getTeam("j");
+        Player = board.getTeam("k");
+    }
+	
+	/**
+	 * returns scoreboard team for rank
+	 * @param p CustomPlayer
+	 * @return Team
+	 */
+	static Team getTeam(CustomPlayer p)  {
+        Teams teams = new Teams(p);
+		switch(p.getRank()) {
+		case Admin: return teams.Admin;
+        case SrDeveloper: return teams.SrDeveloper;
+		case Developer: return teams.Developer;
+        case SrModerator: return teams.SrModerator;
+		case HeadBuilder: return teams.HeadBuilder;
+        case Moderator: return teams.Moderator;
+		case Builder: return teams.Builder;
+		case Supporter: return teams.Supporter;
+		case Youtuber: return teams.Youtuber;
+		case Premium: return teams.Premium;
+		case Player: return teams.Player;
+		default: return null;
+		}
+	}
+}
+
+/**
+ * setup scoreboards
+ */
+public static void initScoreboard(CustomPlayer p) {
+	Scoreboard board = p.getScoreboard();
+	board.getTeams().forEach(Team::unregister);
+	
+	Team Admin = board.registerNewTeam("a");
+    Team SrDeveloper = board.registerNewTeam("b");
+	Team Developer = board.registerNewTeam("c");
+    Team SrModerator = board.registerNewTeam("d");
+	Team HeadBuilder = board.registerNewTeam("e");
+    Team Moderator = board.registerNewTeam("f");
+	Team Builder = board.registerNewTeam("g");
+	Team Supporter = board.registerNewTeam("h");
+	Team Youtuber = board.registerNewTeam("i");
+	Team Premium = board.registerNewTeam("j");
+	Team Player = board.registerNewTeam("k");
+		
+	Admin.setPrefix(getColor(Ranks.Admin));
+    SrDeveloper.setPrefix(getColor(Ranks.SrDeveloper));
+	Developer.setPrefix(getColor(Ranks.Developer));
+    SrModerator.setPrefix(getColor(Ranks.SrModerator));
+	HeadBuilder.setPrefix(getColor(Ranks.HeadBuilder));
+    Moderator.setPrefix(getColor(Ranks.Moderator));
+	Builder.setPrefix(getColor(Ranks.Builder));
+	Supporter.setPrefix(getColor(Ranks.Supporter));
+	Youtuber.setPrefix(getColor(Ranks.Youtuber));
+	Premium.setPrefix(getColor(Ranks.Premium));
+	Player.setPrefix(getColor(Ranks.Player));
+
+    Admin.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
+    SrDeveloper.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
+    Developer.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
+    SrModerator.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
+    HeadBuilder.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
+    Moderator.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
+    Builder.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
+    Supporter.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
+    Youtuber.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
+    Premium.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
+    Player.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
+}
+/**
+ * gets Rank of player
+ * @param p Player
+ * @return Ranks
+ * @throws ClassNotFoundException Class couldn't be found
+ * @throws SQLException SQL server not available or throwing error
+ */
+static Ranks getRank(CustomPlayer p) throws ClassNotFoundException, SQLException {
+	  if(getRanks().get(p) != null) {
+		  return getRanks().get(p);
+	  }else {
+		  return getRankFresh(p);
+	  }
+	  
+  }
+
+/**
+ * gets Rank of player fresh from database
+ * @param p Player
+ * @return Ranks
+ * @throws ClassNotFoundException Class couldn't be found
+ * @throws SQLException SQL server not available or throwing error
+ */
+static Ranks getRankFresh(CustomPlayer p) throws SQLException, ClassNotFoundException {
+	MySQL sql = Core.returnSQL();
+	sql.openConnection();
+	String uuid = p.getUniqueId().toString();
+	PreparedStatement st = sql.getConnection().prepareStatement("SELECT * FROM users WHERE UUID= '" + uuid + "';");
+    ResultSet rs = st.executeQuery();
+    if(rs.next()) {
+      String rank = rs.getString("Rank");
+      sql.closeConnection();
+      return Ranks.valueOf(rank);
+    }else {
+        sql.closeConnection();
+        return null;	
+    }
+  }
+  
+  /**
+   * sets rank for player
+ * @param p Player
+ * @param r Ranks
+ * @throws ClassNotFoundException Class couldn't be found
+ * @throws SQLException SQL server not available or throwing error
+ */
+static void setRank(CustomPlayer p, Ranks r) throws ClassNotFoundException, SQLException {
+	  MySQL sql = Core.returnSQL();
+	  sql.openConnection();
+	  PreparedStatement st = sql.getConnection().prepareStatement("UPDATE users SET Rank='" + r.toString() + "' WHERE ID='" + p.getID() + "';");
+	  st.execute();
+	  sql.closeConnection();
+  }
+
+/**
+ * if player is allowed to do
+ * @param p Player
+ * @param r Ranks
+ * @return true / false
+ * @throws ClassNotFoundException Class couldn't be found
+ * @throws SQLException SQL server not available or throwing error
+ */
+static boolean isAllowed(CustomPlayer p, Ranks r) throws ClassNotFoundException, SQLException{
+	Ranks rank;
+	if(getRank(p) == null) {
+		rank = getRankFresh(p);
+	}else {
+		rank = getRank(p);
+	}
+    return rank.value >= r.value;
+  }
+
+/**
+ * contains all ranks
+ * @author joethei
+ * @version 1.0
+ */
+  public enum Ranks{
+	Admin(11),
+    SrDeveloper(10),
+	Developer(9),
+	SrModerator(8),
+	HeadBuilder(7),
+	Moderator(6),
+	Builder(5),
+	Supporter(4),
+	Youtuber(3),
+	Premium(2),
+	Player(1);
+
+    final int value;
+
+    Ranks(int n) {
+    	this.value = n;
+    }
+  }
+}

src/main/java/eu/univento/core/api/player/PlayerSettings.java

@@ -0,0 +1,144 @@
+package eu.univento.core.api.player;
+
+import eu.univento.core.Core;
+import eu.univento.core.api.database.MySQL;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+
+/**
+ * server-wide settings
+ * @author joethei
+ * @version 0.1
+ */
+
+public class PlayerSettings {
+
+	/**
+	 * returns if setting is set
+	 * @param what what setting is set
+	 * @param p CustomPlayer
+	 * @return boolean
+	 */
+	static boolean isSet(String what, CustomPlayer p) {
+        int id = p.getID();
+		MySQL sql = Core.returnSQL();
+		try {
+			sql.openConnection();
+            PreparedStatement st = sql.getConnection().prepareStatement("SELECT * FROM PlayerSettings WHERE ID = '" + id + "';");
+			ResultSet rs = st.executeQuery();
+			if (rs.next()) {
+				boolean is = rs.getInt(what) == 1;
+				sql.closeConnection();
+				return is;
+			}
+			sql.closeConnection();
+			return false;
+		} catch (ClassNotFoundException | SQLException e) {
+			e.printStackTrace();
+			return false;
+		}
+	}
+
+	/**
+	 * sets setting
+	 * @param p CustomPlayer
+	 * @param bool boolean to set to
+	 * @param what what to set
+	 * @throws ClassNotFoundException class could not be found
+	 * @throws SQLException SQL ServerPinger not available or throwing error
+	 */
+	static void set(boolean bool, String what, CustomPlayer p) throws SQLException, ClassNotFoundException {
+        int id = p.getID();
+		MySQL sql = Core.returnSQL();
+		sql.openConnection();
+		if (bool) {
+            PreparedStatement st = sql.getConnection().prepareStatement("UPDATE PlayerSettings SET " + what + " = '1' WHERE ID = '" + id + "';");
+            st.execute();
+        }else {
+            PreparedStatement st = sql.getConnection().prepareStatement("UPDATE PlayerSettings SET " + what + " = '0' WHERE ID = '" + id + "';");
+            st.execute();
+        }
+		sql.closeConnection();
+	}
+
+    /**
+     * gets setting from player
+     * @param what what to get
+     * @param p CustomPlayer
+     * @return String
+     */
+	static String get(String what, CustomPlayer p) {
+        int id = p.getID();
+        MySQL sql = Core.returnSQL();
+        try {
+            sql.openConnection();
+            PreparedStatement st = sql.getConnection().prepareStatement("SELECT " + what + " FROM PlayerSettings WHERE ID='" + id + "';");
+            ResultSet rs = st.executeQuery();
+            if(rs.next()) {
+                String rt = rs.getString(what);
+                sql.closeConnection();
+                return rt;
+            }
+            return null;
+        } catch (SQLException | ClassNotFoundException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    /**
+     * sets settings for player
+     * @param set value to set
+     * @param what what to set
+     * @param p CustomPlayer
+     */
+    static void set(String set, String what, CustomPlayer p) {
+        int id = p.getID();
+        MySQL sql = Core.returnSQL();
+        try {
+            sql.openConnection();
+            PreparedStatement st = sql.getConnection().prepareStatement("UPDATE PlayerSettings SET " + what + " = '" + set + "' WHERE ID = '" + id + "';");
+            st.execute();
+        } catch (SQLException | ClassNotFoundException e) {
+            e.printStackTrace();
+        }
+    }
+	
+	/**
+	 * changes settings
+	 * @param what what to set
+	 * @param p CustomPlayer
+	 */
+	static void change(String what, CustomPlayer p) {
+		if(isSet(what, p)) {
+			try {
+				set(false, what, p);
+			} catch (ClassNotFoundException | SQLException e) {
+				e.printStackTrace();
+			}
+		}else {
+			try {
+				set(true, what, p);
+			} catch (ClassNotFoundException | SQLException e) {
+				e.printStackTrace();
+			}
+		}
+	}
+
+    public static ArrayList<CustomPlayer> getAllPlayersWithEffectsEnabled() {
+        ArrayList<CustomPlayer> list = new ArrayList<>();
+        for(Player players : Bukkit.getOnlinePlayers()) {
+            CustomPlayer p = CustomPlayer.getPlayer(players);
+            if(isSet("effects", p)) {
+                list.add(p);
+            }
+        }
+        return list;
+    }
+	
+}

src/main/java/eu/univento/core/api/player/Spectator.java

@@ -0,0 +1,67 @@
+package eu.univento.core.api.player;
+
+import eu.univento.core.api.server.ServerSettings;
+import org.bukkit.Bukkit;
+import org.bukkit.GameMode;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+
+/**
+ * 
+ * @author joethei
+ * @version 1.0
+ */
+public class Spectator {
+
+	/**
+	 * contains all spectators
+	 */
+	private static ArrayList<CustomPlayer> spectators = new ArrayList<>();
+
+	/**
+	 * adds player to spectators
+	 * @param p CustomPlayer
+	 */
+	public static void add(CustomPlayer p) {
+		for (Player on : Bukkit.getOnlinePlayers()) {
+			on.hidePlayer(p);
+		}
+		spectators.add(p);
+		p.setGameMode(GameMode.ADVENTURE);
+		p.setAllowFlight(true);
+		p.setFlying(true);
+	}
+
+	/**
+	 * removes player from spectator
+	 * @param p CustomPlayer
+	 */
+	public static void remove(CustomPlayer p) {
+		for (Player on : Bukkit.getOnlinePlayers()) {
+			on.showPlayer(p);
+		}
+		spectators.remove(p);
+		p.setGameMode(ServerSettings.getGameMode());
+		p.setAllowFlight(false);
+		p.setFlying(false);
+	}
+
+	/**
+	 * gets all spectators
+	 * @return ArrayList<CustomPlayer>
+	 */
+	public static ArrayList<CustomPlayer> getSpectators() {
+		return spectators;
+	}
+	
+	/**
+	 * checks if players is spectator
+	 * @param p CustomPlayer
+	 * @return true/false
+	 */
+	public static boolean is(CustomPlayer p) {
+		return spectators.contains(p);
+	}
+
+}

src/main/java/eu/univento/core/api/player/Statistics.java

@@ -0,0 +1,217 @@
+package eu.univento.core.api.player;
+
+import eu.univento.core.Core;
+import eu.univento.core.api.database.MySQL;
+import eu.univento.core.api.server.Game;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+/**
+ * statistics management
+ * @author joethei
+ * @version 1.0
+ */
+public class Statistics {
+
+	CustomPlayer player;
+	Game game;
+	
+	/**
+	 * @param player CustomPlayer
+	 * @param game Game
+	 */
+	public Statistics(CustomPlayer player, Game game) {
+		this.player = player;
+		this.game = game;
+	}
+	
+	
+	/**
+	 * gets deaths of player for game
+	 * @return Integer
+	 */
+	public int getDeaths() {
+		MySQL sql = Core.returnSQL();
+		try {
+			sql.openConnection();
+			PreparedStatement st = sql.getConnection().prepareStatement("SELECT Deaths FROM " + game.toString() + "Stats WHERE ID='" + player.getID() + "');");
+			ResultSet rs = st.executeQuery();
+			int deaths = rs.getInt("Deaths");
+			sql.closeConnection();
+			return deaths;
+		} catch (ClassNotFoundException | SQLException e) {
+			e.printStackTrace();
+			return 0;
+		}
+	}
+	
+	/**
+	 * sets deaths of player for game
+	 * @param deaths Integer
+	 */
+	public void setDeaths(int deaths) {
+		MySQL sql = Core.returnSQL();
+		try {
+			sql.openConnection();
+			PreparedStatement st = sql.getConnection().prepareStatement("UPDATE " + game.toString() + "Stats WHERE ID='" + player.getID() + "' SET Deaths='" + deaths +"');");
+			st.execute();
+		} catch (ClassNotFoundException | SQLException e) {
+			e.printStackTrace();
+		}
+	}
+
+    public void addDeath() {
+        setDeaths(getDeaths() + 1);
+    }
+	
+	/**
+	 * gets kills of player for game
+	 * @return Integer
+	 */
+	public int getKills() {
+		MySQL sql = Core.returnSQL();
+		try {
+			sql.openConnection();
+			PreparedStatement st = sql.getConnection().prepareStatement("SELECT Kills FROM " + game.toString() + "Stats WHERE ID='" + player.getID() + "');");
+			ResultSet rs = st.executeQuery();
+			int kills = rs.getInt("Kills");
+			sql.closeConnection();
+			return kills;
+		} catch (ClassNotFoundException | SQLException e) {
+			e.printStackTrace();
+			return 0;
+		}
+	}
+	
+	/**
+	 * sets kills of player for game
+	 * @param kills Integer
+	 */
+	public void setKills(int kills) {
+		MySQL sql = Core.returnSQL();
+		try {
+			sql.openConnection();
+			PreparedStatement st = sql.getConnection().prepareStatement("UPDATE " + game.toString() + "Stats WHERE ID='" + player.getID() + "' SET Kills='" + kills +"');");
+			st.execute();
+		} catch (ClassNotFoundException | SQLException e) {
+			e.printStackTrace();
+		}
+	}
+
+    public void addKill() {
+        setKills(getKills() + 1);
+    }
+	
+	/**
+	 * gets played rounds of player for game
+	 * @return Integer
+	 */
+	public int getPlayedRounds() {
+		MySQL sql = Core.returnSQL();
+		try {
+			sql.openConnection();
+			PreparedStatement st = sql.getConnection().prepareStatement("SELECT PlayedRounds FROM " + game.toString() + "Stats WHERE ID='" + player.getID() + "');");
+			ResultSet rs = st.executeQuery();
+			int rounds = rs.getInt("PlayedRounds");
+			sql.closeConnection();
+			return rounds;
+		} catch (ClassNotFoundException | SQLException e) {
+			e.printStackTrace();
+			return 0;
+		}
+	}
+	
+	/**
+	 * sets played rounds of player for game
+	 * @param rounds Integer
+	 */
+	public void setPlayedRounds(int rounds) {
+		MySQL sql = Core.returnSQL();
+		try {
+			sql.openConnection();
+			PreparedStatement st = sql.getConnection().prepareStatement("UPDATE " + game.toString() + "Stats WHERE ID='" + player.getID() + "' SET PlayedRounds='" + rounds +"');");
+			st.execute();
+		} catch (ClassNotFoundException | SQLException e) {
+			e.printStackTrace();
+		}
+	}
+
+    public void addPlayedRound() {
+        setPlayedRounds(getPlayedRounds() + 1);
+    }
+	
+	/**
+	 * gets playtime of player for game
+	 * @return Integer
+	 */
+	public int getPlaytime() {
+		MySQL sql = Core.returnSQL();
+		try {
+			sql.openConnection();
+			PreparedStatement st = sql.getConnection().prepareStatement("SELECT Playtime FROM " + game.toString() + "Stats WHERE ID='" + player.getID() + "');");
+			ResultSet rs = st.executeQuery();
+			int time = rs.getInt("Playtime");
+			sql.closeConnection();
+			return time;
+		} catch (ClassNotFoundException | SQLException e) {
+			e.printStackTrace();
+			return 0;
+		}
+	}
+	
+	/**
+	 * sets playtime of player for game
+	 * @param time Integer
+	 */
+	public void setPlaytime(int time) {
+		MySQL sql = Core.returnSQL();
+		try {
+			sql.openConnection();
+			PreparedStatement st = sql.getConnection().prepareStatement("UPDATE " + game.toString() + "Stats WHERE ID='" + player.getID() + "' SET Playtime='" + time +"');");
+			st.execute();
+		} catch (ClassNotFoundException | SQLException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	/**
+	 * gets wins of player for game
+	 * @return Integer
+	 */
+	public int getWins() {
+		MySQL sql = Core.returnSQL();
+		try {
+			sql.openConnection();
+			PreparedStatement st = sql.getConnection().prepareStatement("SELECT Wins FROM " + game.toString() + "Stats WHERE ID='" + player.getID() + "');");
+			ResultSet rs = st.executeQuery();
+			int wins = rs.getInt("Wins");
+			sql.closeConnection();
+			return wins;
+		} catch (ClassNotFoundException | SQLException e) {
+			e.printStackTrace();
+			return 0;
+		}
+	}
+	
+	/**
+	 * sets wins of player for game
+	 * @param wins Integer
+	 */
+	public void setWins(int wins) {
+		MySQL sql = Core.returnSQL();
+		try {
+			sql.openConnection();
+			PreparedStatement st = sql.getConnection().prepareStatement("UPDATE " + game.toString() + "Stats WHERE ID='" + player.getID() + "' SET Wins='" + wins +"');");
+			st.execute();
+		} catch (ClassNotFoundException | SQLException e) {
+			e.printStackTrace();
+		}
+	}
+
+    public void addWin() {
+        setWins(getWins() + 1);
+    }
+
+}

src/main/java/eu/univento/core/api/server/Game.java

@@ -0,0 +1,19 @@
+package eu.univento.core.api.server;
+
+/**
+ * all minigames with description
+ * @author joethei
+ * @version 1.0
+ */
+public enum Game {
+	
+	//TODO: lookout for some TODOs in this file
+	WoolGet,
+	FlagAttack,
+	Free4All,
+	TrashGames,
+	HulkFight,
+	Maya,
+	FallingAttack,
+	Worms
+}

src/main/java/eu/univento/core/api/server/GameInfo.java

@@ -0,0 +1,27 @@
+package eu.univento.core.api.server;
+
+/**
+ * @author joethei
+ * @version 0.1
+ */
+public class GameInfo {
+
+    Game game;
+
+    public GameInfo(Game game) {
+        this.game = game;
+    }
+
+    public int getPlayerCount() {
+        return 0;
+    }
+
+    public int getServerCount() {
+        return 0;
+    }
+
+    public ServerInfo[] getServers() {
+        return null;
+    }
+
+}

src/main/java/eu/univento/core/api/server/MojangService.java

@@ -0,0 +1,122 @@
+package eu.univento.core.api.server;
+
+import org.bukkit.ChatColor;
+import org.json.simple.JSONObject;
+import org.json.simple.parser.JSONParser;
+import org.json.simple.parser.ParseException;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.URL;
+ 
+public enum MojangService {
+	
+    ACCOUNTS("Accounts Service", "account.mojang.com"),
+    AUTHENTICATION("Authentication Service", "auth.mojang.com"),
+    AUTHENTICATION_SERVER("Authentication ServerPinger", "authserver.mojang.com"),
+    LOGIN("Login Service", "login.minecraft.net"),
+    SESSION_MINECRAFT("Minecraft Session ServerPinger", "session.minecraft.net"),
+    SESSION_MOJANG("Mojang Session ServerPinger", "sessionserver.mojang.com"),
+    SKINS("Skin ServerPinger", "skins.minecraft.net"),
+    MAIN_WEBSITE("Main Site", "minecraft.net");
+ 
+    /*
+    * @Author TheTinySpider
+    * Idea from: sebasju1234
+    *
+    * Status names and other information can be found at:
+    * [url]http://minecraft.gamepedia.com/User_talk:Oxguy3/Minecraft.net_API[/url]
+    */
+ 
+    private String name, serviceURL;
+    private JSONParser jsonParser = new JSONParser();
+ 
+    MojangService(String name, String serviceURL) {
+        this.name = name;
+        this.serviceURL = serviceURL;
+    }
+ 
+    public String getName() {
+        return name;
+    }
+ 
+    /**
+    * Check the current Mojang service for it's status, errors are ignored.
+    *
+    * @return Status of the service.
+    */
+    public Status getStatus() {
+        return getStatus(true);
+    }
+ 
+    /**
+    * Check the current Mojang service for it's status.
+    *
+    * @param suppressErrors - Don't print errors in console.
+    * @return Status of the service.
+    */
+    public Status getStatus(boolean suppressErrors) {
+        try {
+            URL url = new URL("[url]http://status.mojang.com/check?service=[/url]" + serviceURL);
+            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(url.openStream()));
+ 
+            Object object = jsonParser.parse(bufferedReader);
+            JSONObject jsonObject = (JSONObject) object;
+ 
+            String status = (String) jsonObject.get(serviceURL);
+ 
+            return Status.get(status);
+ 
+        } catch (IOException | ParseException exception) {
+ 
+            if (!suppressErrors) {
+                exception.printStackTrace();
+            }
+ 
+            return Status.UNKNOWN;
+        }
+    }
+ 
+    public enum Status {
+        ONLINE("Online", ChatColor.GREEN.toString(), "No problems detected!"),
+        UNSTABLE("Unstable", ChatColor.YELLOW.toString(), "May be experiencing issues..."),
+        OFFLINE("Offline", ChatColor.DARK_RED.toString(), "Experiencing problems!"),
+        UNKNOWN("Unknown", ChatColor.WHITE.toString(), "Couldn't connect to Mojang!");
+ 
+        private String status, color, description;
+ 
+        Status(String status, String color, String description) {
+            this.status = status;
+            this.color = color;
+            this.description = description;
+        }
+ 
+        public String getStatus() {
+            return status;
+        }
+ 
+        public String getColor() {
+            return color;
+        }
+ 
+        public String getDescription() {
+            return description;
+        }
+ 
+        public static Status get(String status) {
+            status = status.toLowerCase();
+ 
+            switch (status) {
+            case "green":
+                return Status.ONLINE;
+            case "yellow":
+                return Status.UNSTABLE;
+            case "red":
+                return Status.OFFLINE;
+            default:
+                return Status.UNKNOWN;
+            }
+        }
+    }
+}

src/main/java/eu/univento/core/api/server/ServerDatabase.java

@@ -0,0 +1,69 @@
+package eu.univento.core.api.server;
+
+import eu.univento.core.Core;
+import eu.univento.core.api.database.MySQL;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+/**
+ * @author joethei
+ * @version 0.1
+ */
+public class ServerDatabase {
+
+    static String getIP(String name) {
+        MySQL sql = Core.returnSQL();
+        try {
+            sql.openConnection();
+            PreparedStatement st = sql.getConnection().prepareStatement("SELECT ip FROM Servers WHERE name='" + name + "'");
+            ResultSet rs = st.executeQuery();
+            if(rs.next()) {
+                String ip = rs.getString("ip");
+                sql.closeConnection();
+                return ip;
+            }
+            return null;
+        } catch (SQLException | ClassNotFoundException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    static int getPort(String name) {
+        MySQL sql = Core.returnSQL();
+        try {
+            sql.openConnection();
+            PreparedStatement st = sql.getConnection().prepareStatement("SELECT port FROM Servers WHERE name='" + name + "'");
+            ResultSet rs = st.executeQuery();
+            if(rs.next()) {
+                int port = rs.getInt("port");
+                sql.closeConnection();
+                return port;
+            }
+            return 0;
+        } catch (SQLException | ClassNotFoundException e) {
+            e.printStackTrace();
+            return 0;
+        }
+    }
+
+    static String getMotd(String name) {
+        MySQL sql = Core.returnSQL();
+        try {
+            sql.openConnection();
+            PreparedStatement st = sql.getConnection().prepareStatement("SELECT motd FROM Servers WHERE name='" + name + "'");
+            ResultSet rs = st.executeQuery();
+            if(rs.next()) {
+                String motd = rs.getString("motd");
+                sql.closeConnection();
+                return motd;
+            }
+            return null;
+        } catch (SQLException | ClassNotFoundException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+}

src/main/java/eu/univento/core/api/server/ServerInfo.java

@@ -0,0 +1,50 @@
+package eu.univento.core.api.server;
+
+import java.util.regex.Pattern;
+
+/**
+ * @author joethei
+ * @version 0.1
+ */
+public class ServerInfo {
+
+    String name;
+    ServerPinger pinger;
+
+    public ServerInfo(String name) {
+        this.name = name;
+        pinger = new ServerPinger(name, 200);
+        pinger.ping();
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public Game getGame() {
+        String[] parts = getMotd().split(Pattern.quote(";"));
+        return Game.valueOf(parts[0]);
+    }
+
+    public String getGameState() {
+        String[] parts = getMotd().split(Pattern.quote(";"));
+        return parts[1];
+    }
+
+    public boolean isOnline() {
+        return pinger.isOnline();
+    }
+
+    public int getOnlinePlayers() {
+        return pinger.getPlayerCount();
+    }
+
+    public int getMaxPlayers() {
+        return pinger.getMaxPlayers();
+    }
+
+    public String getMotd() {
+        return ServerDatabase.getMotd(name);
+    }
+
+}

src/main/java/eu/univento/core/api/server/ServerPinger.java

@@ -0,0 +1,166 @@
+package eu.univento.core.api.server;
+
+import java.io.*;
+import java.net.InetSocketAddress;
+import java.net.Socket;
+import java.net.SocketException;
+import java.nio.charset.Charset;
+
+public class ServerPinger {
+
+    private String address;
+    private int port;
+    private int timeout;
+
+    private boolean online;
+    private int playercount;
+    private int maxplayers;
+    private String motd;
+
+    public ServerPinger(String name, int timeout){
+        this.address = ServerDatabase.getIP(name);
+        this.port = ServerDatabase.getPort(name);
+        this.timeout = timeout;
+    }
+
+    public String getAddress(){
+        return this.address;
+    }
+
+    public void setAddress(String address){
+        this.address = address;
+    }
+
+    public int getPort(){
+        return this.port;
+    }
+
+    public void setPort(int port){
+        this.port = port;
+    }
+
+    public int getTimeout(){
+        return this.timeout;
+    }
+
+    public void setTimeout(int timeout){
+        this.timeout = timeout;
+    }
+
+    public boolean isOnline(){
+        return this.online;
+    }
+
+    private void setOnline(boolean online){
+        this.online = online;
+    }
+
+    public int getPlayerCount(){
+        return this.playercount;
+    }
+
+    private void setPlayerCount(int playercount){
+        this.playercount = playercount;
+    }
+
+    public int getMaxPlayers(){
+        return this.maxplayers;
+    }
+
+    private void setMaxPlayers(int maxplayers){
+        this.maxplayers = maxplayers;
+    }
+
+    public String getMotd(){
+        return this.motd;
+    }
+
+    private void setMotd(String motd){
+        this.motd = motd;
+    }
+
+    public void ping(){
+        try{
+            Socket socket = new Socket();
+            OutputStream outputStream;
+            DataOutputStream dataOutputStream;
+            InputStream inputStream;
+            InputStreamReader inputStreamReader;
+            socket.setSoTimeout(this.timeout);
+            socket.connect(new InetSocketAddress(this.getAddress(), this.getPort()), this.getTimeout());
+            outputStream = socket.getOutputStream();
+            dataOutputStream = new DataOutputStream(outputStream);
+            inputStream = socket.getInputStream();
+            inputStreamReader = new InputStreamReader(inputStream, Charset.forName("UTF-16BE"));
+            dataOutputStream.write(new byte[]{(byte) 0xFE,(byte) 0x01});
+            int packetId = inputStream.read();
+            if(packetId == -1){
+                dataOutputStream.close();
+                outputStream.close();
+                inputStreamReader.close();
+                inputStream.close();
+                socket.close();
+                throw new IOException("Premature end of stream.");
+            }
+            if(packetId != 0xFF){
+                dataOutputStream.close();
+                outputStream.close();
+                inputStreamReader.close();
+                inputStream.close();
+                socket.close();
+                throw new IOException("Invalid packet ID (" + packetId + ").");
+            }
+            int length = inputStreamReader.read();
+            if(length == -1){
+                dataOutputStream.close();
+                outputStream.close();
+                inputStreamReader.close();
+                inputStream.close();
+                socket.close();
+                throw new IOException("Premature end of stream.");
+            }
+            if(length == 0){
+                dataOutputStream.close();
+                outputStream.close();
+                inputStreamReader.close();
+                inputStream.close();
+                socket.close();
+                throw new IOException("Invalid string length.");
+            }
+            char[] chars = new char[length];
+            if(inputStreamReader.read(chars,0,length) != length){
+                dataOutputStream.close();
+                outputStream.close();
+                inputStreamReader.close();
+                inputStream.close();
+                socket.close();
+                throw new IOException("Premature end of stream.");
+            }
+            String string = new String(chars);
+            if(string.startsWith("§")){
+                String[] data = string.split("\0");
+                this.setMotd(data[3]);
+                this.setOnline(true);
+                this.setPlayerCount(Integer.parseInt(data[4]));
+                this.setMaxPlayers(Integer.parseInt(data[5]));
+            }
+            else{
+                String[] data = string.split("§");
+                this.setMotd(data[0]);
+                this.setOnline(true);
+                this.setPlayerCount(Integer.parseInt(data[1]));
+                this.setMaxPlayers(Integer.parseInt(data[2]));
+            }
+            dataOutputStream.close();
+            outputStream.close();
+            inputStreamReader.close();
+            inputStream.close();
+            socket.close();
+        } catch (SocketException exception) {
+            this.setOnline(false);
+        } catch (IOException exception) {
+            this.setOnline(false);
+        }
+    }
+
+}

src/main/java/eu/univento/core/api/server/ServerSettings.java

@@ -0,0 +1,83 @@
+package eu.univento.core.api.server;
+
+import org.bukkit.GameMode;
+
+/**
+ * @author joethei
+ * @version 0.1
+ */
+public class ServerSettings {
+
+    private static boolean build;
+    private static boolean lobby;
+    private static boolean debug;
+    private static boolean mute;
+    private static boolean game;
+    private static Game playedGame;
+    private static GameMode gameMode;
+    private static String gameState;
+
+    public static Game getPlayedGame() {
+        return playedGame;
+    }
+
+    public static void setPlayedGame(Game game) {
+        ServerSettings.playedGame = game;
+    }
+
+    public static GameMode getGameMode() {
+        return gameMode;
+    }
+
+    public static void setGameMode(GameMode gameMode) {
+        ServerSettings.gameMode = gameMode;
+    }
+
+    public static boolean isGame() {
+        return game;
+    }
+
+    public static void setGame(boolean game) {
+        ServerSettings.game = game;
+    }
+
+    public static boolean isBuild() {
+        return build;
+    }
+
+    public static void setBuild(boolean build) {
+        ServerSettings.build = build;
+    }
+
+    public static boolean isLobby() {
+        return lobby;
+    }
+
+    public static void setLobby(boolean lobby) {
+        ServerSettings.lobby = lobby;
+    }
+
+    public static boolean isDebug() {
+        return debug;
+    }
+
+    public static void setDebug(boolean debug) {
+        ServerSettings.debug = debug;
+    }
+
+    public static boolean isMute() {
+        return mute;
+    }
+
+    public static void setMute(boolean mute) {
+        ServerSettings.mute = mute;
+    }
+
+    public static String getGameState() {
+        return gameState;
+    }
+
+    public static void setGameState(String gameState) {
+        ServerSettings.gameState = gameState;
+    }
+}

src/main/java/eu/univento/core/api/server/Servers.java

@@ -0,0 +1,44 @@
+package eu.univento.core.api.server;
+
+import eu.univento.core.Core;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+
+/**
+ * sends player to other bungeecord servers
+ * @author joethei
+ * @version 1.0
+ */
+public class Servers {
+	
+	
+	/**
+	 * sends player to server
+	 * @param p player
+	 * @param server name of server
+	 */
+	public static void connectServer(Player p, String server) {
+			ByteArrayOutputStream b = new ByteArrayOutputStream();
+			DataOutputStream out = new DataOutputStream(b);
+			try {
+				out.writeUTF("Connect");
+				out.writeUTF(server);
+			} catch (IOException el) {
+				el.printStackTrace();
+			}
+			p.sendPluginMessage(Core.getInstance(), "BungeeCord", b.toByteArray());
+	}
+
+	/**
+	 * connects all player to server
+	 * @param server name of server
+	 */
+	public static void connectAllToServer(String server) {
+		for (Player all : Bukkit.getOnlinePlayers())
+			connectServer(all, server);
+	}
+}

src/main/java/eu/univento/core/api/twitch/API.java

@@ -0,0 +1,25 @@
+package eu.univento.core.api.twitch;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.net.URL;
+
+public class API {
+	public static String readJsonFromUrl(String urlString) throws Exception {
+		BufferedReader reader = null;
+		try {
+			URL url = new URL(urlString);
+			reader = new BufferedReader(new InputStreamReader(url.openStream()));
+			StringBuffer buffer = new StringBuffer();
+			int read;
+			char[] chars = new char[1024];
+			while ((read = reader.read(chars)) != -1)
+				buffer.append(chars, 0, read);
+
+			return buffer.toString();
+		} finally {
+			if (reader != null)
+				reader.close();
+		}
+	}
+}

src/main/java/eu/univento/core/api/twitch/Twitch_API.java

@@ -0,0 +1,43 @@
+package eu.univento.core.api.twitch;
+
+
+import com.google.gson.Gson;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+
+
+public class Twitch_API {
+public static Gson gson = new Gson();
+
+
+
+
+public static Twitch_Stream getStream(String channelname){
+try{
+String json = API.readJsonFromUrl("http://api.justin.tv/api/stream/list.json?channel="+channelname);
+
+
+Twitch_Stream stream = new Twitch_Stream();
+if(json.equalsIgnoreCase("[]")){
+stream.setOnline(false);
+return stream;
+}
+JsonArray jb = gson.fromJson(json, JsonArray.class);
+JsonObject jo = (JsonObject) jb.get(0);
+stream.setOnline(true);
+stream.load(jo);
+return stream;
+} catch (Exception error){
+error.printStackTrace();
+}
+
+
+
+
+return null;
+
+
+
+
+}
+}

src/main/java/eu/univento/core/api/twitch/Twitch_Stream.java

@@ -0,0 +1,380 @@
+package eu.univento.core.api.twitch;
+
+import com.google.gson.JsonObject;
+
+public class Twitch_Stream {
+	boolean online;
+	int broadcast_part;
+	boolean featured;
+	boolean channel_subscription;
+	String id;
+	String category;
+	String title;
+	int channel_count;
+	int video_height;
+	int site_count;
+	boolean embed_enabled;
+	String up_time;
+	String meta_game;
+	String format;
+	int embed_count;
+	String stream_type;
+	boolean abuse_reported;
+	int video_width;
+	String geo;
+	String name;
+	String language;
+	int stream_count;
+	double video_bitrate;
+	String broadcaster;
+	int channel_view_count;
+	String username;
+	String status;
+	String channel_url;
+	boolean producer;
+	String subcategory_title;
+	String screen_cap_url_large;
+	String screen_cap_url_small;
+	String screen_cap_url_medium;
+	String screen_cap_url_huge;
+	String timezone;
+	String category_title;
+	int views_count;
+
+	public void load(JsonObject job) {
+		setBroadcast_part(job.get("broadcast_part").getAsInt());
+		setFeatured(job.get("featured").getAsBoolean());
+		setChannel_subscription(job.get("channel_subscription").getAsBoolean());
+		setId(job.get("id").getAsString());
+		setCategory(job.get("category").getAsString());
+		setTitle(job.get("title").getAsString());
+		setChannel_count(job.get("channel_count").getAsInt());
+		setVideo_height(job.get("video_height").getAsInt());
+		setSite_count(job.get("site_count").getAsInt());
+		setEmbed_enabled(job.get("embed_enabled").getAsBoolean());
+		setUp_time(job.get("up_time").getAsString());
+		setMeta_game(job.get("meta_game").getAsString());
+		setFormat(job.get("format").getAsString());
+		setEmbed_count(job.get("embed_count").getAsInt());
+		setStream_type(job.get("stream_type").getAsString());
+		setAbuse_reported(job.get("abuse_reported").getAsBoolean());
+		setVideo_width(job.get("video_width").getAsInt());
+		setGeo(job.get("geo").getAsString());
+		setName(job.get("name").getAsString());
+		setLanguage(job.get("language").getAsString());
+		setStream_count(job.get("stream_count").getAsInt());
+		setVideo_bitrate(job.get("video_bitrate").getAsDouble());
+		setBroadcaster(job.get("broadcaster").getAsString());
+		setChannel_view_count(job.get("channel_view_count").getAsInt());
+
+		setUsername(job.get("channel").getAsJsonObject().get("login").getAsString());
+		setTitle(job.get("channel").getAsJsonObject().get("status").getAsString());
+		setChannel_url(job.get("channel").getAsJsonObject().get("channel_url").getAsString());
+		setProducer(job.get("channel").getAsJsonObject().get("producer").getAsBoolean());
+
+		setSubcategory_title(job.get("channel").getAsJsonObject().get("subcategory_title").getAsString());
+		setScreen_cap_url_large(job.get("channel").getAsJsonObject().get("screen_cap_url_large").getAsString());
+		setScreen_cap_url_small(job.get("channel").getAsJsonObject().get("screen_cap_url_small").getAsString());
+		setScreen_cap_url_medium(job.get("channel").getAsJsonObject().get("screen_cap_url_medium").getAsString());
+		setScreen_cap_url_huge(job.get("channel").getAsJsonObject().get("screen_cap_url_huge").getAsString());
+		setTimezone(job.get("channel").getAsJsonObject().get("timezone").getAsString());
+		setCategory_title(job.get("channel").getAsJsonObject().get("category_title").getAsString());
+		setViews_count(job.get("channel").getAsJsonObject().get("views_count").getAsInt());
+	}
+
+	public boolean isOnline() {
+		return this.online;
+	}
+
+	public void setOnline(boolean online) {
+		this.online = online;
+	}
+
+	public int getBroadcast_part() {
+		return this.broadcast_part;
+	}
+
+	public void setBroadcast_part(int broadcast_part) {
+		this.broadcast_part = broadcast_part;
+	}
+
+	public boolean isFeatured() {
+		return this.featured;
+	}
+
+	public void setFeatured(boolean featured) {
+		this.featured = featured;
+	}
+
+	public boolean isChannel_subscription() {
+		return this.channel_subscription;
+	}
+
+	public void setChannel_subscription(boolean channel_subscription) {
+		this.channel_subscription = channel_subscription;
+	}
+
+	public String getId() {
+		return this.id;
+	}
+
+	public void setId(String id) {
+		this.id = id;
+	}
+
+	public String getCategory() {
+		return this.category;
+	}
+
+	public void setCategory(String category) {
+		this.category = category;
+	}
+
+	public String getTitle() {
+		return this.title;
+	}
+
+	public void setTitle(String title) {
+		this.title = title;
+	}
+
+	public int getChannel_count() {
+		return this.channel_count;
+	}
+
+	public void setChannel_count(int channel_count) {
+		this.channel_count = channel_count;
+	}
+
+	public int getVideo_height() {
+		return this.video_height;
+	}
+
+	public void setVideo_height(int video_height) {
+		this.video_height = video_height;
+	}
+
+	public int getSite_count() {
+		return this.site_count;
+	}
+
+	public void setSite_count(int site_count) {
+		this.site_count = site_count;
+	}
+
+	public boolean isEmbed_enabled() {
+		return this.embed_enabled;
+	}
+
+	public void setEmbed_enabled(boolean embed_enabled) {
+		this.embed_enabled = embed_enabled;
+	}
+
+	public String getUp_time() {
+		return this.up_time;
+	}
+
+	public void setUp_time(String up_time) {
+		this.up_time = up_time;
+	}
+
+	public String getMeta_game() {
+		return this.meta_game;
+	}
+
+	public void setMeta_game(String meta_game) {
+		this.meta_game = meta_game;
+	}
+
+	public String getFormat() {
+		return this.format;
+	}
+
+	public void setFormat(String format) {
+		this.format = format;
+	}
+
+	public int getEmbed_count() {
+		return this.embed_count;
+	}
+
+	public void setEmbed_count(int embed_count) {
+		this.embed_count = embed_count;
+	}
+
+	public String getStream_type() {
+		return this.stream_type;
+	}
+
+	public void setStream_type(String stream_type) {
+		this.stream_type = stream_type;
+	}
+
+	public boolean isAbuse_reported() {
+		return this.abuse_reported;
+	}
+
+	public void setAbuse_reported(boolean abuse_reported) {
+		this.abuse_reported = abuse_reported;
+	}
+
+	public int getVideo_width() {
+		return this.video_width;
+	}
+
+	public void setVideo_width(int video_width) {
+		this.video_width = video_width;
+	}
+
+	public String getGeo() {
+		return this.geo;
+	}
+
+	public void setGeo(String geo) {
+		this.geo = geo;
+	}
+
+	public String getName() {
+		return this.name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	public String getLanguage() {
+		return this.language;
+	}
+
+	public void setLanguage(String language) {
+		this.language = language;
+	}
+
+	public int getStream_count() {
+		return this.stream_count;
+	}
+
+	public void setStream_count(int stream_count) {
+		this.stream_count = stream_count;
+	}
+
+	public double getVideo_bitrate() {
+		return this.video_bitrate;
+	}
+
+	public void setVideo_bitrate(double video_bitrate) {
+		this.video_bitrate = video_bitrate;
+	}
+
+	public String getBroadcaster() {
+		return this.broadcaster;
+	}
+
+	public void setBroadcaster(String broadcaster) {
+		this.broadcaster = broadcaster;
+	}
+
+	public int getChannel_view_count() {
+		return this.channel_view_count;
+	}
+
+	public void setChannel_view_count(int channel_view_count) {
+		this.channel_view_count = channel_view_count;
+	}
+
+	public String getUsername() {
+		return this.username;
+	}
+
+	public void setUsername(String username) {
+		this.username = username;
+	}
+
+	public String getStatus() {
+		return this.status;
+	}
+
+	public void setStatus(String status) {
+		this.status = status;
+	}
+
+	public String getChannel_url() {
+		return this.channel_url;
+	}
+
+	public void setChannel_url(String channel_url) {
+		this.channel_url = channel_url;
+	}
+
+	public boolean isProducer() {
+		return this.producer;
+	}
+
+	public void setProducer(boolean producer) {
+		this.producer = producer;
+	}
+
+	public String getSubcategory_title() {
+		return this.subcategory_title;
+	}
+
+	public void setSubcategory_title(String subcategory_title) {
+		this.subcategory_title = subcategory_title;
+	}
+
+	public String getScreen_cap_url_large() {
+		return this.screen_cap_url_large;
+	}
+
+	public void setScreen_cap_url_large(String screen_cap_url_large) {
+		this.screen_cap_url_large = screen_cap_url_large;
+	}
+
+	public String getScreen_cap_url_small() {
+		return this.screen_cap_url_small;
+	}
+
+	public void setScreen_cap_url_small(String screen_cap_url_small) {
+		this.screen_cap_url_small = screen_cap_url_small;
+	}
+
+	public String getScreen_cap_url_medium() {
+		return this.screen_cap_url_medium;
+	}
+
+	public void setScreen_cap_url_medium(String screen_cap_url_medium) {
+		this.screen_cap_url_medium = screen_cap_url_medium;
+	}
+
+	public String getScreen_cap_url_huge() {
+		return this.screen_cap_url_huge;
+	}
+
+	public void setScreen_cap_url_huge(String screen_cap_url_huge) {
+		this.screen_cap_url_huge = screen_cap_url_huge;
+	}
+
+	public String getTimezone() {
+		return this.timezone;
+	}
+
+	public void setTimezone(String timezone) {
+		this.timezone = timezone;
+	}
+
+	public String getCategory_title() {
+		return this.category_title;
+	}
+
+	public void setCategory_title(String category_title) {
+		this.category_title = category_title;
+	}
+
+	public int getViews_count() {
+		return this.views_count;
+	}
+
+	public void setViews_count(int views_count) {
+		this.views_count = views_count;
+	}
+}

src/main/java/eu/univento/core/api/utils/Direction.java

@@ -0,0 +1,37 @@
+package eu.univento.core.api.utils;
+
+public enum Direction
+{
+  NORTH(1, 0), 
+  SOUTH(-1, 0), 
+  EAST(0, 1), 
+  WEST(0, -1), 
+  NORTHEAST(1, 1), 
+  SOUTHEAST(-1, 1), 
+  NORTHWEST(1, -1), 
+  SOUTHWEST(-1, -1);
+
+  private int x;
+  private int z;
+
+  private Direction(int x, int z) { this.x = x;
+    this.z = z; }
+
+  public int getX()
+  {
+    return this.x;
+  }
+
+  public int getZ() {
+    return this.z;
+  }
+
+  public static Direction getDirection(String direction) {
+    for (Direction dir : values())
+    {
+      if (dir.name().equalsIgnoreCase(direction))
+        return dir;
+    }
+    return null;
+  }
+}

src/main/java/eu/univento/core/api/utils/GameProfileBuilder.java

@@ -0,0 +1,171 @@
+package eu.univento.core.api.utils;
+
+import com.google.gson.*;
+import com.mojang.authlib.GameProfile;
+import com.mojang.authlib.properties.Property;
+import com.mojang.authlib.properties.PropertyMap;
+import com.mojang.util.UUIDTypeAdapter;
+import org.yaml.snakeyaml.external.biz.base64Coder.Base64Coder;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.lang.reflect.Type;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.UUID;
+
+/**
+ * @author Jofkos
+ */
+public class GameProfileBuilder {
+
+    private static final String SERVICE_URL = "https://sessionserver.mojang.com/session/minecraft/profile/%s?unsigned=false";
+    private static final String JSON_SKIN = "{\"timestamp\":%d,\"profileId\":\"%s\",\"profileName\":\"%s\",\"isPublic\":true,\"textures\":{\"SKIN\":{\"url\":\"%s\"}}}";
+    private static final String JSON_CAPE = "{\"timestamp\":%d,\"profileId\":\"%s\",\"profileName\":\"%s\",\"isPublic\":true,\"textures\":{\"SKIN\":{\"url\":\"%s\"},\"CAPE\":{\"url\":\"%s\"}}}";
+
+    private static Gson gson = new GsonBuilder().disableHtmlEscaping().registerTypeAdapter(UUID.class, new UUIDTypeAdapter()).registerTypeAdapter(GameProfile.class, new GameProfileSerializer()).registerTypeAdapter(PropertyMap.class, new PropertyMap.Serializer()).create();
+
+    private static HashMap<UUID, CachedProfile> cache = new HashMap<>();
+
+    private static long cacheTime = -1;
+
+    /**
+     * Don't run in main thread!
+     *
+     * Fetches the GameProfile from the Mojang servers
+     *
+     * @param uuid The player uuid
+     * @return The GameProfile
+     * @throws IOException If something wents wrong while fetching
+     * @see GameProfile
+     */
+    public static GameProfile fetch(UUID uuid) throws IOException {
+        return fetch(uuid, false);
+    }
+
+    /**
+     * Don't run in main thread!
+     *
+     * Fetches the GameProfile from the Mojang servers
+     * @param uuid The player uuid
+     * @param forceNew If true the cache is ignored
+     * @return The GameProfile
+     * @throws IOException If something wents wrong while fetching
+     * @see GameProfile
+     */
+    public static GameProfile fetch(UUID uuid, boolean forceNew) throws IOException {
+        if (!forceNew && cache.containsKey(uuid) && cache.get(uuid).isValid()) {
+            return cache.get(uuid).profile;
+        } else {
+            HttpURLConnection connection = (HttpURLConnection) new URL(String.format(SERVICE_URL, UUIDTypeAdapter.fromUUID(uuid))).openConnection();
+            connection.setReadTimeout(5000);
+
+            if (connection.getResponseCode() == HttpURLConnection.HTTP_OK) {
+                String json = new BufferedReader(new InputStreamReader(connection.getInputStream())).readLine();
+
+                GameProfile result = gson.fromJson(json, GameProfile.class);
+                cache.put(uuid, new CachedProfile(result));
+                return result;
+            } else {
+                if (!forceNew && cache.containsKey(uuid)) {
+                    return cache.get(uuid).profile;
+                }
+                JsonObject error = (JsonObject) new JsonParser().parse(new BufferedReader(new InputStreamReader(connection.getErrorStream())).readLine());
+                throw new IOException(error.get("error").getAsString() + ": " + error.get("errorMessage").getAsString());
+            }
+        }
+    }
+
+    /**
+     * Builds a GameProfile for the specified args
+     *
+     * @param uuid The uuid
+     * @param name The name
+     * @param skin The url from the skin image
+     * @return A GameProfile built from the arguments
+     * @see GameProfile
+     */
+    public static GameProfile getProfile(UUID uuid, String name, String skin) {
+        return getProfile(uuid, name, skin, null);
+    }
+
+    /**
+     * Builds a GameProfile for the specified args
+     *
+     * @param uuid The uuid
+     * @param name The name
+     * @param skinUrl Url from the skin image
+     * @param capeUrl Url from the cape image
+     * @return A GameProfile built from the arguments
+     * @see GameProfile
+     */
+    public static GameProfile getProfile(UUID uuid, String name, String skinUrl, String capeUrl) {
+        GameProfile profile = new GameProfile(uuid, name);
+        boolean cape = capeUrl != null && !capeUrl.isEmpty();
+
+        List<Object> args = new ArrayList<Object>();
+        args.add(System.currentTimeMillis());
+        args.add(UUIDTypeAdapter.fromUUID(uuid));
+        args.add(name);
+        args.add(skinUrl);
+        if (cape) args.add(capeUrl);
+
+        profile.getProperties().put("textures", new Property("textures", Base64Coder.encodeString(String.format(cape ? JSON_CAPE : JSON_SKIN, args.toArray(new Object[args.size()])))));
+        return profile;
+    }
+
+    /**
+     * Sets the time as long as you want to keep the gameprofiles in cache (-1 = never remove it)
+     * @param time cache time (default = -1)
+     */
+    public static void setCacheTime(long time) {
+        cacheTime = time;
+    }
+
+    private static class GameProfileSerializer implements JsonSerializer<GameProfile>, JsonDeserializer<GameProfile> {
+
+        public GameProfile deserialize(JsonElement json, Type type, JsonDeserializationContext context) throws JsonParseException {
+            JsonObject object = (JsonObject) json;
+            UUID id = object.has("id") ? (UUID) context.deserialize(object.get("id"), UUID.class) : null;
+            String name = object.has("name") ? object.getAsJsonPrimitive("name").getAsString() : null;
+            GameProfile profile = new GameProfile(id, name);
+
+            if (object.has("properties")) {
+                for (Entry<String, Property> prop : ((PropertyMap) context.deserialize(object.get("properties"), PropertyMap.class)).entries()) {
+                    profile.getProperties().put(prop.getKey(), prop.getValue());
+                }
+            }
+            return profile;
+        }
+
+        public JsonElement serialize(GameProfile profile, Type type, JsonSerializationContext context) {
+            JsonObject result = new JsonObject();
+            if (profile.getId() != null)
+                result.add("id", context.serialize(profile.getId()));
+            if (profile.getName() != null)
+                result.addProperty("name", profile.getName());
+            if (!profile.getProperties().isEmpty())
+                result.add("properties", context.serialize(profile.getProperties()));
+            return result;
+        }
+    }
+
+    private static class CachedProfile {
+
+        private long timestamp = System.currentTimeMillis();
+        private GameProfile profile;
+
+        public CachedProfile(GameProfile profile) {
+            this.profile = profile;
+        }
+
+        public boolean isValid() {
+            return cacheTime < 0 ? true : (System.currentTimeMillis() - timestamp) < cacheTime;
+        }
+    }
+}

src/main/java/eu/univento/core/api/utils/Maths.java

@@ -0,0 +1,281 @@
+package eu.univento.core.api.utils;
+
+import java.util.Calendar;
+import java.util.GregorianCalendar;
+import java.util.Random;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public final class Maths
+{
+  public static final float nanoToSec = 1.0E-009F;
+  public static final float FLOAT_ROUNDING_ERROR = 1.0E-006F;
+  public static final float PI = 3.141593F;
+  public static final float PI2 = 6.283186F;
+  public static final float SQRT_3 = 1.73205F;
+  public static final float E = 2.718282F;
+  public static final float radiansToDegrees = 57.295776F;
+  public static final float radDeg = 57.295776F;
+  public static final float degreesToRadians = 0.01745329F;
+  public static final float degRad = 0.01745329F;
+  static final int ATAN2_DIM = (int)Math.sqrt(16384.0D);
+  private static final float INV_ATAN2_DIM_MINUS_1 = 1.0F / (ATAN2_DIM - 1);
+
+  public static Random random = new Random();
+
+  public static final float sin(float radians) {
+    return Sin.table[((int)(radians * 2607.5945F) & 0x3FFF)];
+  }
+
+  public static final float cos(float radians)
+  {
+    return Sin.table[((int)((radians + 1.570796F) * 2607.5945F) & 0x3FFF)];
+  }
+
+  public static final float sinDeg(float degrees)
+  {
+    return Sin.table[((int)(degrees * 45.511112F) & 0x3FFF)];
+  }
+
+  public static final float cosDeg(float degrees)
+  {
+    return Sin.table[((int)((degrees + 90.0F) * 45.511112F) & 0x3FFF)];
+  }
+
+  public static final float atan2(float y, float x)
+  {
+    float mul;
+    float add;
+    if (x < 0.0F)
+    {
+      if (y < 0.0F) {
+        y = -y;
+        mul = 1.0F;
+      } else {
+        mul = -1.0F;
+      }x = -x;
+      add = -3.141593F;
+    }
+    else
+    {
+      if (y < 0.0F) {
+        y = -y;
+        mul = -1.0F;
+      } else {
+        mul = 1.0F;
+      }add = 0.0F;
+    }
+    float invDiv = 1.0F / ((x < y ? y : x) * INV_ATAN2_DIM_MINUS_1);
+
+    if (invDiv == 1.0F) return ((float)Math.atan2(y, x) + add) * mul;
+
+    int xi = (int)(x * invDiv);
+    int yi = (int)(y * invDiv);
+    return (Atan2.table[(yi * ATAN2_DIM + xi)] + add) * mul;
+  }
+
+  public static final int random(int range)
+  {
+    return random.nextInt(range + 1);
+  }
+
+  public static final int random(int start, int end)
+  {
+    return start + random.nextInt(end - start + 1);
+  }
+
+  public static final boolean randomBoolean()
+  {
+    return random.nextBoolean();
+  }
+
+  public static final boolean randomBoolean(float chance)
+  {
+    return random() < chance;
+  }
+
+  public static final float random()
+  {
+    return random.nextFloat();
+  }
+
+  public static final float random(float range)
+  {
+    return random.nextFloat() * range;
+  }
+
+  public static final float random(float start, float end)
+  {
+    return start + random.nextFloat() * (end - start);
+  }
+
+  public static int nextPowerOfTwo(int value)
+  {
+    if (value == 0) return 1;
+    value--;
+    value |= value >> 1;
+    value |= value >> 2;
+    value |= value >> 4;
+    value |= value >> 8;
+    value |= value >> 16;
+    return value + 1;
+  }
+
+  public static boolean isPowerOfTwo(int value) {
+    return (value != 0) && ((value & value - 1) == 0);
+  }
+
+  public static int clamp(int value, int min, int max)
+  {
+    if (value < min) return min;
+    if (value > max) return max;
+    return value;
+  }
+
+  public static short clamp(short value, short min, short max) {
+    if (value < min) return min;
+    if (value > max) return max;
+    return value;
+  }
+
+  public static float clamp(float value, float min, float max) {
+    if (value < min) return min;
+    if (value > max) return max;
+    return value;
+  }
+
+  public static int floor(float x)
+  {
+    return (int)(x + 16384.0D) - 16384;
+  }
+
+  public static int floorPositive(float x)
+  {
+    return (int)x;
+  }
+
+  public static int ceil(float x)
+  {
+    return (int)(x + 16384.999999999996D) - 16384;
+  }
+
+  public static int ceilPositive(float x)
+  {
+    return (int)(x + 0.9999999000000001D);
+  }
+
+  public static int round(float x)
+  {
+    return (int)(x + 16384.5D) - 16384;
+  }
+
+  public static int roundPositive(float x)
+  {
+    return (int)(x + 0.5F);
+  }
+
+  public static boolean isZero(float value)
+  {
+    return Math.abs(value) <= 1.0E-006F;
+  }
+
+  public static boolean isZero(float value, float tolerance)
+  {
+    return Math.abs(value) <= tolerance;
+  }
+
+  public static boolean isEqual(float a, float b)
+  {
+    return Math.abs(a - b) <= 1.0E-006F;
+  }
+
+  public static boolean isEqual(float a, float b, float tolerance)
+  {
+    return Math.abs(a - b) <= tolerance;
+  }
+
+  public static long parseDateDiff(String time, boolean future)
+    throws Exception
+  {
+    Pattern timePattern = Pattern.compile("(?:([0-9]+)\\s*y[a-z]*[,\\s]*)?(?:([0-9]+)\\s*mo[a-z]*[,\\s]*)?(?:([0-9]+)\\s*w[a-z]*[,\\s]*)?(?:([0-9]+)\\s*d[a-z]*[,\\s]*)?(?:([0-9]+)\\s*h[a-z]*[,\\s]*)?(?:([0-9]+)\\s*m[a-z]*[,\\s]*)?(?:([0-9]+)\\s*(?:s[a-z]*)?)?", 2);
+    Matcher m = timePattern.matcher(time);
+    int years = 0;
+    int months = 0;
+    int weeks = 0;
+    int days = 0;
+    int hours = 0;
+    int minutes = 0;
+    int seconds = 0;
+    boolean found = false;
+    while (m.find()) {
+      if ((m.group() == null) || (m.group().isEmpty())) {
+        continue;
+      }
+      for (int i = 0; i < m.groupCount(); i++) {
+        if ((m.group(i) != null) && (!m.group(i).isEmpty())) {
+          found = true;
+          break;
+        }
+      }
+      if (found) {
+        if ((m.group(1) != null) && (!m.group(1).isEmpty()))
+          years = Integer.parseInt(m.group(1));
+        if ((m.group(2) != null) && (!m.group(2).isEmpty()))
+          months = Integer.parseInt(m.group(2));
+        if ((m.group(3) != null) && (!m.group(3).isEmpty()))
+          weeks = Integer.parseInt(m.group(3));
+        if ((m.group(4) != null) && (!m.group(4).isEmpty()))
+          days = Integer.parseInt(m.group(4));
+        if ((m.group(5) != null) && (!m.group(5).isEmpty()))
+          hours = Integer.parseInt(m.group(5));
+        if ((m.group(6) != null) && (!m.group(6).isEmpty()))
+          minutes = Integer.parseInt(m.group(6));
+        if ((m.group(7) == null) || (m.group(7).isEmpty())) break;
+        seconds = Integer.parseInt(m.group(7));
+        break;
+      }
+    }
+    if (!found)
+      throw new Exception("Illegal Date");
+    Calendar c = new GregorianCalendar();
+    if (years > 0)
+      c.add(1, years * (future ? 1 : -1));
+    if (months > 0)
+      c.add(2, months * (future ? 1 : -1));
+    if (weeks > 0)
+      c.add(3, weeks * (future ? 1 : -1));
+    if (days > 0)
+      c.add(5, days * (future ? 1 : -1));
+    if (hours > 0)
+      c.add(11, hours * (future ? 1 : -1));
+    if (minutes > 0)
+      c.add(12, minutes * (future ? 1 : -1));
+    if (seconds > 0)
+      c.add(13, seconds * (future ? 1 : -1));
+    return c.getTimeInMillis();
+  }
+
+  private static class Atan2
+  {
+    static final float[] table = new float[16384];
+
+    static { for (int i = 0; i < Maths.ATAN2_DIM; i++)
+        for (int j = 0; j < Maths.ATAN2_DIM; j++) {
+          float x0 = i / Maths.ATAN2_DIM;
+          float y0 = j / Maths.ATAN2_DIM;
+          table[(j * Maths.ATAN2_DIM + i)] = (float)Math.atan2(y0, x0);
+        }
+    }
+  }
+
+  private static class Sin
+  {
+    static final float[] table = new float[16384];
+
+    static { for (int i = 0; i < 16384; i++)
+        table[i] = (float)Math.sin((i + 0.5F) / 16384.0F * 6.283186F);
+      for (int i = 0; i < 360; i += 90)
+        table[((int)(i * 45.511112F) & 0x3FFF)] = (float)Math.sin(i * 0.01745329F);
+    }
+  }
+}

src/main/java/eu/univento/core/api/utils/NameFetcher.java

@@ -0,0 +1,49 @@
+package eu.univento.core.api.utils;
+
+import com.google.common.collect.ImmutableList;
+import org.json.simple.JSONObject;
+import org.json.simple.parser.JSONParser;
+
+import java.io.InputStreamReader;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.Callable;
+
+public class NameFetcher implements Callable<Map<UUID, String>>{
+  private static final String PROFILE_URL = "https://sessionserver.mojang.com/session/minecraft/profile/";
+  private final JSONParser jsonParser = new JSONParser();
+  private final List<UUID> uuids;
+
+  public NameFetcher(List<UUID> uuids)
+  {
+    this.uuids = ImmutableList.copyOf(uuids);
+  }
+
+  public Map<UUID, String> call() throws Exception
+  {
+    Map<UUID, String> uuidStringMap = new HashMap<UUID, String>();
+    for (UUID uuid : this.uuids) {
+      HttpURLConnection connection = (HttpURLConnection)new URL("https://sessionserver.mojang.com/session/minecraft/profile/" + uuid.toString().replace("-", "")).openConnection();
+      JSONObject response = (JSONObject)this.jsonParser.parse(new InputStreamReader(connection.getInputStream()));
+      String name = (String)response.get("name");
+      if (name == null) {
+        continue;
+      }
+      String cause = (String)response.get("cause");
+      String errorMessage = (String)response.get("errorMessage");
+      if ((cause != null) && (cause.length() > 0)) {
+        throw new IllegalStateException(errorMessage);
+      }
+      uuidStringMap.put(uuid, name);
+    }
+    return uuidStringMap;
+  }
+
+public static String getProfileUrl() {
+	return PROFILE_URL;
+}
+}

src/main/java/eu/univento/core/api/utils/RandomCollection.java

@@ -0,0 +1,41 @@
+package eu.univento.core.api.utils;
+
+import java.util.NavigableMap;
+import java.util.Random;
+import java.util.TreeMap;
+
+public class RandomCollection<E>
+{
+  private final NavigableMap<Double, E> map = new TreeMap<Double, E>();
+  private final Random random;
+  private double total = 0.0D;
+
+  public RandomCollection() {
+    this(new Random());
+  }
+
+  public RandomCollection(Random random) {
+    this.random = random;
+  }
+
+  public void add(double weight, E result) {
+    if (weight <= 0.0D) return;
+    this.total += weight;
+    this.map.put(Double.valueOf(this.total), result);
+  }
+
+  public E next() {
+    double value = this.random.nextDouble() * this.total;
+    return this.map.ceilingEntry(Double.valueOf(value)).getValue();
+  }
+
+  public E random() {
+    double value = this.random.nextDouble() * this.total;
+
+    while (this.random.nextBoolean()) {
+      value = this.random.nextDouble() * this.total;
+    }
+
+    return this.map.ceilingEntry(Double.valueOf(value)).getValue();
+  }
+}

src/main/java/eu/univento/core/api/utils/Vectors.java

@@ -0,0 +1,45 @@
+package eu.univento.core.api.utils;
+
+import org.bukkit.util.Vector;
+
+public final class Vectors
+{
+  public static final Vector rotateAroundAxisX(Vector v, double angle)
+  {
+    double cos = Math.cos(angle);
+    double sin = Math.sin(angle);
+    double y = v.getY() * cos - v.getZ() * sin;
+    double z = v.getY() * sin + v.getZ() * cos;
+    return v.setY(y).setZ(z);
+  }
+
+  public static final Vector rotateAroundAxisY(Vector v, double angle)
+  {
+    double cos = Math.cos(angle);
+    double sin = Math.sin(angle);
+    double x = v.getX() * cos + v.getZ() * sin;
+    double z = v.getX() * -sin + v.getZ() * cos;
+    return v.setX(x).setZ(z);
+  }
+
+  public static final Vector rotateAroundAxisZ(Vector v, double angle)
+  {
+    double cos = Math.cos(angle);
+    double sin = Math.sin(angle);
+    double x = v.getX() * cos - v.getY() * sin;
+    double y = v.getX() * sin + v.getY() * cos;
+    return v.setX(x).setY(y);
+  }
+
+  public static final Vector rotateVector(Vector v, double angleX, double angleY, double angleZ)
+  {
+    rotateAroundAxisX(v, angleX);
+    rotateAroundAxisY(v, angleY);
+    rotateAroundAxisZ(v, angleZ);
+    return v;
+  }
+
+  public static final double angleToXAxis(Vector vector) {
+    return Math.atan2(vector.getX(), vector.getY());
+  }
+}

src/main/java/eu/univento/core/api/utils/reflection/IReflection.java

@@ -0,0 +1,256 @@
+package eu.univento.core.api.utils.reflection;
+
+import org.bukkit.Bukkit;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.Map;
+
+
+/**
+ * -== IReflection ==-
+ *
+ * This library was created by @Ingrim4 and allows you to use the reflection-api implemented in java easily for spigot plugins
+ * You are welcome to use it and redistribute it under the following conditions:
+ *  * Don't claim this class as your own
+ *  * Don't remove this disclaimer
+ *
+ * @author Ingrim4
+ * @version 1.2.8
+ */
+public class IReflection {
+
+    public interface ConstructorAccessor {
+
+        public Object newInstance(Object... args);
+
+        public Constructor<?> getConstructor();
+
+    }
+
+    public interface MethodAccessor {
+
+        public Object invoke(Object target, Object... args);
+
+        public Method getMehtod();
+
+    }
+
+    public interface FieldAccessor<T> {
+
+        public T get(Object target);
+
+        public void set(Object target, Object value);
+
+        public Field getField();
+
+    }
+
+    public static Class<?> getClass(ServerPacket packet, String name) {
+        try {
+            return Class.forName(packet + name);
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public static ConstructorAccessor getConstructor(Class<?> clazz, Class<?>... parameterTypes) {
+        Class<?>[] p = DataType.convertToPrimitive(parameterTypes);
+        for (Constructor<?> c : clazz.getDeclaredConstructors())
+            if (DataType.equalsArray(DataType.convertToPrimitive(c.getParameterTypes()), p)) {
+                c.setAccessible(true);
+                return new ConstructorAccessor() {
+
+                    @Override
+                    public Object newInstance(Object... args) {
+                        try {
+                            return c.newInstance(args);
+                        } catch (IllegalAccessException e) {
+                            throw new IllegalStateException("Cannot use reflection.", e);
+                        } catch (InvocationTargetException e) {
+                            throw new RuntimeException("An internal error occured.", e.getCause());
+                        } catch (InstantiationException e) {
+                            throw new RuntimeException("Cannot instantiate object.", e);
+                        } catch (IllegalArgumentException e) {
+                            throw e;
+                        }
+                    }
+
+                    @Override
+                    public Constructor<?> getConstructor() {
+                        return c;
+                    }
+                };
+            }
+        if (clazz.getSuperclass() != null)
+            return IReflection.getConstructor(clazz.getSuperclass(), parameterTypes);
+        return null;
+    }
+
+    public static MethodAccessor getMethod(Class<?> target, String methodName, Class<?>... parameterTypes) {
+        return IReflection.getMethod(target, methodName, null, parameterTypes);
+    }
+
+    public static MethodAccessor getMethod(Class<?> target, String methodName, Class<?> returnType, Class<?>... parameterTypes) {
+        Class<?>[] primitiveParameter = DataType.convertToPrimitive(parameterTypes);
+        for (Method method : target.getDeclaredMethods())
+            if ((methodName == null || method.getName().equals(methodName)) && (returnType == null || method.getReturnType().equals(returnType)) && (primitiveParameter.length == 0 || DataType.equalsArray(DataType.convertToPrimitive(method.getParameterTypes()), primitiveParameter))) {
+                method.setAccessible(true);
+                return new MethodAccessor() {
+
+                    @Override
+                    public Object invoke(Object target, Object... args) {
+                        try {
+                            return method.invoke(target, args);
+                        } catch (IllegalAccessException e) {
+                            throw new IllegalStateException("Cannot use reflection.", e);
+                        } catch (InvocationTargetException e) {
+                            throw new RuntimeException("An internal error occured.", e.getCause());
+                        } catch (IllegalArgumentException e) {
+                            throw e;
+                        }
+                    }
+
+                    @Override
+                    public Method getMehtod() {
+                        return method;
+                    }
+                };
+            }
+        if (target.getSuperclass() != null)
+            return IReflection.getMethod(target.getSuperclass(), methodName, returnType, parameterTypes);
+
+        throw new IllegalStateException(String.format("Unable to find method %s (%s).", methodName, parameterTypes));
+    }
+
+    public static <T> FieldAccessor<T> getField(Class<?> target, String fieldName) {
+        return IReflection.getField(target, fieldName, null, 0);
+    }
+
+    public static <T> FieldAccessor<T> getField(Class<?> target, Class<T> fieldType, int index) {
+        return IReflection.getField(target, null, fieldType, index);
+    }
+
+    private static <T> FieldAccessor<T> getField(Class<?> target, String fieldName, Class<T> fieldType, int index) {
+        for (Field field : target.getDeclaredFields())
+            if ((fieldName == null || fieldName.equals(field.getName())) && (fieldType == null || (fieldType.isAssignableFrom(field.getType()) && index-- <= 0))) {
+                field.setAccessible(true);
+                return new FieldAccessor<T>() {
+
+                    @Override
+                    @SuppressWarnings("unchecked")
+                    public T get(Object target) {
+                        try {
+                            return (T) field.get(target);
+                        } catch (IllegalAccessException e) {
+                            throw new IllegalStateException("Cannot use reflection.", e);
+                        } catch (IllegalArgumentException e) {
+                            throw e;
+                        }
+                    }
+
+                    @Override
+                    public void set(Object target, Object value) {
+                        try {
+                            field.set(target, value);
+                        } catch (IllegalAccessException e) {
+                            throw new IllegalStateException("Cannot use reflection.", e);
+                        } catch (IllegalArgumentException e) {
+                            throw e;
+                        }
+                    }
+
+                    @Override
+                    public Field getField() {
+                        return field;
+                    }
+                };
+            }
+
+        if (target.getSuperclass() != null)
+            return IReflection.getField(target.getSuperclass(), fieldName, fieldType, index);
+
+        throw new IllegalStateException(String.format("Unable to find field %s (%s).", fieldName, fieldType));
+    }
+
+    public enum DataType {
+        BYTE(byte.class, Byte.class), SHORT(short.class, Short.class), INTEGER(int.class,
+                Integer.class), LONG(long.class, Long.class), CHARACTER(char.class, Character.class), FLOAT(float.class,
+                Float.class), DOUBLE(double.class, Double.class), BOOLEAN(boolean.class, Boolean.class);
+
+        private static final Map<Class<?>, DataType> CLASS_MAP = new HashMap<Class<?>, DataType>();
+        private final Class<?> primitive;
+        private final Class<?> reference;
+
+        static {
+            for (DataType t : DataType.values()) {
+                DataType.CLASS_MAP.put(t.primitive, t);
+                DataType.CLASS_MAP.put(t.reference, t);
+            }
+        }
+
+        private DataType(Class<?> primitive, Class<?> reference) {
+            this.primitive = primitive;
+            this.reference = reference;
+        }
+
+        public Class<?> getPrimitive() {
+            return this.primitive;
+        }
+
+        public Class<?> getReference() {
+            return this.reference;
+        }
+
+        public static DataType fromClass(Class<?> c) {
+            return DataType.CLASS_MAP.get(c);
+        }
+
+        public static Class<?> getPrimitive(Class<?> c) {
+            DataType t = DataType.fromClass(c);
+            return t == null ? c : t.getPrimitive();
+        }
+
+        public static Class<?> getReference(Class<?> c) {
+            DataType t = DataType.fromClass(c);
+            return t == null ? c : t.getReference();
+        }
+
+        public static Class<?>[] convertToPrimitive(Class<?>[] classes) {
+            int length = classes == null ? 0 : classes.length;
+            Class<?>[] types = new Class<?>[length];
+            for (int i = 0; i < length; i++)
+                types[i] = DataType.getPrimitive(classes[i]);
+            return types;
+        }
+
+        public static boolean equalsArray(Class<?>[] a1, Class<?>[] a2) {
+            if (a1 == null || a2 == null || a1.length != a2.length)
+                return false;
+            for (int i = 0; i < a1.length; i++)
+                if (!a1[i].equals(a2[i]) && !a1[i].isAssignableFrom(a2[i]))
+                    return false;
+            return true;
+        }
+    }
+
+    public enum ServerPacket {
+
+        MINECRAFT_PACKAGE("net.minecraft.server." + Bukkit.getServer().getClass().getPackage().getName().substring(23)), MOJANG_AUTHLIB("com.mojang.authlib"), CRAFTBUKKIT_PACKAGE(Bukkit.getServer().getClass().getPackage().getName());
+
+        ServerPacket(String source) {
+            this.name = source;
+        }
+
+        private final String name;
+
+        @Override
+        public String toString() {
+            return this.name + ".";
+        }
+    }
+}

src/main/java/eu/univento/core/api/utils/reflection/Reflection.java

@@ -0,0 +1,141 @@
+package eu.univento.core.api.utils.reflection;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class Reflection
+{
+  public static final Class<?> CLASS_CRAFTITEMSTACK = getCraftBukkitClass("inventory.CraftItemStack");
+  public static final Method METHOD_ASNMSCOPY = getMethod(CLASS_CRAFTITEMSTACK, "asNMSCopy");
+
+  public static void sendPacket(Player p, Object packet) {
+    try {
+      Object nmsPlayer = getNMSPlayer(p);
+      Object connection = nmsPlayer.getClass()
+        .getField("playerConnection").get(nmsPlayer);
+      connection.getClass()
+        .getMethod("sendPacket", new Class[] { getNMSClass("Packet") })
+        .invoke(connection, new Object[] { packet });
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+  }
+
+  public static Field getField(Class<?> clazz, String field) {
+    Field re = null;
+    try {
+      re = clazz.getDeclaredField(field);
+    } catch (NoSuchFieldException e) {
+      e.printStackTrace();
+    } catch (SecurityException e) {
+      e.printStackTrace();
+    }
+    return re;
+  }
+
+  public static void sendPacket(Player p, String packetName, Class<?>[] parameterclass, Object[] parameters) {
+    try {
+      Object nmsPlayer = getNMSPlayer(p);
+      Object connection = nmsPlayer.getClass()
+        .getField("playerConnection").get(nmsPlayer);
+      Object packet = 
+        Class.forName(
+        nmsPlayer.getClass().getPackage().getName() + "." + 
+        packetName)
+        .getConstructor(parameterclass).newInstance(parameters);
+      connection.getClass()
+        .getMethod("sendPacket", new Class[] { getNMSClass("Packet") })
+        .invoke(connection, new Object[] { packet });
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+  }
+
+  public static String getVersion() {
+    String name = Bukkit.getServer().getClass().getPackage().getName();
+    String version = name.substring(name.lastIndexOf('.') + 1) + ".";
+    return version;
+  }
+
+  public static Class<?> getNMSClass(String className) {
+    String fullName = "net.minecraft.server." + getVersion() + className;
+    Class<?> clazz = null;
+    try {
+      clazz = Class.forName(fullName);
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+    return clazz;
+  }
+  public static Class<?> getCraftBukkitClass(String className) {
+    String fullName = "org.bukkit.craftbukkit." + getVersion() + className;
+    Class<?> clazz = null;
+    try {
+      clazz = Class.forName(fullName);
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+    return clazz;
+  }
+
+  public static Object asNMSCopy(ItemStack i) throws IllegalAccessException, InvocationTargetException {
+    Object re = null;
+    try
+    {
+      METHOD_ASNMSCOPY.invoke(null, new Object[] { i });
+    }
+    catch (java.lang.IllegalArgumentException e) {
+      e.printStackTrace();
+    }
+
+    return re;
+  }
+
+  public static Field getField(Field f) {
+    f.setAccessible(true);
+    return f;
+  }
+  public static Constructor<?> getConstructor(Class<?> clazz, Class<?>[] param) {
+    Constructor<?> re = null;
+    try {
+      re = clazz.getConstructor(param);
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+    return re;
+  }
+  public static Object getHandle(Entity entity) {
+    Object object = null;
+    try
+    {
+      object = getMethod(entity.getClass(), "getHandle").invoke(entity, new Object[0]);
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+
+    return object;
+  }
+
+  public static Object getNMSPlayer(Player player) {
+    return getHandle(player);
+  }
+
+  public static Method getMethod(Class<?> c, String methodName) {
+    Method returnMethod = null;
+
+    for (Method m : c.getDeclaredMethods()) {
+      if (m.getName().equals(methodName)) {
+        returnMethod = m;
+      }
+    }
+
+    return returnMethod;
+  }
+}

src/main/java/eu/univento/core/api/utils/reflection/ReflectionUtils.java

@@ -0,0 +1,606 @@
+package eu.univento.core.api.utils.reflection;
+
+import org.bukkit.Bukkit;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * <b>ReflectionUtils</b>
+ * <p>
+ * This class provides useful methods which makes dealing with reflection much easier, especially when working with Bukkit
+ * <p>
+ * You are welcome to use it, modify it and redistribute it under the following conditions:
+ * <ul>
+ * <li>Don't claim this class as your own
+ * <li>Don't remove this disclaimer
+ * </ul>
+ * <p>
+ * <i>It would be nice if you provide credit to me if you use this class in a published project</i>
+ * 
+ * @author DarkBlade12
+ * @version 1.1
+ */
+public final class ReflectionUtils {
+	// Prevent accidental construction
+	private ReflectionUtils() {}
+
+	/**
+	 * Returns the constructor of a given class with the given parameter types
+	 * 
+	 * @param clazz Target class
+	 * @param parameterTypes Parameter types of the desired constructor
+	 * @return The constructor of the target class with the specified parameter types
+	 * @throws NoSuchMethodException If the desired constructor with the specified parameter types cannot be found
+	 * @see DataType
+	 * @see DataType#getPrimitive(Class[])
+	 * @see DataType#compare(Class[], Class[])
+	 */
+	public static Constructor<?> getConstructor(Class<?> clazz, Class<?>... parameterTypes) throws NoSuchMethodException {
+		Class<?>[] primitiveTypes = DataType.getPrimitive(parameterTypes);
+		for (Constructor<?> constructor : clazz.getConstructors()) {
+			if (!DataType.compare(DataType.getPrimitive(constructor.getParameterTypes()), primitiveTypes)) {
+				continue;
+			}
+			return constructor;
+		}
+		throw new NoSuchMethodException("There is no such constructor in this class with the specified parameter types");
+	}
+
+	/**
+	 * Returns the constructor of a desired class with the given parameter types
+	 * 
+	 * @param className Name of the desired target class
+	 * @param packageType Package where the desired target class is located
+	 * @param parameterTypes Parameter types of the desired constructor
+	 * @return The constructor of the desired target class with the specified parameter types
+	 * @throws NoSuchMethodException If the desired constructor with the specified parameter types cannot be found
+	 * @throws ClassNotFoundException ClassNotFoundException If the desired target class with the specified name and package cannot be found
+	 * @see #getClass(String, PackageType)
+	 * @see #getConstructor(Class, Class...)
+	 */
+	public static Constructor<?> getConstructor(String className, PackageType packageType, Class<?>... parameterTypes) throws NoSuchMethodException, ClassNotFoundException {
+		return getConstructor(packageType.getClass(className), parameterTypes);
+	}
+
+	/**
+	 * Returns an instance of a class with the given arguments
+	 * 
+	 * @param clazz Target class
+	 * @param arguments Arguments which are used to construct an object of the target class
+	 * @return The instance of the target class with the specified arguments
+	 * @throws InstantiationException If you cannot create an instance of the target class due to certain circumstances
+	 * @throws IllegalAccessException If the desired constructor cannot be accessed due to certain circumstances
+	 * @throws IllegalArgumentException If the types of the arguments do not match the parameter types of the constructor (this should not occur since it searches for a constructor with the types of the arguments)
+	 * @throws InvocationTargetException If the desired constructor cannot be invoked
+	 * @throws NoSuchMethodException If the desired constructor with the specified arguments cannot be found
+	 */
+	public static Object instantiateObject(Class<?> clazz, Object... arguments) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
+		return getConstructor(clazz, DataType.getPrimitive(arguments)).newInstance(arguments);
+	}
+
+	/**
+	 * Returns an instance of a desired class with the given arguments
+	 * 
+	 * @param className Name of the desired target class
+	 * @param packageType Package where the desired target class is located
+	 * @param arguments Arguments which are used to construct an object of the desired target class
+	 * @return The instance of the desired target class with the specified arguments
+	 * @throws InstantiationException If you cannot create an instance of the desired target class due to certain circumstances
+	 * @throws IllegalAccessException If the desired constructor cannot be accessed due to certain circumstances
+	 * @throws IllegalArgumentException If the types of the arguments do not match the parameter types of the constructor (this should not occur since it searches for a constructor with the types of the arguments)
+	 * @throws InvocationTargetException If the desired constructor cannot be invoked
+	 * @throws NoSuchMethodException If the desired constructor with the specified arguments cannot be found
+	 * @throws ClassNotFoundException If the desired target class with the specified name and package cannot be found
+	 * @see #getClass(String, PackageType)
+	 * @see #instantiateObject(Class, Object...)
+	 */
+	public static Object instantiateObject(String className, PackageType packageType, Object... arguments) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, ClassNotFoundException {
+		return instantiateObject(packageType.getClass(className), arguments);
+	}
+
+	/**
+	 * Returns a method of a class with the given parameter types
+	 * 
+	 * @param clazz Target class
+	 * @param methodName Name of the desired method
+	 * @param parameterTypes Parameter types of the desired method
+	 * @return The method of the target class with the specified name and parameter types
+	 * @throws NoSuchMethodException If the desired method of the target class with the specified name and parameter types cannot be found
+	 * @see DataType#getPrimitive(Class[])
+	 * @see DataType#compare(Class[], Class[])
+	 */
+	public static Method getMethod(Class<?> clazz, String methodName, Class<?>... parameterTypes) throws NoSuchMethodException {
+		Class<?>[] primitiveTypes = DataType.getPrimitive(parameterTypes);
+		for (Method method : clazz.getMethods()) {
+			if (!method.getName().equals(methodName) || !DataType.compare(DataType.getPrimitive(method.getParameterTypes()), primitiveTypes)) {
+				continue;
+			}
+			return method;
+		}
+		throw new NoSuchMethodException("There is no such method in this class with the specified name and parameter types");
+	}
+
+	/**
+	 * Returns a method of a desired class with the given parameter types
+	 * 
+	 * @param className Name of the desired target class
+	 * @param packageType Package where the desired target class is located
+	 * @param methodName Name of the desired method
+	 * @param parameterTypes Parameter types of the desired method
+	 * @return The method of the desired target class with the specified name and parameter types
+	 * @throws NoSuchMethodException If the desired method of the desired target class with the specified name and parameter types cannot be found
+	 * @throws ClassNotFoundException If the desired target class with the specified name and package cannot be found
+	 * @see #getClass(String, PackageType)
+	 * @see #getMethod(Class, String, Class...)
+	 */
+	public static Method getMethod(String className, PackageType packageType, String methodName, Class<?>... parameterTypes) throws NoSuchMethodException, ClassNotFoundException {
+		return getMethod(packageType.getClass(className), methodName, parameterTypes);
+	}
+
+	/**
+	 * Invokes a method on an object with the given arguments
+	 * 
+	 * @param instance Target object
+	 * @param methodName Name of the desired method
+	 * @param arguments Arguments which are used to invoke the desired method
+	 * @return The result of invoking the desired method on the target object
+	 * @throws IllegalAccessException If the desired method cannot be accessed due to certain circumstances
+	 * @throws IllegalArgumentException If the types of the arguments do not match the parameter types of the method (this should not occur since it searches for a method with the types of the arguments)
+	 * @throws InvocationTargetException If the desired method cannot be invoked on the target object
+	 * @throws NoSuchMethodException If the desired method of the class of the target object with the specified name and arguments cannot be found
+	 * @see #getMethod(Class, String, Class...)
+	 * @see DataType#getPrimitive(Object[])
+	 */
+	public static Object invokeMethod(Object instance, String methodName, Object... arguments) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
+		return getMethod(instance.getClass(), methodName, DataType.getPrimitive(arguments)).invoke(instance, arguments);
+	}
+
+	/**
+	 * Invokes a method of the target class on an object with the given arguments
+	 * 
+	 * @param instance Target object
+	 * @param clazz Target class
+	 * @param methodName Name of the desired method
+	 * @param arguments Arguments which are used to invoke the desired method
+	 * @return The result of invoking the desired method on the target object
+	 * @throws IllegalAccessException If the desired method cannot be accessed due to certain circumstances
+	 * @throws IllegalArgumentException If the types of the arguments do not match the parameter types of the method (this should not occur since it searches for a method with the types of the arguments)
+	 * @throws InvocationTargetException If the desired method cannot be invoked on the target object
+	 * @throws NoSuchMethodException If the desired method of the target class with the specified name and arguments cannot be found
+	 * @see #getMethod(Class, String, Class...)
+	 * @see DataType#getPrimitive(Object[])
+	 */
+	public static Object invokeMethod(Object instance, Class<?> clazz, String methodName, Object... arguments) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
+		return getMethod(clazz, methodName, DataType.getPrimitive(arguments)).invoke(instance, arguments);
+	}
+
+	/**
+	 * Invokes a method of a desired class on an object with the given arguments
+	 * 
+	 * @param instance Target object
+	 * @param className Name of the desired target class
+	 * @param packageType Package where the desired target class is located
+	 * @param methodName Name of the desired method
+	 * @param arguments Arguments which are used to invoke the desired method
+	 * @return The result of invoking the desired method on the target object
+	 * @throws IllegalAccessException If the desired method cannot be accessed due to certain circumstances
+	 * @throws IllegalArgumentException If the types of the arguments do not match the parameter types of the method (this should not occur since it searches for a method with the types of the arguments)
+	 * @throws InvocationTargetException If the desired method cannot be invoked on the target object
+	 * @throws NoSuchMethodException If the desired method of the desired target class with the specified name and arguments cannot be found
+	 * @throws ClassNotFoundException If the desired target class with the specified name and package cannot be found
+	 * @see #getClass(String, PackageType)
+	 * @see #invokeMethod(Object, Class, String, Object...)
+	 */
+	public static Object invokeMethod(Object instance, String className, PackageType packageType, String methodName, Object... arguments) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, ClassNotFoundException {
+		return invokeMethod(instance, packageType.getClass(className), methodName, arguments);
+	}
+
+	/**
+	 * Returns a field of the target class with the given name
+	 * 
+	 * @param clazz Target class
+	 * @param declared Whether the desired field is declared or not
+	 * @param fieldName Name of the desired field
+	 * @return The field of the target class with the specified name
+	 * @throws NoSuchFieldException If the desired field of the given class cannot be found
+	 * @throws SecurityException If the desired field cannot be made accessible
+	 */
+	public static Field getField(Class<?> clazz, boolean declared, String fieldName) throws NoSuchFieldException, SecurityException {
+		Field field = declared ? clazz.getDeclaredField(fieldName) : clazz.getField(fieldName);
+		field.setAccessible(true);
+		return field;
+	}
+
+	/**
+	 * Returns a field of a desired class with the given name
+	 * 
+	 * @param className Name of the desired target class
+	 * @param packageType Package where the desired target class is located
+	 * @param declared Whether the desired field is declared or not
+	 * @param fieldName Name of the desired field
+	 * @return The field of the desired target class with the specified name
+	 * @throws NoSuchFieldException If the desired field of the desired class cannot be found
+	 * @throws SecurityException If the desired field cannot be made accessible
+	 * @throws ClassNotFoundException If the desired target class with the specified name and package cannot be found
+	 * @see #getField(Class, boolean, String)
+	 */
+	public static Field getField(String className, PackageType packageType, boolean declared, String fieldName) throws NoSuchFieldException, SecurityException, ClassNotFoundException {
+		return getField(packageType.getClass(className), declared, fieldName);
+	}
+
+	/**
+	 * Returns the value of a field of the given class of an object
+	 * 
+	 * @param instance Target object
+	 * @param clazz Target class
+	 * @param declared Whether the desired field is declared or not
+	 * @param fieldName Name of the desired field
+	 * @return The value of field of the target object
+	 * @throws IllegalArgumentException If the target object does not feature the desired field
+	 * @throws IllegalAccessException If the desired field cannot be accessed
+	 * @throws NoSuchFieldException If the desired field of the target class cannot be found
+	 * @throws SecurityException If the desired field cannot be made accessible
+	 * @see #getField(Class, boolean, String)
+	 */
+	public static Object getValue(Object instance, Class<?> clazz, boolean declared, String fieldName) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException {
+		return getField(clazz, declared, fieldName).get(instance);
+	}
+
+	/**
+	 * Returns the value of a field of a desired class of an object
+	 * 
+	 * @param instance Target object
+	 * @param className Name of the desired target class
+	 * @param packageType Package where the desired target class is located
+	 * @param declared Whether the desired field is declared or not
+	 * @param fieldName Name of the desired field
+	 * @return The value of field of the target object
+	 * @throws IllegalArgumentException If the target object does not feature the desired field
+	 * @throws IllegalAccessException If the desired field cannot be accessed
+	 * @throws NoSuchFieldException If the desired field of the desired class cannot be found
+	 * @throws SecurityException If the desired field cannot be made accessible
+	 * @throws ClassNotFoundException If the desired target class with the specified name and package cannot be found
+	 * @see #getValue(Object, Class, boolean, String)
+	 */
+	public static Object getValue(Object instance, String className, PackageType packageType, boolean declared, String fieldName) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException, ClassNotFoundException {
+		return getValue(instance, packageType.getClass(className), declared, fieldName);
+	}
+
+	/**
+	 * Returns the value of a field with the given name of an object
+	 * 
+	 * @param instance Target object
+	 * @param declared Whether the desired field is declared or not
+	 * @param fieldName Name of the desired field
+	 * @return The value of field of the target object
+	 * @throws IllegalArgumentException If the target object does not feature the desired field (should not occur since it searches for a field with the given name in the class of the object)
+	 * @throws IllegalAccessException If the desired field cannot be accessed
+	 * @throws NoSuchFieldException If the desired field of the target object cannot be found
+	 * @throws SecurityException If the desired field cannot be made accessible
+	 * @see #getValue(Object, Class, boolean, String)
+	 */
+	public static Object getValue(Object instance, boolean declared, String fieldName) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException {
+		return getValue(instance, instance.getClass(), declared, fieldName);
+	}
+
+	/**
+	 * Sets the value of a field of the given class of an object
+	 * 
+	 * @param instance Target object
+	 * @param clazz Target class
+	 * @param declared Whether the desired field is declared or not
+	 * @param fieldName Name of the desired field
+	 * @param value New value
+	 * @throws IllegalArgumentException If the type of the value does not match the type of the desired field
+	 * @throws IllegalAccessException If the desired field cannot be accessed
+	 * @throws NoSuchFieldException If the desired field of the target class cannot be found
+	 * @throws SecurityException If the desired field cannot be made accessible
+	 * @see #getField(Class, boolean, String)
+	 */
+	public static void setValue(Object instance, Class<?> clazz, boolean declared, String fieldName, Object value) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException {
+		getField(clazz, declared, fieldName).set(instance, value);
+	}
+
+	/**
+	 * Sets the value of a field of a desired class of an object
+	 * 
+	 * @param instance Target object
+	 * @param className Name of the desired target class
+	 * @param packageType Package where the desired target class is located
+	 * @param declared Whether the desired field is declared or not
+	 * @param fieldName Name of the desired field
+	 * @param value New value
+	 * @throws IllegalArgumentException If the type of the value does not match the type of the desired field
+	 * @throws IllegalAccessException If the desired field cannot be accessed
+	 * @throws NoSuchFieldException If the desired field of the desired class cannot be found
+	 * @throws SecurityException If the desired field cannot be made accessible
+	 * @throws ClassNotFoundException If the desired target class with the specified name and package cannot be found
+	 * @see #setValue(Object, Class, boolean, String, Object)
+	 */
+	public static void setValue(Object instance, String className, PackageType packageType, boolean declared, String fieldName, Object value) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException, ClassNotFoundException {
+		setValue(instance, packageType.getClass(className), declared, fieldName, value);
+	}
+
+	/**
+	 * Sets the value of a field with the given name of an object
+	 * 
+	 * @param instance Target object
+	 * @param declared Whether the desired field is declared or not
+	 * @param fieldName Name of the desired field
+	 * @param value New value
+	 * @throws IllegalArgumentException If the type of the value does not match the type of the desired field
+	 * @throws IllegalAccessException If the desired field cannot be accessed
+	 * @throws NoSuchFieldException If the desired field of the target object cannot be found
+	 * @throws SecurityException If the desired field cannot be made accessible
+	 * @see #setValue(Object, Class, boolean, String, Object)
+	 */
+	public static void setValue(Object instance, boolean declared, String fieldName, Object value) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException {
+		setValue(instance, instance.getClass(), declared, fieldName, value);
+	}
+
+	/**
+	 * Represents an enumeration of dynamic packages of NMS and CraftBukkit
+	 * <p>
+	 * This class is part of the <b>ReflectionUtils</b> and follows the same usage conditions
+	 * 
+	 * @author DarkBlade12
+	 * @since 1.0
+	 */
+	public enum PackageType {
+		MINECRAFT_SERVER("net.minecraft.server." + getServerVersion()),
+		CRAFTBUKKIT("org.bukkit.craftbukkit." + getServerVersion()),
+		CRAFTBUKKIT_BLOCK(CRAFTBUKKIT, "block"),
+		CRAFTBUKKIT_CHUNKIO(CRAFTBUKKIT, "chunkio"),
+		CRAFTBUKKIT_COMMAND(CRAFTBUKKIT, "command"),
+		CRAFTBUKKIT_CONVERSATIONS(CRAFTBUKKIT, "conversations"),
+		CRAFTBUKKIT_ENCHANTMENS(CRAFTBUKKIT, "enchantments"),
+		CRAFTBUKKIT_ENTITY(CRAFTBUKKIT, "entity"),
+		CRAFTBUKKIT_EVENT(CRAFTBUKKIT, "event"),
+		CRAFTBUKKIT_GENERATOR(CRAFTBUKKIT, "generator"),
+		CRAFTBUKKIT_HELP(CRAFTBUKKIT, "help"),
+		CRAFTBUKKIT_INVENTORY(CRAFTBUKKIT, "inventory"),
+		CRAFTBUKKIT_MAP(CRAFTBUKKIT, "map"),
+		CRAFTBUKKIT_METADATA(CRAFTBUKKIT, "metadata"),
+		CRAFTBUKKIT_POTION(CRAFTBUKKIT, "potion"),
+		CRAFTBUKKIT_PROJECTILES(CRAFTBUKKIT, "projectiles"),
+		CRAFTBUKKIT_SCHEDULER(CRAFTBUKKIT, "scheduler"),
+		CRAFTBUKKIT_SCOREBOARD(CRAFTBUKKIT, "scoreboard"),
+		CRAFTBUKKIT_UPDATER(CRAFTBUKKIT, "updater"),
+		CRAFTBUKKIT_UTIL(CRAFTBUKKIT, "util");
+
+		private final String path;
+
+		/**
+		 * Construct a new package type
+		 * 
+		 * @param path Path of the package
+		 */
+		private PackageType(String path) {
+			this.path = path;
+		}
+
+		/**
+		 * Construct a new package type
+		 * 
+		 * @param parent Parent package of the package
+		 * @param path Path of the package
+		 */
+		private PackageType(PackageType parent, String path) {
+			this(parent + "." + path);
+		}
+
+		/**
+		 * Returns the path of this package type
+		 * 
+		 * @return The path
+		 */
+		public String getPath() {
+			return path;
+		}
+
+		/**
+		 * Returns the class with the given name
+		 * 
+		 * @param className Name of the desired class
+		 * @return The class with the specified name
+		 * @throws ClassNotFoundException If the desired class with the specified name and package cannot be found
+		 */
+		public Class<?> getClass(String className) throws ClassNotFoundException {
+			return Class.forName(this + "." + className);
+		}
+
+		// Override for convenience
+		@Override
+		public String toString() {
+			return path;
+		}
+
+		/**
+		 * Returns the version of your server
+		 * 
+		 * @return The server version
+		 */
+		public static String getServerVersion() {
+			return Bukkit.getServer().getClass().getPackage().getName().substring(23);
+		}
+	}
+
+	/**
+	 * Represents an enumeration of Java data types with corresponding classes
+	 * <p>
+	 * This class is part of the <b>ReflectionUtils</b> and follows the same usage conditions
+	 * 
+	 * @author DarkBlade12
+	 * @since 1.0
+	 */
+	public enum DataType {
+		BYTE(byte.class, Byte.class),
+		SHORT(short.class, Short.class),
+		INTEGER(int.class, Integer.class),
+		LONG(long.class, Long.class),
+		CHARACTER(char.class, Character.class),
+		FLOAT(float.class, Float.class),
+		DOUBLE(double.class, Double.class),
+		BOOLEAN(boolean.class, Boolean.class);
+
+		private static final Map<Class<?>, DataType> CLASS_MAP = new HashMap<Class<?>, DataType>();
+		private final Class<?> primitive;
+		private final Class<?> reference;
+
+		// Initialize map for quick class lookup
+		static {
+			for (DataType type : values()) {
+				CLASS_MAP.put(type.primitive, type);
+				CLASS_MAP.put(type.reference, type);
+			}
+		}
+
+		/**
+		 * Construct a new data type
+		 * 
+		 * @param primitive Primitive class of this data type
+		 * @param reference Reference class of this data type
+		 */
+		private DataType(Class<?> primitive, Class<?> reference) {
+			this.primitive = primitive;
+			this.reference = reference;
+		}
+
+		/**
+		 * Returns the primitive class of this data type
+		 * 
+		 * @return The primitive class
+		 */
+		public Class<?> getPrimitive() {
+			return primitive;
+		}
+
+		/**
+		 * Returns the reference class of this data type
+		 * 
+		 * @return The reference class
+		 */
+		public Class<?> getReference() {
+			return reference;
+		}
+
+		/**
+		 * Returns the data type with the given primitive/reference class
+		 * 
+		 * @param clazz Primitive/Reference class of the data type
+		 * @return The data type
+		 */
+		public static DataType fromClass(Class<?> clazz) {
+			return CLASS_MAP.get(clazz);
+		}
+
+		/**
+		 * Returns the primitive class of the data type with the given reference class
+		 * 
+		 * @param clazz Reference class of the data type
+		 * @return The primitive class
+		 */
+		public static Class<?> getPrimitive(Class<?> clazz) {
+			DataType type = fromClass(clazz);
+			return type == null ? clazz : type.getPrimitive();
+		}
+
+		/**
+		 * Returns the reference class of the data type with the given primitive class
+		 * 
+		 * @param clazz Primitive class of the data type
+		 * @return The reference class
+		 */
+		public static Class<?> getReference(Class<?> clazz) {
+			DataType type = fromClass(clazz);
+			return type == null ? clazz : type.getReference();
+		}
+
+		/**
+		 * Returns the primitive class array of the given class array
+		 * 
+		 * @param classes Given class array
+		 * @return The primitive class array
+		 */
+		public static Class<?>[] getPrimitive(Class<?>[] classes) {
+			int length = classes == null ? 0 : classes.length;
+			Class<?>[] types = new Class<?>[length];
+			for (int index = 0; index < length; index++) {
+				types[index] = getPrimitive(classes[index]);
+			}
+			return types;
+		}
+
+		/**
+		 * Returns the reference class array of the given class array
+		 * 
+		 * @param classes Given class array
+		 * @return The reference class array
+		 */
+		public static Class<?>[] getReference(Class<?>[] classes) {
+			int length = classes == null ? 0 : classes.length;
+			Class<?>[] types = new Class<?>[length];
+			for (int index = 0; index < length; index++) {
+				types[index] = getReference(classes[index]);
+			}
+			return types;
+		}
+
+		/**
+		 * Returns the primitive class array of the given object array
+		 * 
+		 * @param object Given object array
+		 * @return The primitive class array
+		 */
+		public static Class<?>[] getPrimitive(Object[] objects) {
+			int length = objects == null ? 0 : objects.length;
+			Class<?>[] types = new Class<?>[length];
+			for (int index = 0; index < length; index++) {
+				types[index] = getPrimitive(objects[index].getClass());
+			}
+			return types;
+		}
+
+		/**
+		 * Returns the reference class array of the given object array
+		 * 
+		 * @param object Given object array
+		 * @return The reference class array
+		 */
+		public static Class<?>[] getReference(Object[] objects) {
+			int length = objects == null ? 0 : objects.length;
+			Class<?>[] types = new Class<?>[length];
+			for (int index = 0; index < length; index++) {
+				types[index] = getReference(objects[index].getClass());
+			}
+			return types;
+		}
+
+		/**
+		 * Compares two class arrays on equivalence
+		 * 
+		 * @param primary Primary class array
+		 * @param secondary Class array which is compared to the primary array
+		 * @return Whether these arrays are equal or not
+		 */
+		public static boolean compare(Class<?>[] primary, Class<?>[] secondary) {
+			if (primary == null || secondary == null || primary.length != secondary.length) {
+				return false;
+			}
+			for (int index = 0; index < primary.length; index++) {
+				Class<?> primaryClass = primary[index];
+				Class<?> secondaryClass = secondary[index];
+				if (primaryClass.equals(secondaryClass) || primaryClass.isAssignableFrom(secondaryClass)) {
+					continue;
+				}
+				return false;
+			}
+			return true;
+		}
+	}
+}

src/main/java/eu/univento/core/api/youtube/YTAPI.java

@@ -0,0 +1,119 @@
+package eu.univento.core.api.youtube;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.net.URL;
+
+public class YTAPI {
+
+	public static Gson gson = new Gson();
+
+	public static String readJsonFromUrl(String urlString) throws Exception {
+		BufferedReader reader = null;
+		try {
+			URL url = new URL(urlString);
+			reader = new BufferedReader(new InputStreamReader(url.openStream()));
+			StringBuffer buffer = new StringBuffer();
+			int read;
+			char[] chars = new char[1024];
+			while ((read = reader.read(chars)) != -1)
+				buffer.append(chars, 0, read);
+
+			return buffer.toString();
+		} finally {
+			if (reader != null)
+				reader.close();
+		}
+	}
+
+	public static String getGooglePlusId(String uri) throws Exception {
+		String endid = uri.split("/")[uri.split("/").length - 1];
+		String json = YTAPI.readJsonFromUrl("http://gdata.youtube.com/feeds/api/users/" + endid + "?alt=json");
+		JsonObject jo = gson.fromJson(json, JsonObject.class);
+		String gplusid = jo.get("entry").getAsJsonObject().get("yt$googlePlusUserId").getAsJsonObject().get("$t")
+				.getAsString();
+		return gplusid;
+	}
+
+	public static String getChannelFromGPlusId(String plusid, String uri, String developerkey) throws Exception {
+
+		String endid = uri;
+
+		try {
+			String json = YTAPI
+					.readJsonFromUrl("https://www.googleapis.com/plus/v1/people/" + plusid + "?key=" + developerkey);
+			JsonObject jb = gson.fromJson(json, JsonObject.class);
+			JsonObject jo = jb;
+			JsonArray ja = jo.get("urls").getAsJsonArray();
+			for (int i = 0; i < ja.size(); i++) {
+				JsonObject jsob = (JsonObject) ja.get(i);
+				if (jsob.get("value").getAsString().toLowerCase().contains("youtube")) {
+					return jsob.get("value").getAsString();
+				}
+			}
+			return "No Google Plus Data To Find The Channel";
+		} catch (NullPointerException e) {
+			e.printStackTrace();
+			return "No Google Plus Data To Find The Channel";
+		}
+
+	}
+
+	public static YoutubeChannel getYTChannelFromUri(String uri) {
+		try {
+			System.out.println(uri);
+			YoutubeChannel ch;
+			String json = YTAPI.readJsonFromUrl(uri + "?alt=json");
+			JsonObject jb = gson.fromJson(json, JsonObject.class);
+			String username = jb.get("entry").getAsJsonObject().get("yt$username").getAsJsonObject().get("$t")
+					.getAsString();
+			String about_us = jb.get("entry").getAsJsonObject().get("content").getAsJsonObject().get("$t")
+					.getAsString();
+			String title = jb.get("entry").getAsJsonObject().get("title").getAsJsonObject().get("$t").getAsString();
+			String subscribers = jb.get("entry").getAsJsonObject().get("yt$statistics").getAsJsonObject()
+					.get("subscriberCount").getAsString();
+			String gplusid = jb.get("entry").getAsJsonObject().get("yt$googlePlusUserId").getAsJsonObject().get("$t")
+					.getAsString();
+			String firstname = "";
+			String lastname = "";
+			if (jb.get("entry").getAsJsonObject().get("yt$firstName") != null) {
+				firstname = jb.get("entry").getAsJsonObject().get("yt$firstName").getAsJsonObject().get("$t")
+						.getAsString();
+			}
+			if (jb.get("entry").getAsJsonObject().get("yt$lastName") != null) {
+
+				lastname = jb.get("entry").getAsJsonObject().get("yt$lastName").getAsJsonObject().get("$t")
+						.getAsString();
+
+			}
+			String location = jb.get("entry").getAsJsonObject().get("yt$location").getAsJsonObject().get("$t")
+					.getAsString();
+
+			String lastwebaccess = jb.get("entry").getAsJsonObject().get("yt$statistics").getAsJsonObject()
+					.get("lastWebAccess").getAsString();
+			int videowatchcount = jb.get("entry").getAsJsonObject().get("yt$statistics").getAsJsonObject()
+					.get("videoWatchCount").getAsInt();
+			int viewcount = jb.get("entry").getAsJsonObject().get("yt$statistics").getAsJsonObject().get("viewCount")
+					.getAsInt();
+			String totaluploadviews = jb.get("entry").getAsJsonObject().get("yt$statistics").getAsJsonObject()
+					.get("totalUploadViews").getAsString();
+			String avatar = jb.get("entry").getAsJsonObject().get("media$thumbnail").getAsJsonObject().get("url")
+					.getAsString();
+			ch = new YoutubeChannel(about_us, title, username, subscribers, gplusid, firstname, lastname, location,
+					lastwebaccess, videowatchcount, viewcount, totaluploadviews, avatar);
+			return ch;
+		} catch (Exception err) {
+			err.printStackTrace();
+			return null;
+		}
+	}
+
+	public static YoutubeChannel getYTChannelFromName(String channel) {
+		return getYTChannelFromUri("http://gdata.youtube.com/feeds/api/users/" + channel);
+	}
+
+}

src/main/java/eu/univento/core/api/youtube/YoutubeChannel.java

@@ -0,0 +1,242 @@
+package eu.univento.core.api.youtube;
+
+import java.beans.ConstructorProperties;
+
+public class YoutubeChannel {
+	String about_us;
+	String title;
+	String username;
+	String subscribers;
+	String googleplusid;
+	String firstname = "";
+	String lastname = "";
+	String location;
+	String lastwebaccess;
+	int videoWatchCount;
+	int viewcount;
+	String totaluploadViews;
+	String avatar;
+
+	@ConstructorProperties({ "about_us", "title", "username", "subscribers", "googleplusid", "firstname", "lastname",
+			"location", "lastwebaccess", "videoWatchCount", "viewcount", "totaluploadViews", "avatar" })
+	public YoutubeChannel(String about_us, String title, String username, String subscribers, String googleplusid,
+			String firstname, String lastname, String location, String lastwebaccess, int videoWatchCount,
+			int viewcount, String totaluploadViews, String avatar) {
+		this.about_us = about_us;
+		this.title = title;
+		this.username = username;
+		this.subscribers = subscribers;
+		this.googleplusid = googleplusid;
+		this.firstname = firstname;
+		this.lastname = lastname;
+		this.location = location;
+		this.lastwebaccess = lastwebaccess;
+		this.videoWatchCount = videoWatchCount;
+		this.viewcount = viewcount;
+		this.totaluploadViews = totaluploadViews;
+		this.avatar = avatar;
+	}
+
+	public String getAbout_us() {
+		return this.about_us;
+	}
+
+	public String getTitle() {
+		return this.title;
+	}
+
+	public String getUsername() {
+		return this.username;
+	}
+
+	public String getSubscribers() {
+		return this.subscribers;
+	}
+
+	public String getGoogleplusid() {
+		return this.googleplusid;
+	}
+
+	public String getFirstname() {
+		return this.firstname;
+	}
+
+	public String getLastname() {
+		return this.lastname;
+	}
+
+	public String getLocation() {
+		return this.location;
+	}
+
+	public String getLastwebaccess() {
+		return this.lastwebaccess;
+	}
+
+	public int getVideoWatchCount() {
+		return this.videoWatchCount;
+	}
+
+	public int getViewcount() {
+		return this.viewcount;
+	}
+
+	public String getTotaluploadViews() {
+		return this.totaluploadViews;
+	}
+
+	public String getAvatar() {
+		return this.avatar;
+	}
+
+	public void setAbout_us(String about_us) {
+		this.about_us = about_us;
+	}
+
+	public void setTitle(String title) {
+		this.title = title;
+	}
+
+	public void setUsername(String username) {
+		this.username = username;
+	}
+
+	public void setSubscribers(String subscribers) {
+		this.subscribers = subscribers;
+	}
+
+	public void setGoogleplusid(String googleplusid) {
+		this.googleplusid = googleplusid;
+	}
+
+	public void setFirstname(String firstname) {
+		this.firstname = firstname;
+	}
+
+	public void setLastname(String lastname) {
+		this.lastname = lastname;
+	}
+
+	public void setLocation(String location) {
+		this.location = location;
+	}
+
+	public void setLastwebaccess(String lastwebaccess) {
+		this.lastwebaccess = lastwebaccess;
+	}
+
+	public void setVideoWatchCount(int videoWatchCount) {
+		this.videoWatchCount = videoWatchCount;
+	}
+
+	public void setViewcount(int viewcount) {
+		this.viewcount = viewcount;
+	}
+
+	public void setTotaluploadViews(String totaluploadViews) {
+		this.totaluploadViews = totaluploadViews;
+	}
+
+	public void setAvatar(String avatar) {
+		this.avatar = avatar;
+	}
+
+	public boolean equals(Object o) {
+		if (o == this)
+			return true;
+		if (!(o instanceof YoutubeChannel))
+			return false;
+		YoutubeChannel other = (YoutubeChannel) o;
+		if (!other.canEqual(this))
+			return false;
+		Object this$about_us = getAbout_us();
+		Object other$about_us = other.getAbout_us();
+		if (this$about_us == null ? other$about_us != null : !this$about_us.equals(other$about_us))
+			return false;
+		Object this$title = getTitle();
+		Object other$title = other.getTitle();
+		if (this$title == null ? other$title != null : !this$title.equals(other$title))
+			return false;
+		Object this$username = getUsername();
+		Object other$username = other.getUsername();
+		if (this$username == null ? other$username != null : !this$username.equals(other$username))
+			return false;
+		Object this$subscribers = getSubscribers();
+		Object other$subscribers = other.getSubscribers();
+		if (this$subscribers == null ? other$subscribers != null : !this$subscribers.equals(other$subscribers))
+			return false;
+		Object this$googleplusid = getGoogleplusid();
+		Object other$googleplusid = other.getGoogleplusid();
+		if (this$googleplusid == null ? other$googleplusid != null : !this$googleplusid.equals(other$googleplusid))
+			return false;
+		Object this$firstname = getFirstname();
+		Object other$firstname = other.getFirstname();
+		if (this$firstname == null ? other$firstname != null : !this$firstname.equals(other$firstname))
+			return false;
+		Object this$lastname = getLastname();
+		Object other$lastname = other.getLastname();
+		if (this$lastname == null ? other$lastname != null : !this$lastname.equals(other$lastname))
+			return false;
+		Object this$location = getLocation();
+		Object other$location = other.getLocation();
+		if (this$location == null ? other$location != null : !this$location.equals(other$location))
+			return false;
+		Object this$lastwebaccess = getLastwebaccess();
+		Object other$lastwebaccess = other.getLastwebaccess();
+		if (this$lastwebaccess == null ? other$lastwebaccess != null : !this$lastwebaccess.equals(other$lastwebaccess))
+			return false;
+		if (getVideoWatchCount() != other.getVideoWatchCount())
+			return false;
+		if (getViewcount() != other.getViewcount())
+			return false;
+		Object this$totaluploadViews = getTotaluploadViews();
+		Object other$totaluploadViews = other.getTotaluploadViews();
+		if (this$totaluploadViews == null ? other$totaluploadViews != null
+				: !this$totaluploadViews.equals(other$totaluploadViews))
+			return false;
+		Object this$avatar = getAvatar();
+		Object other$avatar = other.getAvatar();
+		return this$avatar == null ? other$avatar == null : this$avatar.equals(other$avatar);
+	}
+
+	public boolean canEqual(Object other) {
+		return other instanceof YoutubeChannel;
+	}
+
+	public int hashCode() {
+		int PRIME = 31;
+		int result = 1;
+		Object $about_us = getAbout_us();
+		result = result * 31 + ($about_us == null ? 0 : $about_us.hashCode());
+		Object $title = getTitle();
+		result = result * 31 + ($title == null ? 0 : $title.hashCode());
+		Object $username = getUsername();
+		result = result * 31 + ($username == null ? 0 : $username.hashCode());
+		Object $subscribers = getSubscribers();
+		result = result * 31 + ($subscribers == null ? 0 : $subscribers.hashCode());
+		Object $googleplusid = getGoogleplusid();
+		result = result * 31 + ($googleplusid == null ? 0 : $googleplusid.hashCode());
+		Object $firstname = getFirstname();
+		result = result * 31 + ($firstname == null ? 0 : $firstname.hashCode());
+		Object $lastname = getLastname();
+		result = result * 31 + ($lastname == null ? 0 : $lastname.hashCode());
+		Object $location = getLocation();
+		result = result * 31 + ($location == null ? 0 : $location.hashCode());
+		Object $lastwebaccess = getLastwebaccess();
+		result = result * 31 + ($lastwebaccess == null ? 0 : $lastwebaccess.hashCode());
+		result = result * 31 + getVideoWatchCount();
+		result = result * 31 + getViewcount();
+		Object $totaluploadViews = getTotaluploadViews();
+		result = result * 31 + ($totaluploadViews == null ? 0 : $totaluploadViews.hashCode());
+		Object $avatar = getAvatar();
+		return result * 31 + ($avatar == null ? 0 : $avatar.hashCode());
+	}
+
+	public String toString() {
+		return "YoutubeChannel(about_us=" + getAbout_us() + ", title=" + getTitle() + ", username=" + getUsername()
+				+ ", subscribers=" + getSubscribers() + ", googleplusid=" + getGoogleplusid() + ", firstname="
+				+ getFirstname() + ", lastname=" + getLastname() + ", location=" + getLocation() + ", lastwebaccess="
+				+ getLastwebaccess() + ", videoWatchCount=" + getVideoWatchCount() + ", viewcount=" + getViewcount()
+				+ ", totaluploadViews=" + getTotaluploadViews() + ", avatar=" + getAvatar() + ")";
+	}
+}

src/main/java/eu/univento/core/commands/Ban.java

@@ -0,0 +1,116 @@
+package eu.univento.core.commands;
+
+import eu.univento.core.Core;
+import eu.univento.core.api.AutoCommand;
+import eu.univento.core.api.languages.Messages;
+import eu.univento.core.api.player.CustomPlayer;
+import eu.univento.core.api.player.Perms.Ranks;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+/**
+ * command to ban players
+ * @author joethei
+ * @version 1.0
+ */
+public class Ban extends AutoCommand<Core>{
+
+	/**
+	 * @param plugin main class
+	 * @param command command to execute
+	 * @param description describes the command
+	 * @param aliases aliases of command
+	 */
+	public Ban(Core plugin, String command, String description, String... aliases) {
+		super(plugin, command, description, aliases);
+	}
+
+	@Override
+	public boolean execute(CommandSender sender, String label, String[] args) {
+		if(sender instanceof Player) {
+			CustomPlayer p = CustomPlayer.getPlayer(sender.getName());
+			Messages msgs = new Messages(p);
+			if(p.isAllowed(Ranks.Moderator)) {
+				if(args.length == 2) {
+					if(Bukkit.getPlayer(args[0]) != null) {
+						CustomPlayer t = CustomPlayer.getPlayer(args[0]);
+						if(getReasons().containsValue(args[1])) {
+                            int id = getKey(args[1]);
+							t.ban(getReasons().get(id), p, getBanDurations().get(id));
+						}else {
+							p.sendMessage(msgs.PREFIX() + msgs.Core_BAN_NO_REASON());
+						}
+					}else {
+						p.sendMessage(msgs.PREFIX() + msgs.NOT_ONLINE(args[0]));
+					}
+				}else {
+					p.sendMessage(msgs.PREFIX() + msgs.Core_BAN_USAGE());
+				}
+			}else {
+				sender.sendMessage(msgs.NO_PERMS());
+			}
+		}else {
+			sender.sendMessage(Messages.Console.NOT_A_PLAYER);
+		}
+		return true;
+	}
+
+	@Override
+	public List<String> tabComplete(CommandSender sender, String label, String[] args) {
+		List<String> list = new ArrayList<>();
+		for(int i = 0; i >= getReasons().size(); i++) {
+			list.add(getReasons().get(i));
+		}
+		return list;
+	}
+	
+	/**
+	 * @return all possible ban reasons
+	 */
+	private HashMap<Integer, String> getReasons() {
+		HashMap<Integer, String> map = new HashMap<>();
+		
+		map.put(1, "Hacking");
+		map.put(2, "Griefing");
+		map.put(3, "Bugusing");
+		map.put(4, "Insult");
+		map.put(5, "Spam");
+		map.put(6, "Banumgehung");
+		map.put(7, "Advertising");
+		map.put(8, "Trolling");
+		
+		return map;
+	}
+
+	/**
+	 * @return ban durations to reason
+	 */
+	private HashMap<Integer, Integer> getBanDurations() {
+		HashMap<Integer, Integer> map = new HashMap<>();
+		
+		map.put(1, 60);
+		map.put(2, 30);
+		map.put(3, 20);
+		map.put(4, 10);
+		map.put(5, 5);
+		map.put(6, 120);
+		map.put(7, 15);
+		map.put(8, 25);
+		
+		return map;
+	}
+
+    private Integer getKey(String value) {
+        for(int key : getReasons().keySet()) {
+            if(getReasons().get(key).equals(value)) {
+                return key;
+            }
+        }
+        return null;
+    }
+}

src/main/java/eu/univento/core/commands/Build.java

@@ -0,0 +1,82 @@
+package eu.univento.core.commands;
+
+import eu.univento.core.Core;
+import eu.univento.core.api.AutoCommand;
+import eu.univento.core.api.languages.Messages;
+import eu.univento.core.api.player.CustomPlayer;
+import eu.univento.core.api.player.Perms.Ranks;
+import eu.univento.core.api.server.ServerSettings;
+import org.bukkit.GameMode;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.HashMap;
+import java.util.List;
+
+/**
+ * lets player build
+ * @author joethei
+ * @version 1.0
+ */
+public class Build extends AutoCommand<Core>{
+	
+	/**
+	 * player who can build
+	 */
+	private static HashMap<CustomPlayer, ItemStack[]> players = new HashMap<>();
+	
+	/**
+	 * @return player that can build
+	 */
+	public static HashMap<CustomPlayer, ItemStack[]> getPlayers() {
+		return players;
+	}
+
+	/**
+	 * @param plugin main class
+	 * @param command command to execute
+	 * @param description describes the command
+	 * @param aliases aliases of command
+	 */
+	public Build(Core plugin, String command, String description, String... aliases) {
+		super(plugin, command, description, aliases);
+	}
+
+	@Override
+	public boolean execute(CommandSender sender, String label, String[] args) {
+		if(sender instanceof Player) {
+			CustomPlayer p = CustomPlayer.getPlayer(sender.getName());
+			Messages msgs = new Messages(p);
+			if(p.isAllowed(Ranks.Builder)) {
+				if(players.containsKey(p)) {
+					p.sendMessage(msgs.PREFIX() + msgs.Core_BUILD_OFF());
+					
+					ItemStack[] content = players.get(p);
+					p.getInventory().setContents(content);
+					players.remove(p);
+					p.setGameMode(ServerSettings.getGameMode());
+					
+					}else {
+					players.put(p, p.getInventory().getContents());
+					p.sendMessage(msgs.PREFIX() + msgs.Core_BUILD_ON());
+					p.getInventory().clear();
+					p.setGameMode(GameMode.CREATIVE);
+				}
+			}else {
+				sender.sendMessage(msgs.NO_PERMS());
+			}
+		}else {
+			sender.sendMessage(Messages.Console.NOT_A_PLAYER);
+		}
+		return false;
+	}
+
+	@Override
+	public List<String> tabComplete(CommandSender sender, String label, String[] args) {
+		return null;
+	}
+	
+	
+
+}

src/main/java/eu/univento/core/commands/ChatClear.java

@@ -0,0 +1,53 @@
+package eu.univento.core.commands;
+
+import eu.univento.core.Core;
+import eu.univento.core.api.AutoCommand;
+import eu.univento.core.api.languages.Messages;
+import eu.univento.core.api.player.CustomPlayer;
+import eu.univento.core.api.player.Perms.Ranks;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.List;
+
+/**
+ * @author joethei
+ * @version 1.0
+ */
+public class ChatClear extends AutoCommand<Core> {
+
+    public ChatClear(Core plugin, String command, String description, String... aliases) {
+        super(plugin, command, description, aliases);
+    }
+
+    @Override
+    public boolean execute(CommandSender sender, String label, String[] args) {
+        if(sender instanceof Player) {
+            CustomPlayer p = CustomPlayer.getPlayer(sender.getName());
+            Messages msgs = new Messages(p);
+            if(p.isAllowed(Ranks.Supporter)) {
+                for(int i = 0; i <= 100; i++) {
+                    Bukkit.broadcastMessage(" ");
+                }
+                for(Player players : Bukkit.getOnlinePlayers()) {
+                    CustomPlayer player = CustomPlayer.getPlayer(players);
+                    if (player.isAllowed(Ranks.Supporter)) {
+                        Messages messages = new Messages(player);
+                        player.sendMessage(messages.Core_CHAT_CLEARED(p));
+                    }
+                }
+            }else {
+                p.sendMessage(msgs.NO_PERMS());
+            }
+        }else {
+            sender.sendMessage(Messages.Console.NOT_A_PLAYER);
+        }
+        return true;
+    }
+
+    @Override
+    public List<String> tabComplete(CommandSender sender, String label, String[] args) {
+        return null;
+    }
+}

src/main/java/eu/univento/core/commands/Fix.java

@@ -0,0 +1,71 @@
+package eu.univento.core.commands;
+
+import eu.univento.core.Core;
+import eu.univento.core.api.AutoCommand;
+import eu.univento.core.api.languages.Messages;
+import eu.univento.core.api.player.CustomPlayer;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * fixes players
+ * @author joethei
+ * @version 1.0
+ */
+public class Fix extends AutoCommand<Core>{
+	
+	/**
+	 * @param plugin main class
+	 * @param command command to execute
+	 * @param description describes the command
+	 * @param aliases aliases of command
+	 */
+	public Fix(Core plugin, String command, String description, String... aliases) {
+		super(plugin, command, description, aliases);
+	}
+	
+	@Override
+	public boolean execute(CommandSender sender, String label, String[] args) {
+		if(sender instanceof Player) {
+			CustomPlayer p = CustomPlayer.getPlayer(sender.getName());
+			Messages msgs = new Messages(p);
+			if(args.length == 0) {
+				for(Player player : Bukkit.getOnlinePlayers()) {
+					player.hidePlayer(p);
+					player.showPlayer(p);
+				}
+				p.teleport(p.getLocation());
+				p.sendMessage(msgs.PREFIX() + msgs.Core_FIX_OWN());
+			}
+			if(args.length == 1) {
+				if(Bukkit.getPlayer(args[0]) != null) {
+					CustomPlayer t = CustomPlayer.getPlayer(Bukkit.getPlayer(args[0]).getName());
+					Messages tMsgs = new Messages(t);
+						if(t != p) {
+							p.hidePlayer(t);
+							p.showPlayer(t);
+							p.teleport(p.getLocation());
+					        p.sendMessage(msgs.Core_FIX_OTHER(t));
+					        t.sendMessage(tMsgs.Core_FIX_BY_OTHER(p));
+						}else {
+							p.chat("/fix");
+						}
+				}else {
+					p.sendMessage(msgs.NOT_ONLINE(args[0]));
+				}
+			}
+		}else {
+			sender.sendMessage(Messages.Console.NOT_A_PLAYER);
+		}
+		return true;
+	}
+	
+	@Override
+	public List<String> tabComplete(CommandSender sender, String label, String[] args) {
+		return Bukkit.getOnlinePlayers().stream().map(Player::getDisplayName).collect(Collectors.toList());
+	}
+}

src/main/java/eu/univento/core/commands/GameMode.java

@@ -0,0 +1,87 @@
+package eu.univento.core.commands;
+
+import eu.univento.core.Core;
+import eu.univento.core.api.AutoCommand;
+import eu.univento.core.api.languages.Messages;
+import eu.univento.core.api.player.CustomPlayer;
+import eu.univento.core.api.player.Perms.Ranks;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * changes game modes
+ * @author joethei
+ * @version 1.0
+ */
+public class GameMode extends AutoCommand<Core>{
+
+	/**
+	 * @param plugin main class
+	 * @param command command to execute
+	 * @param description describes the command
+	 * @param aliases aliases of command
+	 */
+	public GameMode(Core plugin, String command, String description, String... aliases) {
+		super(plugin, command, description, aliases);
+	}
+
+	@Override
+	public boolean execute(CommandSender sender, String label, String[] args) {
+		if(sender instanceof Player) {
+			CustomPlayer p = CustomPlayer.getPlayer(sender.getName());
+			Messages msgs = new Messages(p);
+			if(p.isAllowed(Ranks.Builder)) {
+				if(args.length == 1) {
+					String mode = args[0];
+					p.setGameMode(getModeFromString(mode));
+					p.sendMessage(msgs.Core_GM_CHANGED());
+				}if(args.length == 0){
+					p.sendMessage(msgs.Core_GM_USAGE());
+				}
+			}else {
+				p.sendMessage(msgs.NO_PERMS());
+			}
+		}else {
+			sender.sendMessage(Messages.Console.NOT_A_PLAYER);
+		}
+		return true;
+	}
+
+	@Override
+	public List<String> tabComplete(CommandSender sender, String label, String[] args) {
+		List<String> list = new ArrayList<>();
+		
+		list.add("0");
+		list.add("1");
+		list.add("2");
+		list.add("3");
+		list.add("Survival");
+		list.add("Creative");
+		list.add("Adventure");
+		list.add("Spectator");
+		
+		return list;
+	}
+	
+	/**
+	 * @param string Mode
+	 * @return GameMode
+	 */
+	private org.bukkit.GameMode getModeFromString(String string) {
+		switch(string) {
+		case "0" : return org.bukkit.GameMode.SURVIVAL;
+		case "1" : return org.bukkit.GameMode.CREATIVE;
+		case "2": return org.bukkit.GameMode.ADVENTURE;
+		case "3" : return org.bukkit.GameMode.SPECTATOR;
+		case "Survial" : return org.bukkit.GameMode.SURVIVAL;
+		case "Creative" : return org.bukkit.GameMode.CREATIVE;
+		case "Adventure" : return org.bukkit.GameMode.ADVENTURE;
+		case "Spectator" : return org.bukkit.GameMode.SPECTATOR;
+		default: return org.bukkit.GameMode.SPECTATOR;
+		}
+	}
+
+}

src/main/java/eu/univento/core/commands/GlobalMute.java

@@ -0,0 +1,58 @@
+package eu.univento.core.commands;
+
+import eu.univento.core.Core;
+import eu.univento.core.api.AutoCommand;
+import eu.univento.core.api.languages.Messages;
+import eu.univento.core.api.player.CustomPlayer;
+import eu.univento.core.api.player.Perms.Ranks;
+import eu.univento.core.api.server.ServerSettings;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.List;
+
+/**
+ * mutes the whole server
+ * @author joethei
+ * @version 1.0
+ */
+public class GlobalMute extends AutoCommand<Core>{
+
+	/**
+	 * @param plugin main class
+	 * @param command command to execute
+	 * @param description describes the command
+	 * @param aliases aliases of command
+	 */
+	public GlobalMute(Core plugin, String command, String description, String... aliases) {
+		super(plugin, command, description, aliases);
+	}
+
+	@Override
+	public boolean execute(CommandSender sender, String label, String[] args) {
+		if(sender instanceof Player) {
+			CustomPlayer p = CustomPlayer.getPlayer(sender.getName());
+			Messages msgs = new Messages(p);
+			if(p.isAllowed(Ranks.Moderator)) {
+				if(ServerSettings.isMute()) {
+                    ServerSettings.setMute(false);
+					p.sendMessage(msgs.Core_GLOBALMUTE_OFF());
+				}else {
+                    ServerSettings.setMute(true);
+					p.sendMessage(msgs.Core_GLOBALMUTE_ON());
+				}
+			}else {
+				p.sendMessage(msgs.NO_PERMS());
+			}
+		}else {
+			sender.sendMessage(Messages.Console.NOT_A_PLAYER);
+		}
+		return false;
+	}
+
+	@Override
+	public List<String> tabComplete(CommandSender sender, String label, String[] args) {
+		return null;
+	}
+
+}

src/main/java/eu/univento/core/commands/Nick.java

@@ -0,0 +1,67 @@
+package eu.univento.core.commands;
+
+import eu.univento.core.Core;
+import eu.univento.core.api.AutoCommand;
+import eu.univento.core.api.languages.Messages;
+import eu.univento.core.api.player.CustomPlayer;
+import eu.univento.core.api.player.Perms.Ranks;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.List;
+
+/**
+ * nick command
+ * @author joethei
+ * @version 1.0
+ */
+public class Nick extends AutoCommand<Core>{
+
+	/**
+	 * @param plugin main class
+	 * @param command command to execute
+	 * @param description describes the command
+	 * @param aliases aliases of command
+	 */
+	public Nick(Core plugin, String command, String description, String... aliases) {
+		super(plugin, command, description, aliases);
+	}
+
+	@SuppressWarnings("deprecation")
+	@Override
+	public boolean execute(CommandSender sender, String label, String[] args) {
+		if(sender instanceof Player) {
+			CustomPlayer p = CustomPlayer.getPlayer(sender.getName());
+			Messages msgs = new Messages(p);
+			if(p.isAllowed(Ranks.Youtuber)) {
+				if(p.isNicked()) {
+                    p.getTeam().removeEntry(p.getDisplayName());
+					p.setNicked(false);
+					p.setDisplayName(p.getName());
+					p.getTeam().addEntry(p.getDisplayName());
+					p.sendMessage(msgs.PREFIX() + msgs.Core_NICK_OFF());
+                    p.unnick();
+				}else {
+					p.getTeam().removeEntry(p.getDisplayName());
+					p.setNicked(true);
+					p.setDisplayName(p.getNick());
+					p.getTeam().addEntry(p.getDisplayName());
+					p.sendMessage(msgs.PREFIX() + msgs.Core_NICK_ON());
+                    p.nick(p.getNick());
+				}
+			}else {
+				p.sendMessage(msgs.NO_PERMS());
+			}
+		}else {
+			sender.sendMessage(Messages.Console.NOT_A_PLAYER);
+		}
+		return true;
+	}
+
+	@Override
+	public List<String> tabComplete(CommandSender sender, String label, String[] args) {
+		
+		return null;
+	}
+
+}

src/main/java/eu/univento/core/commands/RunAs.java

@@ -0,0 +1,70 @@
+package eu.univento.core.commands;
+
+import eu.univento.core.Core;
+import eu.univento.core.api.AutoCommand;
+import eu.univento.core.api.languages.Messages;
+import eu.univento.core.api.player.CustomPlayer;
+import eu.univento.core.api.player.Perms.Ranks;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * lets other player run commands
+ * @author joethei
+ * @version 1.0
+ */
+public class RunAs extends AutoCommand<Core>{
+
+	/**
+	 * @param plugin main class
+	 * @param command command to execute
+	 * @param description describes the command
+	 * @param aliases aliases of command
+	 */
+	public RunAs(Core plugin, String command, String description, String... aliases) {
+		super(plugin, command, description, aliases);
+	}
+
+
+	@Override
+	public boolean execute(CommandSender sender, String label, String[] args) {
+		if(sender instanceof Player) {
+			CustomPlayer p = CustomPlayer.getPlayer(sender.getName());
+			Messages msgs = new Messages(p);
+			if(p.isAllowed(Ranks.Admin)) {
+				if(args.length >= 2) {
+					CustomPlayer t = CustomPlayer.getPlayer(Bukkit.getPlayer(args[0]).getName());
+					if(t != null) {
+						String msg = "";
+						for(int i = 1; i < args.length; i++) {
+							msg = msg + args[i] + " ";
+						}
+						t.chat(msg);
+						p.sendMessage(msgs.Core_RUNAS_RUN(t));
+						return true;
+					}else {
+						p.sendMessage(msgs.NOT_ONLINE(args[0]));
+					}
+				}else {
+					p.sendMessage(msgs.Core_RUNAS_USAGE());
+				}
+			}else {
+				p.sendMessage(msgs.NO_PERMS());
+			}
+		}else {
+			sender.sendMessage(Messages.Console.NOT_A_PLAYER);
+		}
+		return false;
+	}
+	
+	@Override
+	public List<String> tabComplete(CommandSender sender, String label, String[] args) {
+		return Bukkit.getOnlinePlayers().stream().map(Player::getDisplayName).collect(Collectors.toList());
+	}
+
+
+}

src/main/java/eu/univento/core/commands/SetRank.java

@@ -0,0 +1,102 @@
+package eu.univento.core.commands;
+
+import eu.univento.core.Core;
+import eu.univento.core.api.AutoCommand;
+import eu.univento.core.api.languages.Messages;
+import eu.univento.core.api.player.CustomPlayer;
+import eu.univento.core.api.player.Perms.Ranks;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * sets ranks for players
+ * @author joethei
+ * @version 1.0
+ */
+public class SetRank extends AutoCommand<Core>{
+
+	/**
+	 * @param plugin main class
+	 * @param command command to execute
+	 * @param description describes the command
+	 * @param aliases aliases of command
+	 */
+	public SetRank(Core plugin, String command, String description, String... aliases) {
+		super(plugin, command, description, aliases);
+	}
+
+	@Override
+	public boolean execute(CommandSender sender, String label, String[] args) {
+		if(sender instanceof Player) {
+			CustomPlayer p = CustomPlayer.getPlayer(sender.getName());
+			if(p.isAllowed(Ranks.HeadBuilder)) {
+				if(args.length == 2) {
+					Ranks rank = Ranks.valueOf(args[1]);
+					if(rank != null) {
+						if(Bukkit.getPlayer(args[0]) != null) {
+                            CustomPlayer player = CustomPlayer.getPlayer(Bukkit.getPlayer(args[0]));
+							if(p.isAllowed(Ranks.HeadBuilder)  && rank.equals(Ranks.Builder)) {
+                                player.setRank(rank);
+                                p.sendMessage(p.getMessages().PREFIX() + p.getMessages().Core_SETRANK_SET(player, player.getRank()));
+                                player.kickPlayer(player.getMessages().Core_SETRANK_KICK());
+                            }if(p.isAllowed(Ranks.SrModerator) && rank.equals(Ranks.Moderator)) {
+                                player.setRank(rank);
+                                p.sendMessage(p.getMessages().PREFIX() + p.getMessages().Core_SETRANK_SET(player, player.getRank()));
+                                player.kickPlayer(player.getMessages().Core_SETRANK_KICK());
+                            }if(p.isAllowed(Ranks.SrModerator) && rank.equals(Ranks.Supporter)) {
+                                player.setRank(rank);
+                                p.sendMessage(p.getMessages().PREFIX() + p.getMessages().Core_SETRANK_SET(player, player.getRank()));
+                                player.kickPlayer(player.getMessages().Core_SETRANK_KICK());
+                            }if(p.isAllowed(Ranks.SrDeveloper) && rank.equals(Ranks.Developer)) {
+                                player.setRank(rank);
+                                p.sendMessage(p.getMessages().PREFIX() + p.getMessages().Core_SETRANK_SET(player, player.getRank()));
+                                player.kickPlayer(player.getMessages().Core_SETRANK_KICK());
+                            }
+                            if(p.isAllowed(Ranks.Admin)) {
+                                player.setRank(rank);
+                                p.sendMessage(p.getMessages().PREFIX() + p.getMessages().Core_SETRANK_SET(player, player.getRank()));
+                                player.kickPlayer(player.getMessages().Core_SETRANK_KICK());
+                            }
+						}else {
+							p.sendMessage(p.getMessages().NOT_ONLINE(args[0]));
+						}	
+					}else {
+						p.sendMessage(p.getMessages().Core_SETRANK_NO_RANK());
+					}
+				}else {
+					p.sendMessage(p.getMessages().Core_SETRANK_NO_RANK());
+				}
+			}else {
+				p.sendMessage(p.getMessages().NO_PERMS());
+			}
+		}else {
+			sender.sendMessage(Messages.Console.NOT_A_PLAYER);
+		}
+		return true;
+	}
+
+	@Override
+	public List<String> tabComplete(CommandSender sender, String label, String[] args) {
+		List<String> list = Bukkit.getOnlinePlayers().stream().map(Player::getDisplayName).collect(Collectors.toList());
+
+		list.add("Admin");
+		list.add("Developer");
+		list.add("SrModerator");
+		list.add("Moderator");
+		list.add("HeadBuilder");
+		list.add("Builder");
+		list.add("Supporter");
+		list.add("Youtuber");
+		list.add("Premium");
+		list.add("Player");
+		
+		return list;
+	}
+	
+	
+
+}

src/main/java/eu/univento/core/commands/SystemInfo.java

@@ -0,0 +1,61 @@
+package eu.univento.core.commands;
+
+import eu.univento.core.Core;
+import eu.univento.core.api.AutoCommand;
+import eu.univento.core.api.languages.Messages;
+import eu.univento.core.api.player.CustomPlayer;
+import eu.univento.core.api.player.Perms.Ranks;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.List;
+
+/**
+ * prints infos about the server
+ * @author joethei
+ * @version 1.0
+ */
+public class SystemInfo extends AutoCommand<Core>{
+
+	/**
+	 * @param plugin main class
+	 * @param command command to execute
+	 * @param description describes the command
+	 * @param aliases aliases of command
+	 */
+	public SystemInfo(Core plugin, String command, String description, String... aliases) {
+		super(plugin, command, description, aliases);
+	}
+	
+	@Override
+	public boolean execute(CommandSender sender, String label, String[] args) {
+		if(sender instanceof Player) {
+			CustomPlayer p = CustomPlayer.getPlayer(sender.getName());
+			Messages msgs = new Messages(p);
+			if(p.isAllowed(Ranks.SrModerator)) {
+				Runtime run = Runtime.getRuntime();
+		        p.sendMessage("§6§l===SystemInfo <SpigotServer>===");
+		        p.sendMessage("§6Spigot version: " + Bukkit.getVersion());
+		        p.sendMessage("§6used memory: " + (run.totalMemory() - run.freeMemory() / 1048576L) + " MB");
+		        p.sendMessage("§6free memory: " + run.freeMemory() / 1048576L + " MB");
+		        p.sendMessage("§6total memory: " + run.maxMemory() / 1048576L + " MB");
+		        p.sendMessage("§6avaiable cores: " + run.availableProcessors());
+		        p.sendMessage("§6OS: " + System.getProperty("os.name"));
+		        p.sendMessage("§6OS version: " + System.getProperty("os.version"));
+		        p.sendMessage("§6OS architecture: " + System.getProperty("os.arch"));
+			}else {
+				p.sendMessage(msgs.NO_PERMS());
+			}
+		}else {
+			sender.sendMessage(Messages.Console.NOT_A_PLAYER);
+		}
+		return false;
+	}
+
+	@Override
+	public List<String> tabComplete(CommandSender sender, String label, String[] args) {
+		return null;
+	}
+
+}

src/main/java/eu/univento/core/commands/TS.java

@@ -0,0 +1,42 @@
+package eu.univento.core.commands;
+
+import eu.univento.core.Core;
+import eu.univento.core.api.AutoCommand;
+import eu.univento.core.api.player.CustomPlayer;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.List;
+
+/**
+ * sets ts groups according to player rank
+ * @author joethei
+ * @version 1.0
+ */
+public class TS extends AutoCommand<Core>{
+	
+	/**
+	 * @param plugin main class
+	 * @param command command to execute
+	 * @param description describes the command
+	 * @param aliases aliases of command
+	 */
+	public TS(Core plugin, String command, String description, String... aliases) {
+		super(plugin, command, description, aliases);
+	}
+
+	@Override
+	public boolean execute(CommandSender sender, String label, String[] args) {
+		if(sender instanceof Player) {
+			CustomPlayer p = CustomPlayer.getPlayer(sender.getName());
+            p.sendMessage("Der TS Befehl ist momentan deaktivert");
+			}
+		return true;
+	}
+
+	@Override
+	public List<String> tabComplete(CommandSender sender, String label, String[] args) {
+		return null;
+	}
+
+}

src/main/java/eu/univento/core/commands/Twitch.java

@@ -0,0 +1,65 @@
+package eu.univento.core.commands;
+
+import eu.univento.core.Core;
+import eu.univento.core.api.AutoCommand;
+import eu.univento.core.api.languages.Messages;
+import eu.univento.core.api.player.CustomPlayer;
+import eu.univento.core.api.twitch.Twitch_API;
+import eu.univento.core.api.twitch.Twitch_Stream;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.List;
+
+/**
+ * send info about twitch streams
+ * @author joethei
+ * @version 1.0
+ */
+public class Twitch extends AutoCommand<Core>{
+
+	/**
+	 * @param plugin main class
+	 * @param command command to execute
+	 * @param description describes the command
+	 * @param aliases aliases of command
+	 */
+	public Twitch(Core plugin, String command, String description, String... aliases) {
+		super(plugin, command, description, aliases);
+	}
+
+	@Override
+	public boolean execute(CommandSender sender, String label, String[] args) {
+		if(sender instanceof Player) {
+			CustomPlayer p = CustomPlayer.getPlayer(sender.getName());
+			Messages msgs = new Messages(p);
+			if(args.length == 1) {
+				Twitch_Stream stream = Twitch_API.getStream(args[0]);
+				if(stream != null) {
+					p.sendMessage("§a" + stream.getBroadcaster());
+					p.sendMessage("§aBenutzername: " + stream.getUsername());
+					p.sendMessage("§aSpiel: " + stream.getMeta_game());
+					p.sendMessage("§aKategorie: " + stream.getCategory());
+					p.sendMessage("§aTitel: " + stream.getTitle());
+					p.sendMessage("§aStatus: " + stream.getStatus());
+					p.sendMessage("§aZuschauer:" + stream.getChannel_view_count());
+					p.sendMessage("§aSprachen: " + stream.getGeo());
+					p.sendMessage("§aOnline seit: " + stream.getUp_time());
+				}else {
+					p.sendMessage(msgs.PREFIX() + "§aDen Benutzer gibt es nicht");
+				}
+			}else {
+				p.sendMessage(msgs.PREFIX() + "§cNutze /twitch <Name>");
+			}
+		}else {
+			sender.sendMessage(Messages.Console.NOT_A_PLAYER);
+		}
+		return true;
+	}
+
+	@Override
+	public List<String> tabComplete(CommandSender sender, String label, String[] args) {
+		return null;
+	}
+
+}

src/main/java/eu/univento/core/commands/Vanish.java

@@ -0,0 +1,77 @@
+package eu.univento.core.commands;
+
+import eu.univento.core.Core;
+import eu.univento.core.api.AutoCommand;
+import eu.univento.core.api.languages.Messages;
+import eu.univento.core.api.player.CustomPlayer;
+import eu.univento.core.api.player.Perms.Ranks;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * vanish players
+ * @author joethei
+ * @version 1.0
+ */
+public class Vanish extends AutoCommand<Core>{
+	
+	/**
+	 * contains vanished players
+	 */
+	private static ArrayList<CustomPlayer> players = new ArrayList<CustomPlayer>();
+	/**
+	 * @return vanished players
+	 */
+	public static ArrayList<CustomPlayer> getPlayers() {
+		return players;
+	}
+
+	/**
+	 * @param plugin main class
+	 * @param command command to execute
+	 * @param description describes the command
+	 * @param aliases aliases of command
+	 */
+	public Vanish(Core plugin, String command, String description, String... aliases) {
+		super(plugin, command, description, aliases);
+	}
+	
+	@Override
+	public boolean execute(CommandSender sender, String label, String[] args) {
+		if(sender instanceof Player) {
+			CustomPlayer p = CustomPlayer.getPlayer(sender.getName());
+			Messages msgs = new Messages(p);
+			if(p.isAllowed(Ranks.Moderator)) {
+				if(players.contains(p)) {
+					for(Player players : Bukkit.getOnlinePlayers()) {
+						players.showPlayer(p);
+					}
+					players.remove(p);
+					p.sendMessage(msgs.PREFIX() + msgs.Core_VANISH_OFF());
+				}else {
+					for(Player players : Bukkit.getOnlinePlayers()) {
+						players.hidePlayer(p);
+					}
+					players.add(p);
+					p.sendMessage(msgs.PREFIX() + msgs.Core_VANISH_ON());
+				}
+			}else {
+				p.sendMessage(msgs.NO_PERMS());
+			}
+		}else {
+			sender.sendMessage(Messages.Console.NOT_A_PLAYER);
+		}
+		return false;
+	}
+	
+	@Override
+	public List<String> tabComplete(CommandSender sender, String label, String[] args) {
+		return null;
+	}
+
+
+}

src/main/java/eu/univento/core/listeners/Blocks.java

@@ -0,0 +1,53 @@
+package eu.univento.core.listeners;
+
+import eu.univento.core.api.player.CustomPlayer;
+import eu.univento.core.commands.Build;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.BlockBreakEvent;
+import org.bukkit.event.block.BlockCanBuildEvent;
+import org.bukkit.event.block.BlockPlaceEvent;
+
+/**
+ * some stuff with blocks
+ * @author joethei
+ * @version 1.0
+ */
+public class Blocks implements Listener{
+	
+	/**
+	 * cancels block placement if player is not in build mode
+	 * @param e BlockPlaceEvent
+	 */
+	@EventHandler
+	public void onBlockPlace(BlockPlaceEvent e) {
+		CustomPlayer p = CustomPlayer.getPlayer(e.getPlayer());
+		if(!Build.getPlayers().containsKey(p)) {
+			e.setCancelled(true);
+		}
+	}
+	
+	/**
+	 * cancels block breaking if player is not in build mode
+	 * @param e BlockBreakEvent
+	 */
+	@EventHandler
+	public void onBlockBreak(BlockBreakEvent e) {
+		CustomPlayer p = CustomPlayer.getPlayer(e.getPlayer());
+		if(!Build.getPlayers().containsKey(p)) {
+			e.setCancelled(true);
+		}
+		
+	}
+	
+	/**
+	 * sets buildable true so players can place blocks, even if vanished player is standing there
+	 * @param e BlockCanBuildEvent
+	 */
+	@EventHandler(priority = EventPriority.LOW)
+    public void onBlockCanBuildEvent(BlockCanBuildEvent e){
+        e.setBuildable(true);
+    }
+
+}

src/main/java/eu/univento/core/listeners/Chat.java

@@ -0,0 +1,47 @@
+package eu.univento.core.listeners;
+
+import eu.univento.core.api.languages.Messages;
+import eu.univento.core.api.player.CustomPlayer;
+import eu.univento.core.api.player.Perms.Ranks;
+import eu.univento.core.api.server.ServerSettings;
+import net.md_5.bungee.api.ChatColor;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.AsyncPlayerChatEvent;
+
+/**
+ * manages chat
+ * @author joethei
+ * @version 1.0
+ */
+public class Chat implements Listener{
+	
+	/**
+	 * @param e AsyncPlayerChatEvent
+	 */
+	@EventHandler
+	public void onChat(AsyncPlayerChatEvent e) {
+		CustomPlayer p = CustomPlayer.getPlayer(e.getPlayer().getName());
+		Messages msgs = new Messages(p);
+		if(ServerSettings.isMute()) {
+			if(!p.isAllowed(Ranks.Supporter)) {
+				e.setCancelled(true);
+				p.sendMessage(msgs.PREFIX() + msgs.Core_SERVER_MUTED());
+			}
+		}
+			String format;
+			if(p.isAllowed(Ranks.Youtuber)) {
+				if(p.isNicked() && !ServerSettings.isLobby()) {
+					format = p.getPrefix() + p.getDisplayName() + p.getSuffix() + ChatColor.translateAlternateColorCodes('&', e.getMessage());
+				}else {
+					format = p.getPrefix() + p.getDisplayName() + p.getSuffix() + ChatColor.translateAlternateColorCodes('&', e.getMessage());
+				}
+			}else {
+				format = p.getPrefix() + p.getDisplayName() + p.getSuffix() + e.getMessage();
+			}
+        if(format.contains("%")) format = format.replace("%", "%%");
+			e.setFormat(format);
+
+	}
+
+}

src/main/java/eu/univento/core/listeners/Commands.java

@@ -0,0 +1,61 @@
+package eu.univento.core.listeners;
+
+import eu.univento.core.Core;
+import eu.univento.core.api.languages.Messages;
+import eu.univento.core.api.player.CustomPlayer;
+import eu.univento.core.api.player.Perms.Ranks;
+import org.bukkit.Bukkit;
+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.PlayerCommandPreprocessEvent;
+import org.bukkit.help.HelpTopic;
+
+/**
+ * commands
+ * @author joethei
+ * @version 1.0
+ */
+public class Commands implements Listener{
+	
+	
+	/**
+	 * prints unknown command message
+	 * @param e PlayerCommandPreprocessEvent
+	 */
+    @EventHandler(priority = EventPriority.NORMAL)
+    public void onPlayerCommandPreprocess(PlayerCommandPreprocessEvent e) {
+		CustomPlayer p = CustomPlayer.getPlayer(e.getPlayer());
+		Messages msgs = new Messages(p);
+        if (!e.isCancelled()) {
+            String cmd = e.getMessage().split(" ")[0];
+            HelpTopic topic = Bukkit.getServer().getHelpMap().getHelpTopic(cmd);
+            if (topic == null) {
+                p.sendMessage(msgs.COMMAND_NOT_FOUND());
+                e.setCancelled(true);
+            }
+        }
+        String cmd = e.getMessage();
+		if(cmd.equalsIgnoreCase("/rl") || cmd.equalsIgnoreCase("/reload")) {
+			if(p.isAllowed(Ranks.Admin)) {
+				e.setCancelled(true);
+				Bukkit.broadcastMessage(msgs.PREFIX() + "§cWarning ! Server will be restarted");
+				Bukkit.getScheduler().scheduleSyncDelayedTask(Core.getInstance(), new Runnable() {
+
+					@Override
+					public void run() {
+						for(Player players : Bukkit.getOnlinePlayers()) {
+							players.kickPlayer("§cServer has been restarted \n §6Please join again at: \n §bplay§5.§6univento§5.§aeu");
+						}
+						Bukkit.getServer().spigot().restart();
+					}
+
+				}, 100L);
+			}else {
+				p.sendMessage(msgs.NO_PERMS());
+			}
+		}
+    }
+
+}

src/main/java/eu/univento/core/listeners/Events.java

@@ -0,0 +1,60 @@
+package eu.univento.core.listeners;
+
+import eu.univento.core.api.player.CustomPlayer;
+import eu.univento.core.api.server.ServerSettings;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.inventory.InventoryCloseEvent;
+import org.bukkit.event.server.ServerListPingEvent;
+import org.bukkit.inventory.Inventory;
+
+/**
+ * some basic events
+ * @author joethei
+ * @version 0.2
+ */
+public class Events implements Listener{
+
+	@EventHandler
+	public void onInventoryClose(InventoryCloseEvent e) {
+		CustomPlayer p = CustomPlayer.getPlayer(e.getPlayer().getName());
+        if(e.getInventory().getName().equals(JoinQuit.getLanguageChooser(p).getName())) {
+            p.openInventory(JoinQuit.getLanguageChooser(p));
+            p.sendMessage("§cPlease choose a language");
+            return;
+        }
+		p.setOpenInventory(false);
+	}
+
+	@EventHandler(priority = EventPriority.HIGHEST)
+    public void onInventoryClick(InventoryClickEvent e) {
+        Inventory inv = e.getClickedInventory();
+        if(e.getWhoClicked() instanceof Player) {
+            CustomPlayer p = CustomPlayer.getPlayer(e.getWhoClicked().getName());
+            if(inv.getName().equals(JoinQuit.getLanguageChooser(p).getName())) {
+                if(e.getCurrentItem().getItemMeta().getDisplayName().equals("§6english")) {
+                    p.setLanguage("EN");
+                    p.closeInventory();
+                }
+                if(e.getCurrentItem().getItemMeta().getDisplayName().equals("§6Deutsch")) {
+                    p.setLanguage("DE");
+                    p.closeInventory();
+                }
+                if(e.getCurrentItem().getItemMeta().getDisplayName().equals("§6Italiano")) {
+                    p.setLanguage("IT");
+                    p.closeInventory();
+                }
+             }
+        }
+    }
+
+    @EventHandler
+    public void onServerListPing(ServerListPingEvent e) {
+        if(ServerSettings.isGame()) e.setMotd(ServerSettings.getPlayedGame().toString() + ";" + ServerSettings.getGameState());
+    }
+
+
+}

src/main/java/eu/univento/core/listeners/JoinQuit.java

@@ -0,0 +1,195 @@
+package eu.univento.core.listeners;
+
+import eu.univento.core.Core;
+import eu.univento.core.api.Title;
+import eu.univento.core.api.Utils;
+import eu.univento.core.api.database.MySQL;
+import eu.univento.core.api.languages.Messages;
+import eu.univento.core.api.player.CustomPlayer;
+import eu.univento.core.api.player.NickName;
+import eu.univento.core.api.player.Perms;
+import eu.univento.core.api.player.Spectator;
+import eu.univento.core.api.server.ServerSettings;
+import eu.univento.core.commands.Build;
+import eu.univento.core.commands.Vanish;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+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.PlayerKickEvent;
+import org.bukkit.event.player.PlayerLoginEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.scoreboard.Team;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Timestamp;
+import java.util.Date;
+
+/**
+ * @author joethei
+ * @version 1.0
+ */
+public class JoinQuit implements Listener{
+	
+	/**
+	 * Handles JoinMessage and vanished players
+	 * @param e event
+	 */
+	@EventHandler
+	public void onJoin(PlayerJoinEvent e) {
+		CustomPlayer p = CustomPlayer.getPlayer(e.getPlayer());
+		Messages msgs = new Messages(p);
+
+        for(Player players : Bukkit.getOnlinePlayers()) {
+            CustomPlayer player = CustomPlayer.getPlayer(players);
+            if(Vanish.getPlayers().contains(player)) {
+                p.hidePlayer(player);
+            }
+            if(Spectator.is(player)) {
+                p.hidePlayer(player);
+            }
+        }
+
+		if(!p.hasPlayedBefore()) {
+			//p.insertToDatabase();
+            Perms.getRanks().put(p, p.getFreshRank());
+			for(int i = 0; i <= 15; i++) {
+				Utils.randomFirework(p.getEyeLocation());
+			}
+            Title.sendTitle(p, 0, 100, 0, "§6Welcome", "§aPlease choose a language");
+            Bukkit.getScheduler().scheduleSyncDelayedTask(Core.getInstance(), () -> p.openInventory(getLanguageChooser(p)), 100L);
+            return;
+		}
+        //p.updateDatabaseEntry();
+        Perms.getRanks().put(p, p.getFreshRank());
+		Title.sendTabTitle(p, msgs.Core_TAB_TITLE() + Bukkit.getServerName() ,  msgs.TAB_PREFIX());
+		p.setGameMode(ServerSettings.getGameMode());
+        p.setScoreboard(Bukkit.getScoreboardManager().getNewScoreboard());
+        Perms.initScoreboard(p);
+
+        if(p.isNicked()) {
+            p.nick(p.getNick());
+        }
+
+        for(Player players : Bukkit.getOnlinePlayers()){
+            CustomPlayer player = CustomPlayer.getPlayer(players);
+            p.getScoreboard().getTeam(player.getTeam().getName()).addEntry(player.getDisplayName());
+            player.getScoreboard().getTeam(p.getTeam().getName()).addEntry(p.getDisplayName());
+        }
+		
+	}
+
+    @EventHandler
+    public void onLogin(PlayerLoginEvent e) {
+        //CustomPlayer p = CustomPlayer.getPlayer(e.getPlayer());
+		//Core.log(Level.INFO, "PlayerLogin " + p.getName() + " | " + p.isBanned());
+        //if(p.isBanned()) {
+        //    e.disallow(PlayerLoginEvent.Result.KICK_BANNED, "§cYou have been banned. §6Reason: " + p.getBanReason() + "\nUntil: " + p.getBanTime());
+        //}
+    }
+
+
+	
+	/**
+	 * Handles QuitMessage and other needed stuff
+	 * @param e event
+	 */
+	@EventHandler
+	public void onQuit(PlayerQuitEvent e) {
+		CustomPlayer p = CustomPlayer.getPlayer(e.getPlayer());
+		if(Build.getPlayers().containsKey(p))
+			Build.getPlayers().remove(p);
+		if(ServerSettings.isGame()) {
+            p.setNicked(false);
+            p.setDisplayName(p.getName());
+            p.unnick();
+            NickName.remove(p);
+        }
+        for(Team team : p.getScoreboard().getTeams()) {
+            team.removeEntry(p.getDisplayName());
+        }
+		Perms.getRanks().remove(p);
+		p.onLeave();
+	}
+	
+	/**
+	 * creates player in database
+	 * @param p CustomPlayer
+	 */
+	void createPlayer(CustomPlayer p) {
+		MySQL sql = Core.returnSQL();
+	    Date date = new Date();
+	    Timestamp time = new Timestamp(date.getTime());
+	    String uuid = p.getUniqueId().toString();
+	    try {
+	    	sql.openConnection();
+			PreparedStatement st = sql.getConnection().prepareStatement("SELECT UUID FROM users WHERE UUID ='" + uuid + "'");
+	    	ResultSet res = st.executeQuery();
+	      if (!res.next()){
+	    	  PreparedStatement st2 = sql.getConnection().prepareStatement("INSERT INTO users (UUID, FirstJoin, Rank, Coins) VALUES ('" + uuid + "','" + time + "', '" + Perms.Ranks.Player.toString() + "', 0);");
+	    	  st2.execute();
+	    	  
+	    	  int id = p.getID();
+	    	  
+	    	  PreparedStatement st3 = sql.getConnection().prepareStatement("INSERT INTO PlayerSettings (ID, teleport, FastMenu, requestsParty, requestsFriend, joined, nick) VALUES ('" + id +"', '1', '0', '1', '1', '0', '0',);");
+	    	  st3.execute();
+	    	  
+	    	  PreparedStatement st4 = sql.getConnection().prepareStatement("INSERT INTO FoundItems(ID, music_3, sugar, feather, hearts) VALUES ('" + id + "',0, 0, 0, 0);");
+	    	  st4.execute();
+	    	  
+	    	  sql.closeConnection();
+              return;
+	      }
+            sql.closeConnection();
+	    }
+	    catch (SQLException | ClassNotFoundException e) {
+	      e.printStackTrace();
+	    }
+	}
+	
+	
+	  /**
+	   * Handles KickMessage
+	   * @param e event
+	   */
+	@EventHandler(priority=EventPriority.HIGHEST)
+	  public void onKick(PlayerKickEvent e) {
+        CustomPlayer p = CustomPlayer.getPlayer(e.getPlayer());
+	    e.setLeaveMessage(null);
+        p.setNicked(false);
+	  }
+
+    static Inventory getLanguageChooser(CustomPlayer p) {
+        Inventory inv = Bukkit.createInventory(p, 9, "§6Language Chooser");
+
+        ItemStack en = new ItemStack(Material.PAPER);
+        ItemMeta enMeta = en.getItemMeta();
+        enMeta.setDisplayName("§6english");
+        en.setItemMeta(enMeta);
+
+        ItemStack de = new ItemStack(Material.PAPER);
+        ItemMeta deMeta = de.getItemMeta();
+        deMeta.setDisplayName("§6Deutsch");
+        de.setItemMeta(deMeta);
+
+
+        ItemStack it = new ItemStack(Material.PAPER);
+        ItemMeta itMeta = it.getItemMeta();
+        itMeta.setDisplayName("§6Italiano");
+        it.setItemMeta(itMeta);
+
+        inv.setItem(0, en);
+        inv.setItem(1, de);
+        inv.setItem(2, it);
+
+        return inv;
+    }
+}