univentoEU/Core
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

updated to much stuff

Browse Source
This commit is contained in:
Johannes Theiner 2016-04-13 05:48:26 +02:00
parent 6a9df37421
commit 01ac3ad26a
89 changed files with 954 additions and 10832 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
pom.xml Normal file
View File

@ -0,0 +1,101 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>eu.univento</groupId>
<artifactId>Core</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>Univento.eu Core System</name>
<url>http://univento.eu</url>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-assembly-plugin</artifactId>
<version>2.2-beta-5</version>
<configuration>
<archive>
<manifest>
<mainClass>eu.univento.core.Core</mainClass>
</manifest>
</archive>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
</configuration>
<executions>
<execution>
<id>make-assembly</id>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
<repositories>
<repository>
<id>spigot-repo</id>
<url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
</repository>
</repositories>
<dependencies>
<dependency>
<groupId>org.mongodb</groupId>
<artifactId>mongo-java-driver</artifactId>
<version>LATEST</version>
</dependency>
<dependency>
<groupId>org.mongodb</groupId>
<artifactId>mongodb-driver-async</artifactId>
<version>3.2.2</version>
</dependency>
<dependency>
<groupId>io.netty</groupId>
<artifactId>netty-all</artifactId>
<version>4.0.31.Final</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>LATEST</version>
</dependency>
<dependency>
<groupId>org.bukkit</groupId>
<artifactId>craftbukkit</artifactId>
<version>1.9-R0.1-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.bukkit</groupId>
<artifactId>bukkit</artifactId>
<version>1.9-R0.1-SNAPSHOT</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.spigotmc</groupId>
<artifactId>spigot-api</artifactId>
<version>1.9-R0.1-SNAPSHOT</version>
<scope>provided</scope>
</dependency>
</dependencies>
</project>

33
src/eu/univento/cloud/client/CloudClient.java
View File

@ -1,33 +0,0 @@
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();
}
}
}

159
src/eu/univento/core/Core.java
View File

@ -1,159 +0,0 @@
package eu.univento.core;
import eu.univento.core.api.BossBar;
import eu.univento.core.api.Config;
import eu.univento.core.api.SignInput;
import eu.univento.core.api.database.MySQL;
import eu.univento.core.api.events.MoveEventFilter;
import eu.univento.core.api.fakeplayer.PlayerKi;
import eu.univento.core.api.player.TeamSpeak;
import eu.univento.core.api.server.ServerSettings;
import eu.univento.core.commands.*;
import eu.univento.core.listeners.*;
import org.bukkit.Bukkit;
import org.bukkit.plugin.PluginManager;
import org.bukkit.plugin.java.JavaPlugin;
import java.io.IOException;
import java.sql.SQLException;
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 TeamSpeak ts;
public static TeamSpeak getTs() {
return ts;
}
/**
* logging and stuff
*/
private static Logger log = Bukkit.getLogger();
/**
* @param level Log level
* @param string String
*/
public static void log(Level level, String string) {
if(ServerSettings.isDebug()) {
log.log(level, "[Core] " + string);
}
}
private SignInput signInput;
public SignInput getSignInput() {
return signInput;
}
@Override
public void onEnable() {
ServerSettings.setDebug(true);
try {
Config.writeDefault();
} catch (ClassNotFoundException | SQLException | IOException e) {
e.printStackTrace();
}
instance = this;
this.signInput = new SignInput(this);
if(ServerSettings.isDebug()) log(Level.INFO, "Debug Modus aktiviert");
PluginManager pm = Bukkit.getPluginManager();
pm.registerEvents(new Commands(), this);
pm.registerEvents(new JoinQuit(), this);
pm.registerEvents(new Chat(), this);
pm.registerEvents(new Blocks(), this);
pm.registerEvents(new Events(), this);
pm.registerEvents(new MoveEventFilter(getServer()), this);
pm.registerEvents(new BossBar(), this);
pm.registerEvents(new PlayerKi(), this);
log(Level.INFO, "Events registriert");
String[] fix = {""};
if(ServerSettings.isGame()) new Fix(this, "fix", "Fixe dich oder andere Spieler", fix);
String[] runas = {""};
new RunAs(this, "RunAs", "Sende einen Befehl als ein anderer Spieler", runas);
String[] systeminfo = {""};
new SystemInfo(this, "SystemInfo", "Gibt Infos über den ServerPinger aus", systeminfo);
String[] vanish = {""};
new Vanish(this, "vanish", "Lässt dich verschwinden", vanish);
String[] gamemode = {"gm"};
new GameMode(this, "gamemode" , "Setzt deinen GameMode", gamemode);
String[] setrank = {"sr"};
new SetRank(this, "setrank" , "Setzt den Rang eines Spielers", setrank);
String[] globalmute = {"globalmute"};
new GlobalMute(this, "globalmute", "Muted den gesamten ServerPinger", globalmute);
String[] youtuber = {""};
new Youtuber(this, "youtuber", "setzt Spieler in den Youtuber Rang", youtuber);
String[] ts = {""};
new TS(this, "ts", "verifiziert Spieler auf dem TS", ts);
String[] ban = {""};
new Ban(this, "ban", "Bannt Spieler", ban);
String[] build = {"b"};
new Build(this, "build", "Setzt den Spieler in den Bau Modus", build);
String[] chatclear = {"cc"};
new ChatClear(this, "chatclear", "Cleart den Chat", chatclear);
if(ServerSettings.isGame()) {
String[] nick = {""};
new Nick(this, "nick", "ändert das Verhalten des Nicksystems", nick);
log(Level.INFO, "/nick aktiviert");
}
log(Level.INFO, "Alle Befehle registriert");
Bukkit.getMessenger().registerOutgoingPluginChannel(this, "BungeeCord");
this.ts = new TeamSpeak();
log(Level.INFO, "Plugin ver. " + getDescription().getVersion() + " gestartet");
}
@Override
public void onDisable() {
log(Level.INFO, "Plugin beendet");
getTs().disconnect();
}
}

18
src/eu/univento/core/api/Actionbar.java
View File

@ -1,18 +0,0 @@
package eu.univento.core.api;
import net.minecraft.server.v1_8_R3.IChatBaseComponent;
import net.minecraft.server.v1_8_R3.IChatBaseComponent.ChatSerializer;
import net.minecraft.server.v1_8_R3.PacketPlayOutChat;
import org.bukkit.craftbukkit.v1_8_R3.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);
((CraftPlayer) p).getHandle().playerConnection.sendPacket(ppoc);
}
}

78
src/eu/univento/core/api/AutoCommand.java
View File

@ -1,78 +0,0 @@
package eu.univento.core.api;
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;
/**
* @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());
System.out.println("[PostLib] 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<String>();
for (String alias : aliases) {
aliasList.add(alias);
}
super.setAliases(aliasList);
this.register();
}
public 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;
}
}

85
src/eu/univento/core/api/Blackscreen.java
View File

@ -1,85 +0,0 @@
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, new Runnable()
{
public void run()
{
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(((Integer)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);
}
}

301
src/eu/univento/core/api/BossBar.java
View File

@ -1,301 +0,0 @@
package eu.univento.core.api;
import eu.univento.core.Core;
import eu.univento.core.api.utils.FDragon;
import eu.univento.core.api.utils.FWither;
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.PlayerKickEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.plugin.Plugin;
import org.bukkit.scheduler.BukkitRunnable;
import java.util.HashMap;
import java.util.Map;
/**
* Thanks for chasechocolate and BigTeddy98 for the tutorial
* it is based on the code by them and some other tutorial
* https://forums.bukkit.org/threads/util-set-a-players-boss-bar-nms.245073/
* https://forums.bukkit.org/threads/tutorial-utilizing-the-boss-health-bar.158018/
* @author Marzouki Ghofrane , mgone CraftZone.fr
*/
public class BossBar implements Listener {
public static Plugin plugin;
public static Map<Player, String> playerdragonbartask = new HashMap<>();
public static Map<Player, Float> healthdragonbartask = new HashMap<>();
public static Map<Player, Integer> cooldownsdragonbar= new HashMap<>();
public static Map<Player, Integer> starttimerdragonbar= new HashMap<>();
public static Map<Player, String> playerwitherbartask = new HashMap<>();
public static Map<Player, Float> healthwitherbartask = new HashMap<>();
public static Map<Player, Integer> cooldownswitherbar= new HashMap<>();
public static Map<Player, Integer> starttimerwitherbar= new HashMap<>();
public void DragonBarTask() {
new BukkitRunnable() {
@SuppressWarnings("deprecation")
@Override
public void run() {
for(Player p : plugin.getServer().getOnlinePlayers()){
if(!cooldownsdragonbar.containsKey(p)) {
if(playerdragonbartask.containsKey(p) && !healthdragonbartask.containsKey(p)) { setBarDragon(p, playerdragonbartask.get(p)); }
else if(playerdragonbartask.containsKey(p) && healthdragonbartask.containsKey(p)) { setBarDragonHealth(p, playerdragonbartask.get(p), healthdragonbartask.get(p)); }
}
if(!cooldownswitherbar.containsKey(p)) {
if(playerwitherbartask.containsKey(p) && !healthwitherbartask.containsKey(p)) { setBarWither(p, playerwitherbartask.get(p)); }
else if(playerwitherbartask.containsKey(p) && healthwitherbartask.containsKey(p)) { setBarWitherHealth(p, playerwitherbartask.get(p), healthwitherbartask.get(p)); }
}
}
}
}.runTaskTimer(Core.getInstance(), 0, 40);
new BukkitRunnable() {
@SuppressWarnings("deprecation")
@Override
public void run() {
for(Player p : plugin.getServer().getOnlinePlayers()){
if(cooldownsdragonbar.containsKey(p)) {
if(cooldownsdragonbar.get(p) > 0)
{ cooldownsdragonbar.put(p,cooldownsdragonbar.get(p)-1); setBarDragonTimer(p, playerdragonbartask.get(p), cooldownsdragonbar.get(p)); }
else removeBarDragon(p);
}
if(cooldownswitherbar.containsKey(p)) {
if(cooldownswitherbar.get(p) > 0)
{ cooldownswitherbar.put(p,cooldownswitherbar.get(p)-1); setBarWitherTimer(p, playerwitherbartask.get(p), cooldownswitherbar.get(p)); }
else removeBarWither(p);
}
}
}
}.runTaskTimer(Core.getInstance(), 0, 20);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void PlayerQuit(PlayerQuitEvent event) {
Player p = event.getPlayer();
removeBar(p);
FDragon.removehorligneD(p);
FWither.removehorligneW(p);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void PlayerKick(PlayerKickEvent event) {
Player p = event.getPlayer();
removeBar(p);
FDragon.removehorligneD(p);
FWither.removehorligneW(p);
}
//dragon
public static void setBarDragon(Player p, String text) {
playerdragonbartask.put(p, text);
FDragon.setBossBartext(p, text);
}
public static void setBarDragonHealth(Player p, String text, float health) {
if(health<=0 || health >100) { health = 100; text = "health must be between 1 and 100 it's a %";}
playerdragonbartask.put(p, text);
healthdragonbartask.put(p, (health/100)*200);
FDragon.setBossBar(p, text, health);
}
public static void setBarDragonTimer(Player p, String text, int timer) {
playerdragonbartask.put(p, text);
cooldownsdragonbar.put(p, timer);
if(!starttimerdragonbar.containsKey(p)) starttimerdragonbar.put(p, timer);
int unite = Math.round(200/starttimerdragonbar.get(p));
FDragon.setBossBar(p, text, unite*timer);
}
public static void removeBarDragon(Player p) {
playerdragonbartask.remove(p);
healthdragonbartask.remove(p);
cooldownsdragonbar.remove(p);
starttimerdragonbar.remove(p);
FDragon.removeBossBar(p);
}
public static boolean hasBarDragon(Player p) {
return playerdragonbartask.get(p) != null;
}
public static String getMessageDragon(Player p) {
if(playerdragonbartask.containsKey(p)) return playerdragonbartask.get(p);
else return " ";
}
//wither
public static void setBarWither(Player p, String text) {
playerwitherbartask.put(p, text);
FWither.setBossBartext(p, text);
}
public static void setBarWitherHealth(Player p, String text, float health) {
if(health<=0 || health >100) { health = 100; text = "health must be between 1 and 100 it's a %";}
playerwitherbartask.put(p, text);
healthwitherbartask.put(p, (health/100)*300);
FWither.setBossBar(p, text, health);
}
public static void setBarWitherTimer(Player p, String text, int timer) {
playerwitherbartask.put(p, text);
cooldownswitherbar.put(p, timer);
if(!starttimerwitherbar.containsKey(p)) starttimerwitherbar.put(p, timer);
int unite = Math.round(300/starttimerwitherbar.get(p));
FWither.setBossBar(p, text, unite*timer);
}
public static void removeBarWither(Player p) {
playerwitherbartask.remove(p);
healthwitherbartask.remove(p);
cooldownswitherbar.remove(p);
starttimerwitherbar.remove(p);
FWither.removeBossBar(p);
}
public static boolean hasBarWither(Player p) {
return playerwitherbartask.get(p) != null;
}
public static String getMessageWither(Player p) {
if(playerwitherbartask.containsKey(p)) return playerwitherbartask.get(p);
else return " ";
}
//both
public static void setBar(Player p, String text) {
if(McVersion(p)) {
playerwitherbartask.put(p, text);
FWither.setBossBartext(p, text); }
playerdragonbartask.put(p, text);
FDragon.setBossBartext(p, text);
}
public static void setBarHealth(Player p, String text, float health) {
if(health<=0 || health >100) { health = 100; text = "health must be between 1 and 100 it's a %";}
if(McVersion(p)) {
playerwitherbartask.put(p, text);
healthwitherbartask.put(p, (health/100)*300);
FWither.setBossBar(p, text, health); }
playerdragonbartask.put(p, text);
healthdragonbartask.put(p, (health/100)*200);
FDragon.setBossBar(p, text, health);
}
public static void setBarTimer(Player p, String text, int timer) {
if(McVersion(p)) {
playerwitherbartask.put(p, text);
cooldownswitherbar.put(p, timer);
if(!starttimerwitherbar.containsKey(p)) starttimerwitherbar.put(p, timer);
int unite = Math.round(300/starttimerwitherbar.get(p));
FWither.setBossBar(p, text, unite*timer); }
playerdragonbartask.put(p, text);
cooldownsdragonbar.put(p, timer);
if(!starttimerdragonbar.containsKey(p)) starttimerdragonbar.put(p, timer);
int unite1 = Math.round(200/starttimerdragonbar.get(p));
FDragon.setBossBar(p, text, unite1*timer);
}
public static void removeBar(Player p) {
if(McVersion(p)) {
playerwitherbartask.remove(p);
healthwitherbartask.remove(p);
cooldownswitherbar.remove(p);
starttimerwitherbar.remove(p);
FWither.removeBossBar(p); }
playerdragonbartask.remove(p);
healthdragonbartask.remove(p);
cooldownsdragonbar.remove(p);
starttimerdragonbar.remove(p);
FDragon.removeBossBar(p);
}
public static boolean hasBar(Player p) {
if(McVersion(p)) {
if(playerwitherbartask.containsKey(p) && playerdragonbartask.containsKey(p))
return true;
else return false; }
else {
return playerdragonbartask.get(p) != null;
}
}
public static String getMessage(Player p) {
if(playerdragonbartask.containsKey(p)) return playerdragonbartask.get(p);
else return " ";
}
public static boolean McVersion(Player p) {
return true;
}
}

172
src/eu/univento/core/api/Config.java
View File

@ -1,172 +0,0 @@
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");
Location loc = new Location(Bukkit.getWorld(world), x, y, z, yaw, pitch);
return loc;
}
/**
* checks if data is existing
* @param path path do data
* @return true / false
*/
public static boolean isExsisting(String path) {
return cfg.contains(path);
}
}

149
src/eu/univento/core/api/Hologram.java
View File

@ -1,149 +0,0 @@
package eu.univento.core.api;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.entity.Player;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.List;
public class Hologram
{
private List<String> lines;
private Location loc;
private static final double ABS = 0.23D;
private static String path = Bukkit.getServer().getClass().getPackage().getName();
private static String version = path.substring(path.lastIndexOf(".") + 1, path.length());
private static Class<?> armorStand;
private static Class<?> worldClass;
private static Class<?> nmsEntity;
private static Class<?> craftWorld;
private static Class<?> packetClass;
private static Class<?> entityLivingClass;
private static Constructor<?> armorStandConstructor;
private static Class<?> nmsPacket;
static
{
try
{
armorStand = Class.forName("net.minecraft.server." + version +
".EntityArmorStand");
worldClass = Class.forName("net.minecraft.server." + version +
".World");
nmsEntity = Class.forName("net.minecraft.server." + version +
".Entity");
craftWorld = Class.forName("org.bukkit.craftbukkit." + version +
".CraftWorld");
packetClass = Class.forName("net.minecraft.server." + version +
".PacketPlayOutSpawnEntityLiving");
entityLivingClass = Class.forName("net.minecraft.server." + version +
".EntityLiving");
armorStandConstructor = armorStand
.getConstructor(new Class[] { worldClass });
nmsPacket = Class.forName("net.minecraft.server." + version +
".Packet");
}
catch (java.lang.NoSuchMethodException ex) {
System.err.println("Error - Classes not initialized!");
ex.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
public Hologram(Location loc, List<String> lines) {
this.lines = lines;
this.loc = loc;
}
public boolean display(Player p)
{
Location displayLoc = this.loc.clone().add(0.0D, 0.23D * this.lines.size() - 1.97D,
0.0D);
for (int i = 0; i < this.lines.size(); i++) {
Object packet = null;
try {
packet = getPacket(this.loc.getWorld(),
displayLoc.getX(), displayLoc.getY(), displayLoc.getZ(),
this.lines.get(i));
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
if (packet == null)
return false;
sendPacket(p, packet);
displayLoc.add(0.0D, -0.23D, 0.0D);
}
return true;
}
private Object getPacket(World w, double x, double y, double z, String text) throws NoSuchMethodException {
try {
Object craftWorldObj = craftWorld.cast(w);
Method getHandleMethod = craftWorldObj.getClass().getMethod(
"getHandle", new Class[0]);
Object entityObject = armorStandConstructor
.newInstance(new Object[] { getHandleMethod
.invoke(craftWorldObj, new Object[0]) });
Method setCustomName = entityObject.getClass().getMethod(
"setCustomName", new Class[] { String.class });
setCustomName.invoke(entityObject, new Object[] { text });
Method setCustomNameVisible = nmsEntity.getMethod(
"setCustomNameVisible", new Class[] { Boolean.TYPE });
setCustomNameVisible.invoke(entityObject, new Object[] { Boolean.valueOf(true) });
Method setGravity = entityObject.getClass().getMethod("setGravity",
new Class[] { Boolean.TYPE });
setGravity.invoke(entityObject, new Object[] { Boolean.valueOf(false) });
Method setLocation = entityObject.getClass().getMethod(
"setLocation",
new Class[] { Double.TYPE, Double.TYPE, Double.TYPE,
Float.TYPE, Float.TYPE });
setLocation.invoke(entityObject,
new Object[] { Double.valueOf(x), Double.valueOf(y), Double.valueOf(z), Float.valueOf(0.0F), Float.valueOf(0.0F) });
Method setInvisible = entityObject.getClass().getMethod(
"setInvisible", new Class[] { Boolean.TYPE });
setInvisible.invoke(entityObject, new Object[] { Boolean.valueOf(true) });
Constructor<?> cw = packetClass
.getConstructor(new Class[] { entityLivingClass });
Object packetObject = cw.newInstance(new Object[] { entityObject });
return packetObject;
}
catch (java.lang.SecurityException e)
{
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
return null;
}
private void sendPacket(Player p, Object packet) {
try {
Method getHandle = p.getClass().getMethod("getHandle", new Class[0]);
Object entityPlayer = getHandle.invoke(p, new Object[0]);
Object pConnection = entityPlayer.getClass()
.getField("playerConnection").get(entityPlayer);
Method sendMethod = pConnection.getClass().getMethod("sendPacket",
new Class[] { nmsPacket });
sendMethod.invoke(pConnection, new Object[] { packet });
} catch (Exception e) {
e.printStackTrace();
}
}
public static double getAbs() {
return ABS;
}
}

147
src/eu/univento/core/api/SignInput.java
View File

@ -1,147 +0,0 @@
package eu.univento.core.api;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToMessageDecoder;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.plugin.Plugin;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.function.Consumer;
/**
* @author Janhektor This class in licensed under GPLv3 For more information
* look at http://www.gnu.org/licenses/gpl-3.0
*/
public final class SignInput implements Listener, Runnable {
private final static String VERSION;
static {
String path = Bukkit.getServer().getClass().getPackage().getName();
VERSION = path.substring(path.lastIndexOf(".") + 1, path.length());
}
private final Plugin plugin;
private final Map<UUID, Consumer<String[]>> inputResults;
public SignInput(Plugin plugin) {
this.plugin = plugin;
this.inputResults = new HashMap<UUID, Consumer<String[]>>();
Bukkit.getScheduler().runTaskTimer(this.plugin, this, 0L, 20 * 3L);
}
/**
* Use this method to read the SignInput from a player The accept()-method
* of your consumer will be called, when the player close the sign
*
* @return boolean successful
* @param p
* - The Player, who have to type an input
* @param result
* - The consumer (String[]) for the result; String[] contains
* strings for 4 lines
*/
public boolean readInput(Player p, Consumer<String[]> result) {
inputResults.put(p.getUniqueId(), result);
try {
Class<?> packetClass = Class.forName(getNMSClass("PacketPlayOutOpenSignEditor"));
Class<?> blockPositionClass = Class.forName(getNMSClass("BlockPosition"));
Constructor<?> blockPosCon = blockPositionClass
.getConstructor(new Class[] { int.class, int.class, int.class });
Object blockPosition = blockPosCon.newInstance(new Object[] { 0, 0, 0 });
Constructor<?> packetCon = packetClass.getConstructor(new Class[] { blockPositionClass });
Object packet = packetCon.newInstance(new Object[] { blockPosition });
Method getHandle = p.getClass().getMethod("getHandle");
Object nmsPlayer = getHandle.invoke(p);
Field pConnectionField = nmsPlayer.getClass().getField("playerConnection");
Object pConnection = pConnectionField.get(nmsPlayer);
Method sendMethod = pConnection.getClass().getMethod("sendPacket",
new Class[] { Class.forName(getNMSClass("Packet")) });
sendMethod.invoke(pConnection, new Object[] { packet });
return true;
} catch (Exception ex) {
ex.printStackTrace();
return false;
}
}
/* Garbage Collection */
@Override
public void run() {
for (UUID uuid : inputResults.keySet()) {
if (Bukkit.getPlayer(uuid) == null)
inputResults.remove(uuid);
}
}
/* Events */
@EventHandler
public void onJoin(PlayerJoinEvent e) {
Player p = e.getPlayer();
getNettyChannel(p).pipeline().addAfter("decoder", "signListener", new MessageToMessageDecoder<Object>() {
@Override
protected void decode(ChannelHandlerContext chc, Object packet, List<Object> packetList) throws Exception {
if (instanceOf(packet, getNMSClass("PacketPlayInUpdateSign"))) {
Method bMethod = packet.getClass().getMethod("b");
Object chatBaseComponents = bMethod.invoke(packet);
String[] lines = new String[4];
for (int i = 0; i < 4; i++) {
Object chatComponent = Array.get(chatBaseComponents, i);
Method getText = chatComponent.getClass().getMethod("getText");
lines[i] = (String) getText.invoke(chatComponent);
}
if (inputResults.containsKey(p.getUniqueId())) {
inputResults.get(p.getUniqueId()).accept(lines);
inputResults.remove(p.getUniqueId());
}
}
packetList.add(packet);
}
});
}
/* Util Methods */
private Channel getNettyChannel(Player p) {
Channel ch = null;
try {
Method getHandle = p.getClass().getMethod("getHandle");
Object nmsPlayer = getHandle.invoke(p);
Field pConnectionField = nmsPlayer.getClass().getField("playerConnection");
Object pConnection = pConnectionField.get(nmsPlayer);
Field networkManagerField = pConnection.getClass().getField("networkManager");
Object networkManager = networkManagerField.get(pConnection);
ch = (Channel) networkManager.getClass().getField("k").get(networkManager);
} catch (Exception ex) {
ex.printStackTrace();
}
return ch;
}
private boolean instanceOf(Object o, String className) {
try {
return Class.forName(className).isInstance(o);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return false;
}
private String getNMSClass(String className) {
return "net.minecraft.server." + VERSION + "." + className;
}
}

99
src/eu/univento/core/api/Title.java
View File

@ -1,99 +0,0 @@
package eu.univento.core.api;
import net.minecraft.server.v1_8_R3.IChatBaseComponent;
import net.minecraft.server.v1_8_R3.PacketPlayOutPlayerListHeaderFooter;
import net.minecraft.server.v1_8_R3.PacketPlayOutTitle;
import net.minecraft.server.v1_8_R3.PlayerConnection;
import org.bukkit.ChatColor;
import org.bukkit.craftbukkit.v1_8_R3.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.intValue(), stay.intValue(), fadeOut.intValue());
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);
}
}
/**
* checks if String is integer
* @param s String
* @return boolean
*/
boolean isInteger(String s) {
try {
Integer.parseInt(s);
} catch (NumberFormatException e) {
return false;
}
return true;
}
}

179
src/eu/univento/core/api/Utils.java
View File

@ -1,179 +0,0 @@
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 a = from, b = to;
// calculate the distance between the locations (a => from || b => to)
double dX = a.getX() - b.getX();
double dY = a.getY() - b.getY();
double dZ = a.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);
Vector vector = new Vector(x, z, y);
// -------------------------
return vector;
}
/**
* 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
//TODO: remove effect.toString(), its only to remove unused warnings
effect.toString();
}
}

72
src/eu/univento/core/api/database/Database.java
View File

@ -1,72 +0,0 @@
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;
}
}

36
src/eu/univento/core/api/database/MySQL.java
View File

@ -1,36 +0,0 @@
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;
}
}

47
src/eu/univento/core/api/database/SQLite.java
View File

@ -1,47 +0,0 @@
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;
}
}

129
src/eu/univento/core/api/effects/WorldBoarder.java
View File

@ -1,129 +0,0 @@
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();
}
}
}

239
src/eu/univento/core/api/entity/EntityModifier.java
View File

@ -1,239 +0,0 @@
package eu.univento.core.api.entity;
import net.minecraft.server.v1_8_R3.EntityLiving;
import net.minecraft.server.v1_8_R3.NBTTagCompound;
import org.bukkit.Bukkit;
import org.bukkit.EntityEffect;
import org.bukkit.Location;
import org.bukkit.craftbukkit.v1_8_R3.entity.CraftCreature;
import org.bukkit.craftbukkit.v1_8_R3.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_8_R3.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_8_R3.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;
}
}
}

89
src/eu/univento/core/api/events/MoveEventFilter.java
View File

@ -1,89 +0,0 @@
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();
}
}
}
}

232
src/eu/univento/core/api/fakeplayer/FakePlayer.java
View File

@ -1,232 +0,0 @@
package eu.univento.core.api.fakeplayer;
import com.mojang.authlib.GameProfile;
import eu.univento.core.Core;
import net.minecraft.server.v1_8_R3.*;
import org.bukkit.Location;
import org.bukkit.craftbukkit.v1_8_R3.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 {
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;
}
}

51
src/eu/univento/core/api/fakeplayer/PlayerKi.java
View File

@ -1,51 +0,0 @@
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());
}
}
}
}

224
src/eu/univento/core/api/gui/AnvilGui.java
View File

@ -1,224 +0,0 @@
package eu.univento.core.api.gui;
import eu.univento.core.Core;
import net.minecraft.server.v1_8_R3.*;
import org.bukkit.Bukkit;
import org.bukkit.craftbukkit.v1_8_R3.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;
}
}

124
src/eu/univento/core/api/items/ItemSkulls.java
View File

@ -1,124 +0,0 @@
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;
}
}

67
src/eu/univento/core/api/items/Pagifier.java
View File

@ -1,67 +0,0 @@
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;
}
}

557
src/eu/univento/core/api/languages/Language_DE.java
View File

@ -1,557 +0,0 @@
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";
}
}

556
src/eu/univento/core/api/languages/Language_EN.java
View File

@ -1,556 +0,0 @@
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§lJetzt neu:";
}
@Override
public String LobbyBoard_NEWS() {
return "Scheibenwischer";
}
}

555
src/eu/univento/core/api/languages/Language_IT.java
View File

@ -1,555 +0,0 @@
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 nel §emodo di costruzione";
}
@Override
public String Core_BUILD_OFF() {
return "§7Tu sei §auscito dal §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 è stato §cpulito §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 più dato un §esoprannome §7automatico";
}
@Override
public String Lobby_FORCEFIELD_ON() {
return "§7Hai §7attivato §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 §euscita §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 "§aattivato";
}
@Override
public String LobbyItems_SETTINGS_OFF() {
return "§cdisattivato";
}
@Override
public String LobbyItems_BACK() {
return "§cindietro";
}
@Override
public String LobbyBoard_FOUND_SECRETS() {
return "§eSegreti§7:";
}
@Override
public String LobbyBoard_COINS() {
return "§eI tuoi 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§lNovità:";
}
@Override
public String LobbyBoard_NEWS() {
return "Scheibenwischer";
}
}

125
src/eu/univento/core/api/languages/Languages.java
View File

@ -1,125 +0,0 @@
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();
}

312
src/eu/univento/core/api/languages/Messages.java
View File

@ -1,312 +0,0 @@
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.getLang().equals("DE")) this.lang = de;
if(player.getLang().equals("IT")) this.lang = it;
if(player.getLang().equals("EN")) this.lang = en;
}
public String PREFIX() {
return " §7• §6univento§7.§eeu §7• ";
}
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";
}
}

88
src/eu/univento/core/api/map/Region.java
View File

@ -1,88 +0,0 @@
package eu.univento.core.api.map;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.configuration.file.YamlConfiguration;
import java.io.File;
import java.io.IOException;
/**
* @author RainyCrafter
*/
public class Region {
World w;
int minx;
int miny;
int minz;
int maxx;
int maxy;
int maxz;
String name;
public Region(Location loc1, Location loc2, String name) {
w = loc1.getWorld();
this.name = name;
minx = Math.min(loc1.getBlockX(), loc2.getBlockX());
miny = Math.min(loc1.getBlockY(), loc2.getBlockY());
minz = Math.min(loc1.getBlockZ(), loc2.getBlockZ());
maxx = Math.max(loc1.getBlockX(), loc2.getBlockX());
maxy = Math.max(loc1.getBlockY(), loc2.getBlockY());
maxz = Math.max(loc1.getBlockZ(), loc2.getBlockZ());
}
public void save(){
File file = new File("plugins/Core/regions.yml");
FileConfiguration cfg = YamlConfiguration.loadConfiguration(file);
cfg.set(name+".W", w.getName());
cfg.set(name+".Min.X", minx);
cfg.set(name+".Min.Y", miny);
cfg.set(name+".Min.Z", minz);
cfg.set(name+".Max.X", maxx);
cfg.set(name+".Max.Y", maxy);
cfg.set(name+".Max.Z", maxz);
try {
cfg.save(file);
} catch (IOException e) {
e.printStackTrace();
}
}
public boolean between(int w1, int zw, int w2){
if(zw >= w1 && zw <= w2){
return true;
}
return false;
}
public boolean isInside(Location loc) {
if (loc.getWorld() != w) {
return false;
}
if (between(minx, loc.getBlockX(), maxx) && between(miny, loc.getBlockY(), maxy) && between(minz, loc.getBlockZ(), maxz)) {
return true;
}
return false;
}
}

98
src/eu/univento/core/api/map/Schematic.java
View File

@ -1,98 +0,0 @@
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package eu.univento.core.api.map;
import ch.spacebase.opennbt.stream.NBTInputStream;
import ch.spacebase.opennbt.tag.*;
import eu.univento.core.api.map.Constants.MinecraftSchematicTagNames;
import java.io.File;
import java.io.FileInputStream;
import java.util.List;
/**
*
* @author James
*/
public class Schematic {
private CompoundTag _baseTag;
private ShortTag _width;
private ShortTag _length;
private ShortTag _height;
private StringTag _materials;
private ByteArrayTag _blocks;
private ByteArrayTag _blockData;
private List<CompoundTag> _entities;
private List<CompoundTag> _tileEntities;
public Schematic(File schematicFile) {
_baseTag = getSchematicTagFromNBTFile(schematicFile);
_width = (ShortTag) _baseTag.get(MinecraftSchematicTagNames.WIDTH);
_length = (ShortTag) _baseTag.get(MinecraftSchematicTagNames.LENGTH);
_height = (ShortTag) _baseTag.get(MinecraftSchematicTagNames.HEIGHT);
_blocks = (ByteArrayTag) _baseTag.get(MinecraftSchematicTagNames.BLOCKS);
_blockData = (ByteArrayTag) _baseTag.get(MinecraftSchematicTagNames.DATA);
_entities = ((ListTag) _baseTag.get(MinecraftSchematicTagNames.ENTITIES)).getValue();
_tileEntities = ((ListTag) _baseTag.get(MinecraftSchematicTagNames.TILE_ENTITIES)).getValue();
}
private static CompoundTag getSchematicTagFromNBTFile(File schematicFile) {
CompoundTag schematicTag = null;
try {
FileInputStream stream = new FileInputStream(schematicFile);
NBTInputStream nbtStream = new NBTInputStream(stream);
schematicTag = (CompoundTag) nbtStream.readTag();
nbtStream.close();
stream.close();
} catch (Exception e) {
//TODO: LOG ERROR
}
return schematicTag;
}
public CompoundTag getBaseTag() {
return _baseTag;
}
public ShortTag getWidth() {
return _width;
}
public ShortTag getLength() {
return _length;
}
public ShortTag getHeight() {
return _height;
}
public StringTag getMaterials() {
return _materials;
}
public ByteArrayTag getBlocks() {
return _blocks;
}
public ByteArrayTag getBlockData() {
return _blockData;
}
public List<CompoundTag> getEntities() {
return _entities;
}
public List<CompoundTag> getTileEntities() {
return _tileEntities;
}
}

148
src/eu/univento/core/api/player/BanSystem.java
View File

@ -1,148 +0,0 @@
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 ID='" + 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();
}
}

641
src/eu/univento/core/api/player/CustomPlayer.java
View File

@ -1,641 +0,0 @@
package eu.univento.core.api.player;
import com.github.theholywaffle.teamspeak3.api.wrapper.ClientInfo;
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.server.ServerSettings;
import eu.univento.core.api.server.Servers;
import eu.univento.core.api.utils.NameFetcher;
import org.bukkit.Bukkit;
import org.bukkit.Color;
import org.bukkit.Sound;
import org.bukkit.craftbukkit.v1_8_R3.CraftServer;
import org.bukkit.craftbukkit.v1_8_R3.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;
/**
* 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() {
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;
}
}
/**
* get normal player
* @return Player
*/
public Player getPLAYER() {
return PLAYER;
}
/**
* 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();
}
}
/**
* gets Client Info from TeamSpeak
* @return ClientInfo
*/
public ClientInfo getTSClientInfo() {
TeamSpeak ts = Core.getTs();
try {
return ts.getClientInfo(ts.getTsId(this));
} catch (ClassNotFoundException | SQLException e) {
e.printStackTrace();
return null;
}
}
/**
* verifys player account on teamspeak
*/
public void verifyTs() {
try {
Core.getTs().verify(this);
} catch (ClassNotFoundException | SQLException e) {
e.printStackTrace();
}
}
public void checkVerifiedTs() {
try {
Core.getTs().checkVerifiyed(this);
} catch (SQLException | ClassNotFoundException e) {
e.printStackTrace();
}
}
public boolean hasVerifiedTs() {
try {
return Core.getTs().hasVerified(this);
} catch (SQLException | ClassNotFoundException e) {
e.printStackTrace();
return false;
}
}
/**
* 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);
}
/**
* 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;
}
}
/**
* 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.LEVEL_UP, 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());
}
//TODO: add other functions for secrets
public int getFoundSecrets() {
return 0;
}
public String getLang() {
return PlayerSettings.get("lang", this);
}
public void setLang(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);
}
}

102
src/eu/univento/core/api/player/NickName.java
View File

@ -1,102 +0,0 @@
package eu.univento.core.api.player;
import eu.univento.core.Core;
import eu.univento.core.api.database.MySQL;
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 {
/**
* nick names of players
*/
static HashMap<CustomPlayer, String> nicks = new HashMap<>();
/**
*
* @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()) {
return rs.getInt("nick") == 1;
}
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
*/
static String getRandomNick() {
ArrayList<String> names = new ArrayList<>();
names.add("XXKevinXX");
names.add("xxGamelcrafterxx");
names.add("LiaaamDesigns");
names.add("Firestarter88");
names.add("MatelLucario99");
names.add("Ghostcraft_No");
Random r = new Random();
int i = r.nextInt(names.size());
return names.get(i);
}
}

315
src/eu/univento/core/api/player/Perms.java
View File

@ -1,315 +0,0 @@
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.NameTagVisibility;
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{
/**
* contains all joined players and there ranks
*/
private static HashMap<CustomPlayer, Ranks> ranks = new HashMap<>();
/**
* gets ranks
* @return HashMap<CustomPlayer, Ranks>
*/
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
*/
public static class Teams {
CustomPlayer player;
public Scoreboard board;
public Team Admin;
public Team SrDeveloper;
public Team Developer;
public Team SrModerator;
public Team Moderator;
public Team HeadBuilder;
public Team Builder;
public Team Supporter;
public Team Youtuber;
public Team Premium;
public Team Player;
public 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
*/
public 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.setNameTagVisibility(NameTagVisibility.ALWAYS);
SrDeveloper.setNameTagVisibility(NameTagVisibility.ALWAYS);
Developer.setNameTagVisibility(NameTagVisibility.ALWAYS);
SrModerator.setNameTagVisibility(NameTagVisibility.ALWAYS);
HeadBuilder.setNameTagVisibility(NameTagVisibility.ALWAYS);
Moderator.setNameTagVisibility(NameTagVisibility.ALWAYS);
Builder.setNameTagVisibility(NameTagVisibility.ALWAYS);
Supporter.setNameTagVisibility(NameTagVisibility.ALWAYS);
Youtuber.setNameTagVisibility(NameTagVisibility.ALWAYS);
Premium.setNameTagVisibility(NameTagVisibility.ALWAYS);
Player.setNameTagVisibility(NameTagVisibility.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 static enum Ranks{
Admin(11),
SrDeveloper(10),
Developer(9),
SrModerator(8),
HeadBuilder(7),
Moderator(6),
Builder(5),
Supporter(4),
Youtuber(3),
Premium(2),
Player(1);
public final int value;
private Ranks(int n) {
this.value = n;
}
}
}

144
src/eu/univento/core/api/player/PlayerSettings.java
View File

@ -1,144 +0,0 @@
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;
}
}

67
src/eu/univento/core/api/player/Spectator.java
View File

@ -1,67 +0,0 @@
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);
}
}

210
src/eu/univento/core/api/player/TeamSpeak.java
View File

@ -1,210 +0,0 @@
package eu.univento.core.api.player;
import com.github.theholywaffle.teamspeak3.TS3Api;
import com.github.theholywaffle.teamspeak3.TS3Config;
import com.github.theholywaffle.teamspeak3.TS3Query;
import com.github.theholywaffle.teamspeak3.api.wrapper.Client;
import com.github.theholywaffle.teamspeak3.api.wrapper.ClientInfo;
import eu.univento.core.Core;
import eu.univento.core.api.Config;
import eu.univento.core.api.database.MySQL;
import eu.univento.core.api.player.Perms.Ranks;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.UUID;
import java.util.logging.Level;
/**
* basic functions for teamspeak communication
* @author joethei
* @version 1.0
*/
public class TeamSpeak {
private TS3Query query;
private TS3Api api;
int verified = 11;
/**
* inits class
*/
public TeamSpeak() {
final TS3Config config = new TS3Config();
config.setHost(Config.readString("TS.IP"));
config.setQueryPort(Config.readInt("TS.QueryPort"));
config.setDebugLevel(Level.OFF);
config.setLoginCredentials(Config.readString("TS.QueryUser"), Config.readString("TS.Query.Pass"));
final TS3Query query = new TS3Query(config);
query.connect();
final TS3Api api = query.getApi();
api.selectVirtualServerById(1);
api.setNickname("Rechteverteiler von " + Bukkit.getServerName());
this.api = api;
this.query = query;
}
public void disconnect() {
query.exit();
}
/**
* gets teamspeak api
* @return TS3Api
*/
TS3Api getAPI() {
return api;
}
/**
* gets client info for id
* @param id database id
* @return ClientInfo
*/
ClientInfo getClientInfo(int id) {
return api.getClientInfo(id);
}
/**
* gets database id from teamspeak for player
* @param p CustomPlayer
* @return Integer
* @throws SQLException SQL server not available or throwing error
* @throws ClassNotFoundException class couldn't be found
*/
public int getTsId(CustomPlayer p) throws ClassNotFoundException, SQLException {
MySQL sql = Core.returnSQL();
sql.openConnection();
PreparedStatement st = sql.getConnection().prepareStatement("SELECT TS_ID FROM users WHERE ID='" + p.getID() + "'");
ResultSet rs = st.executeQuery();
rs.next();
if (rs.getInt("TS_ID") != 0) {
int id = rs.getInt("TS_ID");
sql.closeConnection();
return id;
}
sql.closeConnection();
return 0;
}
public String getUUID(int id) throws SQLException, ClassNotFoundException {
MySQL sql = Core.returnSQL();
sql.openConnection();
PreparedStatement st = sql.getConnection().prepareStatement("SELECT UUID FROM users WHERE TS_ID='" + id + "';");
ResultSet rs = st.executeQuery();
if(rs.next()) {
String uuid = rs.getString("UUID");
sql.closeConnection();
return uuid;
}
sql.closeConnection();
return null;
}
/**
* writes id of player to database
* @param p CustomPlayer
* @param id database id
* @throws SQLException SQL server not available or throwing error
* @throws ClassNotFoundException class couldn't be found
*/
void setTsId(CustomPlayer p, int id) throws ClassNotFoundException, SQLException {
MySQL sql = Core.returnSQL();
sql.openConnection();
PreparedStatement st = sql.getConnection().prepareStatement("UPDATE users SET TS_ID='" + id + "' WHERE UUID='" + p.getUniqueId().toString() + "';");
st.execute();
sql.closeConnection();
}
/**
* sets rank on teamspeak
* @param p CustomPlayer
* @throws SQLException SQL server not available or throwing error
* @throws ClassNotFoundException class couldn't be found
*/
private void setRank(CustomPlayer p, Client client) throws ClassNotFoundException, SQLException {
//for(ServerGroup groups : api.getServerGroupsByClient(client)) {
// api.removeClientFromServerGroup(groups, client);
//}
api.addClientToServerGroup(getIdForRank(p.getRank()), client.getDatabaseId());
api.addClientToServerGroup(verified, client.getDatabaseId());
api.pokeClient(client.getId(), "Du wurdest von unserem freundlichem Bot verifiziert");
}
public void verify(CustomPlayer p) throws SQLException, ClassNotFoundException {
TS3Api api = getAPI();
if(hasVerified(p)) {
p.sendMessage("§cDu hast bereits einen verknüpften Account");
}else {
Client client = api.getClientByNameExact(p.getName(), false);
if(client != null) {
setRank(p, client);
return;
}
p.sendMessage("§cDu bist gerade nicht im TS online oder dein Nickname entspricht nicht dem IGN");
}
}
private Client getClient(CustomPlayer p) throws SQLException, ClassNotFoundException {
if(hasVerified(p)) {
int id = getTsId(p);
for (Client client : api.getClients()) {
if (client.getDatabaseId() == id) {
return client;
}
return null;
}
}
return null;
}
private CustomPlayer getPlayer(Client client) throws SQLException, ClassNotFoundException {
Player player = Bukkit.getPlayer(UUID.fromString(getUUID(client.getDatabaseId())));
return CustomPlayer.getPlayer(player);
}
public void checkVerifiyed(CustomPlayer p) throws SQLException, ClassNotFoundException {
if(hasVerified(p)) {
Client client = getClient(p);
if(client != null) {
//for(ServerGroup group : api.getServerGroupsByClient(client)) {
// if(group.getId() == getIdForRank(p.getRank())) {
// return;
// }
// setRank(p, client);
//}
}
}
}
public boolean hasVerified(CustomPlayer p) throws SQLException, ClassNotFoundException {
return getTsId(p) != 0;
}
/**
* gets group id for rank
* @param r Ranks
* @return Integer
*/
public int getIdForRank(Ranks r) {
switch(r) {
case Admin: return 10;
case Developer: return 13;
case SrModerator: return 60;
case Moderator: return 12;
case HeadBuilder: return 19;
case Builder: return 20;
case Supporter: return 14;
case Youtuber: return 21;
case Premium: return 22;
case Player: return 8;
default: return 0;
}
}
}

27
src/eu/univento/core/api/server/GameInfo.java
View File

@ -1,27 +0,0 @@
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;
}
}

122
src/eu/univento/core/api/server/MojangService.java
View File

@ -1,122 +0,0 @@
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;
}
}
}
}

51
src/eu/univento/core/api/server/ServerDatabase.java
View File

@ -1,51 +0,0 @@
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 {
public 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;
}
}
public 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;
}
}
}

46
src/eu/univento/core/api/server/ServerInfo.java
View File

@ -1,46 +0,0 @@
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 int getOnlinePlayers() {
return pinger.getPlayerCount();
}
public int getMaxPlayers() {
return pinger.getMaxPlayers();
}
public String getMotd() {
return pinger.getMotd();
}
}

164
src/eu/univento/core/api/server/ServerPinger.java
View File

@ -1,164 +0,0 @@
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.setPlayerCount(Integer.parseInt(data[4]));
this.setMaxPlayers(Integer.parseInt(data[5]));
}
else{
String[] data = string.split("§");
this.setMotd(data[0]);
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);
}
}
}

74
src/eu/univento/core/api/server/ServerSettings.java
View File

@ -1,74 +0,0 @@
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;
public static Game getPlayedGameGame() {
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;
}
}

44
src/eu/univento/core/api/server/Servers.java
View File

@ -1,44 +0,0 @@
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);
}
}

25
src/eu/univento/core/api/twitch/API.java
View File

@ -1,25 +0,0 @@
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();
}
}
}

43
src/eu/univento/core/api/twitch/Twitch_API.java
View File

@ -1,43 +0,0 @@
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;
}
}

380
src/eu/univento/core/api/twitch/Twitch_Stream.java
View File

@ -1,380 +0,0 @@
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;
}
}

37
src/eu/univento/core/api/utils/Direction.java
View File

@ -1,37 +0,0 @@
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;
}
}

228
src/eu/univento/core/api/utils/FDragon.java
View File

@ -1,228 +0,0 @@
package eu.univento.core.api.utils;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.entity.Player;
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;
/**
* @author mgone2010
*/
public class FDragon {
private static Constructor<?> packetPlayOutSpawnEntityLiving;
private static Constructor<?> entityEnderdragon;
private static Method setLocation;
private static Method setCustomName;
private static Method setHealth;
private static Method setInvisible;
private static Method getWorldHandle;
private static Method getPlayerHandle;
private static Field playerConnection;
private static Method sendPacket;
private static Method getDatawatcher;
private static Method a;
private static Field d;
public static Map<String, Object> playerDragons = new HashMap<String, Object>();
public static Map<String, String> playerTextDragon = new HashMap<String, String>();
static {
try {
packetPlayOutSpawnEntityLiving = getMCClass("PacketPlayOutSpawnEntityLiving").getConstructor(getMCClass("EntityLiving"));
entityEnderdragon = getMCClass("EntityEnderDragon").getConstructor(getMCClass("World"));
setLocation = getMCClass("EntityEnderDragon").getMethod("setLocation", double.class, double.class, double.class, float.class, float.class);
setCustomName = getMCClass("EntityEnderDragon").getMethod("setCustomName", new Class<?>[] { String.class });
setHealth = getMCClass("EntityEnderDragon").getMethod("setHealth", new Class<?>[] { float.class });
setInvisible = getMCClass("EntityEnderDragon").getMethod("setInvisible", new Class<?>[] { boolean.class });
getWorldHandle = getCraftClass("CraftWorld").getMethod("getHandle");
getPlayerHandle = getCraftClass("entity.CraftPlayer").getMethod("getHandle");
playerConnection = getMCClass("EntityPlayer").getDeclaredField("playerConnection");
sendPacket = getMCClass("PlayerConnection").getMethod("sendPacket", getMCClass("Packet"));
getDatawatcher = getMCClass("EntityEnderDragon").getMethod("getDataWatcher");
a = getMCClass("DataWatcher").getMethod("a", int.class, Object.class);
d = getMCClass("DataWatcher").getDeclaredField("d");
d.setAccessible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
public static Object getEnderDragon(Player p) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException {
if (FDragon.playerDragons.containsKey(p.getName())) {
return FDragon.playerDragons.get(p.getName());
} else {
Object nms_world = getWorldHandle.invoke(p.getWorld());
FDragon.playerDragons.put(p.getName(), entityEnderdragon.newInstance(nms_world));
return FDragon.getEnderDragon(p);
}
}
public static void setBossBartext(Player p, String text) {
playerTextDragon.put(p.getName(), text);
try {
Object nms_dragon = getEnderDragon(p);
//setLocation.invoke(nms_dragon, loc.getX(), 150, loc.getZ(), 0F, 0F);
setLocation.invoke(nms_dragon, getPlayerLoc(p).getX(), getPlayerLoc(p).getY()+800, getPlayerLoc(p).getZ(), 0F, 0F);
setCustomName.invoke(nms_dragon,text);
setHealth.invoke(nms_dragon,200);
setInvisible.invoke(nms_dragon,true);
changeWatcher(nms_dragon, text);
Object nms_packet = packetPlayOutSpawnEntityLiving.newInstance(nms_dragon);
Object nms_player = getPlayerHandle.invoke(p);
Object nms_connection = playerConnection.get(nms_player);
sendPacket.invoke(nms_connection, nms_packet);
} catch (Exception e) {
e.printStackTrace();
}
}
public static void setBossBar(Player p, String text, float vie) {
playerTextDragon.put(p.getName(), text);
try {
Object nms_dragon = getEnderDragon(p);
setLocation.invoke(nms_dragon, getPlayerLoc(p).getX(), getPlayerLoc(p).getY()+800, getPlayerLoc(p).getZ(), 0F, 0F);
setCustomName.invoke(nms_dragon,text);
setHealth.invoke(nms_dragon,vie);
setInvisible.invoke(nms_dragon,true);
changeWatcher(nms_dragon, text);
Object nms_packet = packetPlayOutSpawnEntityLiving.newInstance(nms_dragon);
Object nms_player = getPlayerHandle.invoke(p);
Object nms_connection = playerConnection.get(nms_player);
sendPacket.invoke(nms_connection, nms_packet);
} catch (Exception e) {
e.printStackTrace();
}
}
public static void removeBossBar(Player p){
playerTextDragon.remove(p.getName());
try {
Object nms_dragon = getEnderDragon(p);
setLocation.invoke(nms_dragon, p.getLocation().getX(), -5000, p.getLocation().getZ(), 0F, 0F);
setCustomName.invoke(nms_dragon," ");
setHealth.invoke(nms_dragon,0);
setInvisible.invoke(nms_dragon,true);
changeWatcher(nms_dragon, " ");
Object nms_packet = packetPlayOutSpawnEntityLiving.newInstance(nms_dragon);
Object nms_player = getPlayerHandle.invoke(p);
Object nms_connection = playerConnection.get(nms_player);
sendPacket.invoke(nms_connection, nms_packet);
} catch (Exception e) {
e.printStackTrace();
}
}
public static void removehorligneD(Player p) {
playerDragons.remove(p.getName());
playerTextDragon.remove(p.getName());
}
private static void changeWatcher(Object nms_entity, String text) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
Object nms_watcher = getDatawatcher.invoke(nms_entity);
Map<?, ?> map = (Map<?, ?>) d.get(nms_watcher);
map.remove(10);
a.invoke(nms_watcher, 10, text);
}
private static Class<?> getMCClass(String name) throws ClassNotFoundException {
String version = Bukkit.getServer().getClass().getPackage().getName().replace(".", ",").split(",")[3] + ".";
String className = "net.minecraft.server." + version + name;
return Class.forName(className);
}
private static Class<?> getCraftClass(String name) throws ClassNotFoundException {
String version = Bukkit.getServer().getClass().getPackage().getName().replace(".", ",").split(",")[3] + ".";
String className = "org.bukkit.craftbukkit." + version + name;
return Class.forName(className);
}
public static String getCardinalDirection(Player player) {
double rotation = (player.getLocation().getYaw() - 180) % 360;
if (rotation < 0) {
rotation += 360.0;
}
if (0 <= rotation && rotation < 22.5) {
return "N";
} else if (22.5 <= rotation && rotation < 67.5) {
return "NE";
} else if (67.5 <= rotation && rotation < 112.5) {
return "E";
} else if (112.5 <= rotation && rotation < 157.5) {
return "SE";
} else if (157.5 <= rotation && rotation < 202.5) {
return "S";
} else if (202.5 <= rotation && rotation < 247.5) {
return "SW";
} else if (247.5 <= rotation && rotation < 292.5) {
return "W";
} else if (292.5 <= rotation && rotation < 337.5) {
return "NW";
} else if (337.5 <= rotation && rotation < 360.0) {
return "N";
} else {
return null;
}
}
public static Location getPlayerLoc(Player p) {
Location loc = p.getLocation();
switch (getCardinalDirection(p)) {
case ("N") :
loc.add(0, 0, -150);
break;
case ("E") :
loc.add(150, 0, 0);
break;
case ("S") :
loc.add(0, 0, 150);
break;
case ("W") :
loc.add(-150, 0, 0);
break;
case ("NE") :
loc.add(150, 0, -150);
break;
case ("SE") :
loc.add(150, 0, 150);
break;
case ("NW") :
loc.add(-150, 0, -150);
break;
case ("SW") :
loc.add(-150, 0, 150);
break;
}
return loc;
}
}

289
src/eu/univento/core/api/utils/FWither.java
View File

@ -1,289 +0,0 @@
package eu.univento.core.api.utils;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.entity.Player;
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;
import java.util.concurrent.ThreadLocalRandom;
/**
* @author mgone2010
*/
public class FWither {
private static Constructor<?> packetPlayOutSpawnEntityLiving;
private static Constructor<?> entityEntityWither;
private static Method setLocation;
private static Method setCustomName;
private static Method setHealth;
private static Method setInvisible;
private static Method getWorldHandle;
private static Method getPlayerHandle;
private static Field playerConnection;
private static Method sendPacket;
private static Method getDatawatcher;
private static Method a;
private static Field d;
private static Map<String, Object> playerWithers = new HashMap<String, Object>();
private static Map<String, Object> playerWithers2 = new HashMap<String, Object>();
private static Map<String, String> playerTextWither = new HashMap<String, String>();
static {
try {
packetPlayOutSpawnEntityLiving = getMCClass("PacketPlayOutSpawnEntityLiving").getConstructor(getMCClass("EntityLiving"));
entityEntityWither = getMCClass("EntityWither").getConstructor(getMCClass("World"));
setLocation = getMCClass("EntityWither").getMethod("setLocation", double.class, double.class, double.class, float.class, float.class);
setCustomName = getMCClass("EntityWither").getMethod("setCustomName", new Class<?>[] { String.class });
setHealth = getMCClass("EntityWither").getMethod("setHealth", new Class<?>[] { float.class });
setInvisible = getMCClass("EntityWither").getMethod("setInvisible", new Class<?>[] { boolean.class });
getWorldHandle = getCraftClass("CraftWorld").getMethod("getHandle");
getPlayerHandle = getCraftClass("entity.CraftPlayer").getMethod("getHandle");
playerConnection = getMCClass("EntityPlayer").getDeclaredField("playerConnection");
sendPacket = getMCClass("PlayerConnection").getMethod("sendPacket", getMCClass("Packet"));
getDatawatcher = getMCClass("EntityWither").getMethod("getDataWatcher");
a = getMCClass("DataWatcher").getMethod("a", int.class, Object.class);
d = getMCClass("DataWatcher").getDeclaredField("d");
d.setAccessible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
public static Object getWither(Player p) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException {
if (playerWithers.containsKey(p.getName())) {
return playerWithers.get(p.getName());
} else {
Object nms_world = getWorldHandle.invoke(p.getWorld());
playerWithers.put(p.getName(), entityEntityWither.newInstance(nms_world));
return getWither(p);
}
}
public static Object getWither2(Player p) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException {
if (playerWithers2.containsKey(p.getName())) {
return playerWithers2.get(p.getName());
} else {
Object nms_world = getWorldHandle.invoke(p.getWorld());
playerWithers2.put(p.getName(), entityEntityWither.newInstance(nms_world));
return getWither2(p);
}
}
public static void setBossBartext(Player p, String text) {
playerTextWither.put(p.getName(), text);
int xr = ThreadLocalRandom.current().nextInt(-3,3);
int xr2 = ThreadLocalRandom.current().nextInt(-3,3);
try {
Object nms_wither = getWither(p);
setLocation.invoke(nms_wither, getPlayerLoc(p).getX()+xr, getPlayerLoc(p).getY()-3, getPlayerLoc(p).getZ()+xr2, 0F, 0F);
setCustomName.invoke(nms_wither,text);
setHealth.invoke(nms_wither,300);
setInvisible.invoke(nms_wither,true);
changeWatcher(nms_wither, text);
Object nms_packet = packetPlayOutSpawnEntityLiving.newInstance(nms_wither);
Object nms_player = getPlayerHandle.invoke(p);
Object nms_connection = playerConnection.get(nms_player);
sendPacket.invoke(nms_connection, nms_packet);
} catch (Exception e) {
e.printStackTrace();
}
/* try {
Object nms_wither = getWither2(p);
setLocation.invoke(nms_wither, getPlayerLoc(p).getX()+xr2, p.getLocation().getY()-10, getPlayerLoc(p).getZ()+xr, 0F, 0F);
setCustomName.invoke(nms_wither,text);
setHealth.invoke(nms_wither,300);
setInvisible.invoke(nms_wither,true);
changeWatcher(nms_wither, text);
Object nms_packet = packetPlayOutSpawnEntityLiving.newInstance(nms_wither);
Object nms_player = getPlayerHandle.invoke(p);
Object nms_connection = playerConnection.get(nms_player);
sendPacket.invoke(nms_connection, nms_packet);
} catch (Exception e) {
e.printStackTrace();
} */
}
public static void setBossBar(Player p, String text, float vie) {
playerTextWither.put(p.getName(), text);
int xr = ThreadLocalRandom.current().nextInt(0,2);
int xr2 = ThreadLocalRandom.current().nextInt(0,2);
try {
Object nms_wither = getWither(p);
setLocation.invoke(nms_wither, getPlayerLoc(p).getX()+xr, getPlayerLoc(p).getY()-3, getPlayerLoc(p).getZ()+xr2, 0F, 0F);
setCustomName.invoke(nms_wither,text);
setHealth.invoke(nms_wither,vie);
setInvisible.invoke(nms_wither,true);
changeWatcher(nms_wither, text);
Object nms_packet = packetPlayOutSpawnEntityLiving.newInstance(nms_wither);
Object nms_player = getPlayerHandle.invoke(p);
Object nms_connection = playerConnection.get(nms_player);
sendPacket.invoke(nms_connection, nms_packet);
} catch (Exception e) {
e.printStackTrace();
}
/* try {
Object nms_wither = getWither2(p);
setLocation.invoke(nms_wither, getPlayerLoc(p).getX()+xr2, p.getLocation().getY()-10, getPlayerLoc(p).getZ()+xr, 0F, 0F);
setCustomName.invoke(nms_wither,text);
setHealth.invoke(nms_wither,vie);
setInvisible.invoke(nms_wither,true);
changeWatcher(nms_wither, text);
Object nms_packet = packetPlayOutSpawnEntityLiving.newInstance(nms_wither);
Object nms_player = getPlayerHandle.invoke(p);
Object nms_connection = playerConnection.get(nms_player);
sendPacket.invoke(nms_connection, nms_packet);
} catch (Exception e) {
e.printStackTrace();
} */
}
public static void removeBossBar(Player p){
playerTextWither.remove(p.getName());
try {
Object nms_wither = getWither(p);
setLocation.invoke(nms_wither, p.getLocation().getX(), -5000, p.getLocation().getZ(), 0F, 0F);
setCustomName.invoke(nms_wither," ");
setHealth.invoke(nms_wither,0);
setInvisible.invoke(nms_wither,true);
changeWatcher(nms_wither, " ");
Object nms_packet = packetPlayOutSpawnEntityLiving.newInstance(nms_wither);
Object nms_player = getPlayerHandle.invoke(p);
Object nms_connection = playerConnection.get(nms_player);
sendPacket.invoke(nms_connection, nms_packet);
} catch (Exception e) {
e.printStackTrace();
}
}
public static void removehorligneW(Player p) {
playerWithers.remove(p.getName());
playerTextWither.remove(p.getName());
}
private static void changeWatcher(Object nms_entity, String text) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
Object nms_watcher = getDatawatcher.invoke(nms_entity);
Map<?, ?> map = (Map<?, ?>) d.get(nms_watcher);
map.remove(10);
a.invoke(nms_watcher, 10, text);
}
private static Class<?> getMCClass(String name) throws ClassNotFoundException {
String version = Bukkit.getServer().getClass().getPackage().getName().replace(".", ",").split(",")[3] + ".";
String className = "net.minecraft.server." + version + name;
return Class.forName(className);
}
private static Class<?> getCraftClass(String name) throws ClassNotFoundException {
String version = Bukkit.getServer().getClass().getPackage().getName().replace(".", ",").split(",")[3] + ".";
String className = "org.bukkit.craftbukkit." + version + name;
return Class.forName(className);
}
public static String getCardinalDirection(Player player) {
double rotation = (player.getLocation().getYaw() - 180) % 360;
if (rotation < 0) {
rotation += 360.0;
}
if (0 <= rotation && rotation < 22.5) {
return "N";
} else if (22.5 <= rotation && rotation < 67.5) {
return "NE";
} else if (67.5 <= rotation && rotation < 112.5) {
return "E";
} else if (112.5 <= rotation && rotation < 157.5) {
return "SE";
} else if (157.5 <= rotation && rotation < 202.5) {
return "S";
} else if (202.5 <= rotation && rotation < 247.5) {
return "SW";
} else if (247.5 <= rotation && rotation < 292.5) {
return "W";
} else if (292.5 <= rotation && rotation < 337.5) {
return "NW";
} else if (337.5 <= rotation && rotation <= 360.0) {
return "N";
} else {
return "N";
}
}
public static Location getPlayerLoc(Player p) {
Location loc = p.getLocation();
switch (getCardinalDirection(p)) {
case ("N") :
loc.add(0, 0, -50);
break;
case ("E") :
loc.add(50, 0, 0);
break;
case ("S") :
loc.add(0, 0, 50);
break;
case ("W") :
loc.add(-50, 0, 0);
break;
case ("NE") :
loc.add(50, 0, -50);
break;
case ("SE") :
loc.add(50, 0, 50);
break;
case ("NW") :
loc.add(-50, 0, -50);
break;
case ("SW") :
loc.add(-50, 0, 50);
break;
}
return loc;
}
}

171
src/eu/univento/core/api/utils/GameProfileBuilder.java
View File

@ -1,171 +0,0 @@
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;
}
}
}

281
src/eu/univento/core/api/utils/Maths.java
View File

@ -1,281 +0,0 @@
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);
}
}
}

49
src/eu/univento/core/api/utils/NameFetcher.java
View File

@ -1,49 +0,0 @@
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;
}
}

41
src/eu/univento/core/api/utils/RandomCollection.java
View File

@ -1,41 +0,0 @@
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();
}
}

45
src/eu/univento/core/api/utils/Vectors.java
View File

@ -1,45 +0,0 @@
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());
}
}

256
src/eu/univento/core/api/utils/reflection/IReflection.java
View File

@ -1,256 +0,0 @@
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 + ".";
}
}
}

141
src/eu/univento/core/api/utils/reflection/Reflection.java
View File

@ -1,141 +0,0 @@
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;
}
}

119
src/eu/univento/core/api/youtube/YTAPI.java
View File

@ -1,119 +0,0 @@
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);
}
}

242
src/eu/univento/core/api/youtube/YoutubeChannel.java
View File

@ -1,242 +0,0 @@
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() + ")";
}
}

116
src/eu/univento/core/commands/Ban.java
View File

@ -1,116 +0,0 @@
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;
}
}

82
src/eu/univento/core/commands/Build.java
View File

@ -1,82 +0,0 @@
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;
}
}

53
src/eu/univento/core/commands/ChatClear.java
View File

@ -1,53 +0,0 @@
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;
}
}

73
src/eu/univento/core/commands/Fix.java
View File

@ -1,73 +0,0 @@
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) {
List<String> list = Bukkit.getOnlinePlayers().stream().map(Player::getDisplayName).collect(Collectors.toList());
return list;
}
}

87
src/eu/univento/core/commands/GameMode.java
View File

@ -1,87 +0,0 @@
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;
}
}
}

58
src/eu/univento/core/commands/GlobalMute.java
View File

@ -1,58 +0,0 @@
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;
}
}

70
src/eu/univento/core/commands/RunAs.java
View File

@ -1,70 +0,0 @@
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());
}
}

103
src/eu/univento/core/commands/SetRank.java
View File

@ -1,103 +0,0 @@
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());
Messages msgs = new Messages(p);
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]).getName());
if(p.isAllowed(Ranks.HeadBuilder) && rank == Ranks.Builder) {
player.setRank(rank);
p.sendMessage(msgs.PREFIX() + msgs.Core_SETRANK_SET(player, player.getRank()));
player.kickPlayer(msgs.Core_SETRANK_KICK());
}if(p.isAllowed(Ranks.SrModerator) && rank == Ranks.Moderator) {
player.setRank(rank);
p.sendMessage(msgs.PREFIX() + msgs.Core_SETRANK_SET(player, player.getRank()));
player.kickPlayer(msgs.Core_SETRANK_KICK());
}if(p.isAllowed(Ranks.SrModerator) && rank == Ranks.Supporter) {
player.setRank(rank);
p.sendMessage(msgs.PREFIX() + msgs.Core_SETRANK_SET(player, player.getRank()));
player.kickPlayer(msgs.Core_SETRANK_KICK());
}if(p.isAllowed(Ranks.SrDeveloper) && rank == Ranks.Developer) {
player.setRank(rank);
p.sendMessage(msgs.PREFIX() + msgs.Core_SETRANK_SET(player, player.getRank()));
player.kickPlayer(msgs.Core_SETRANK_KICK());
}
if(p.isAllowed(Ranks.Admin)) {
player.setRank(rank);
p.sendMessage(msgs.PREFIX() + msgs.Core_SETRANK_SET(player, player.getRank()));
player.kickPlayer(msgs.Core_SETRANK_KICK());
}
}else {
p.sendMessage(msgs.NOT_ONLINE(args[0]));
}
}else {
p.sendMessage(msgs.Core_SETRANK_NO_RANK());
}
}else {
p.sendMessage(msgs.Core_SETRANK_NO_RANK());
}
}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 = 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;
}
}

61
src/eu/univento/core/commands/SystemInfo.java
View File

@ -1,61 +0,0 @@
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;
}
}

42
src/eu/univento/core/commands/TS.java
View File

@ -1,42 +0,0 @@
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.verifyTs();
}
return true;
}
@Override
public List<String> tabComplete(CommandSender sender, String label, String[] args) {
return null;
}
}

65
src/eu/univento/core/commands/Twitch.java
View File

@ -1,65 +0,0 @@
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;
}
}

77
src/eu/univento/core/commands/Vanish.java
View File

@ -1,77 +0,0 @@
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;
}
}

63
src/eu/univento/core/commands/Youtuber.java
View File

@ -1,63 +0,0 @@
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.youtube.YTAPI;
import eu.univento.core.api.youtube.YoutubeChannel;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.List;
/**
* sets player to youtube rank
* @author joethei
* @version 1.0
*/
public class Youtuber extends AutoCommand<Core>{
/**
* @param plugin main class
* @param command command to execute
* @param description describes the command
* @param aliases aliases of command
*/
public Youtuber(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) {
YoutubeChannel yt = YTAPI.getYTChannelFromName(args[0]);
if(yt != null) {
p.sendMessage("§aBenutzername: " + yt.getUsername());
p.sendMessage("§aGooglePlus ID: " + yt.getGoogleplusid());
p.sendMessage("§aZuletzt online: " + yt.getLastwebaccess());
p.sendMessage("§aVon: " + yt.getLocation());
p.sendMessage("§aAbos: " + yt.getSubscribers());
p.sendMessage("§aVideo Watch Count: " + yt.getVideoWatchCount());
p.sendMessage("§aViewcount: " + yt.getViewcount());
}else {
p.sendMessage(msgs.PREFIX() + "§cDer Youtube Kanal exsistiert nicht");
}
}else {
p.sendMessage(msgs.PREFIX() + "§cBenutze doch /youtuber <Channel Name>");
}
}else {
sender.sendMessage(Messages.Console.NOT_A_PLAYER);
}
return true;
}
@Override
public List<String> tabComplete(CommandSender sender, String label, String[] args) {
return null;
}
}

53
src/eu/univento/core/listeners/Blocks.java
View File

@ -1,53 +0,0 @@
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);
}
}

46
src/eu/univento/core/listeners/Chat.java
View File

@ -1,46 +0,0 @@
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();
}
e.setFormat(format);
}
}

61
src/eu/univento/core/listeners/Commands.java
View File

@ -1,61 +0,0 @@
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());
}
}
}
}

194
src/eu/univento/core/listeners/JoinQuit.java
View File

@ -1,194 +0,0 @@
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 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);
p.setScoreboard(Bukkit.getScoreboardManager().getNewScoreboard());
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.isNicked()) {
p.setDisplayName(p.getNick());
}
if(!p.isSetting("joined")) {
p.changeSetting("joined");
}
if(!p.hasPlayedBefore()) {
createPlayer(p);
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)), 140L);
}
Perms.getRanks().put(p, p.getFreshRank());
Perms.initScoreboard(p);
Title.sendTabTitle(p, msgs.Core_TAB_TITLE() + Bukkit.getServerName() , msgs.PREFIX());
p.setGameMode(ServerSettings.getGameMode());
p.checkVerifiedTs();
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());
NickName.remove(p);
if(Build.getPlayers().containsKey(p))
Build.getPlayers().remove(p);
if(!ServerSettings.isGame())
p.getTeam().removeEntry(p.getDisplayName());
if(ServerSettings.isGame())
p.setNicked(false);
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);
}
public 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("§6Italienisch");
it.setItemMeta(itMeta);
inv.setItem(0, en);
inv.setItem(1, de);
inv.setItem(2, it);
return inv;
}
}

43
src/main/java/eu/univento/core/api/database/MongoDB.java Normal file
View File

@ -0,0 +1,43 @@
package eu.univento.core.api.database;
import com.mongodb.MongoClient;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
import com.mongodb.client.MongoDatabase;
import eu.univento.core.api.Config;
import java.util.Arrays;
public class MongoDB {
private MongoClient client;
private MongoDatabase database;
public MongoClient getClient() {
if(client == null)
new MongoDB(Config.readString("MongoDB.Host"), Config.readInt("MongoDB.Port"), Config.readString("MongoDB.Username"), Config.readString("MongoDB.Password"), Config.readString("MongoDB.Database"));
return client;
}
public MongoDB(String host, int port, String username, String password, String database) {
MongoCredential credential = MongoCredential.createCredential(username, database, password.toCharArray());
client = new MongoClient(new ServerAddress(host, port), Arrays.asList(credential));
}
public MongoDatabase getDatabase() {
if(database == null) {
database = getClient().getDatabase(Config.readString("MongoDB.Database"));
}return database;
}
public void setDatabase(String database) {
this.database = getClient().getDatabase(database);
}
public void closeConnection() {
if(client != null) {
client.close();
}
}
}

59
src/main/java/eu/univento/core/api/game/Team.java Normal file
View File

@ -0,0 +1,59 @@
package eu.univento.core.api.game;
import eu.univento.core.api.player.CustomPlayer;
import org.bukkit.Bukkit;
import java.util.ArrayList;
/**
* @author joethei
* @version 0.1
*/
public class Team {
private ArrayList<CustomPlayer> players = new ArrayList<>();
private String name;
private String prefix;
private org.bukkit.scoreboard.Team team;
public Team(String name, String prefix) {
this.name = name;
this.prefix = prefix;
if(Bukkit.getScoreboardManager().getMainScoreboard().getTeam(name) == null) {
team = Bukkit.getScoreboardManager().getMainScoreboard().registerNewTeam(name);
}else{
team = Bukkit.getScoreboardManager().getMainScoreboard().getTeam(name);
}
team.setPrefix(prefix);
}
public void addPlayer(CustomPlayer p) {
players.add(p);
team.addEntry(p.getName());
}
public void removePlayer(CustomPlayer p) {
players.remove(p);
team.removeEntry(p.getName());
}
public boolean isPlayer(CustomPlayer p) {
return players.contains(p);
}
public String getName() {
return name;
}
public String getPrefix() {
return prefix;
}
public ArrayList<CustomPlayer> getPlayers() {
return players;
}
public org.bukkit.scoreboard.Team getScoreboardTeam() {
return team;
}
}

41
src/main/java/eu/univento/core/api/game/TeamManager.java Normal file
View File

@ -0,0 +1,41 @@
package eu.univento.core.api.game;
import eu.univento.core.api.player.CustomPlayer;
import java.util.ArrayList;
/**
* @author joethei
* @version 0.1
*/
public class TeamManager {
private static ArrayList<Team> teams = new ArrayList<>();
public static ArrayList<Team> getTeams() {
return teams;
}
public static Team getTeam(String name) {
for(Team team : teams) {
if(team.getName().equalsIgnoreCase(name)) return team;
}
return null;
}
public static Team getTeam(CustomPlayer p) {
for(Team team : teams) {
if(team.isPlayer(p)) return team;
}
return null;
}
public static void addTeam(Team team) {
teams.add(team);
}
public static void removeTeam(Team team) {
teams.remove(team);
}
}

30
src/main/java/eu/univento/core/api/gui/PlayerSignInputEvent.java Normal file
View File

@ -0,0 +1,30 @@
package eu.univento.core.api.gui;
import org.bukkit.entity.Player;
import org.bukkit.event.HandlerList;
import org.bukkit.event.player.PlayerEvent;
/**
* @author joethei
* @version 0.1
*/
public class PlayerSignInputEvent extends PlayerEvent{
public static HandlerList handlerList = new HandlerList();
public String[] lines;
public PlayerSignInputEvent(Player p, String[] lines) {
super(p);
this.lines = lines;
SignInputHandler.ejectNetty(p);
}
@Override
public HandlerList getHandlers() {
return handlerList;
}
public String[] getLines() {
return lines;
}
}

21
src/main/java/eu/univento/core/api/gui/SignInput.java Normal file
View File

@ -0,0 +1,21 @@
package eu.univento.core.api.gui;
import eu.univento.core.api.player.CustomPlayer;
import net.minecraft.server.v1_9_R1.BlockPosition;
import net.minecraft.server.v1_9_R1.EntityPlayer;
import net.minecraft.server.v1_9_R1.PacketPlayOutOpenSignEditor;
/**
* @author joethei
* @version 0.1
*/
public class SignInput {
public static void openSignInput(CustomPlayer p) {
EntityPlayer player = p.getHandle();
BlockPosition bp = new BlockPosition(p.getHandle());
PacketPlayOutOpenSignEditor packet = new PacketPlayOutOpenSignEditor(bp);
player.playerConnection.sendPacket(packet);
SignInputHandler.injectNetty(p);
}
}

67
src/main/java/eu/univento/core/api/gui/SignInputHandler.java Normal file
View File

@ -0,0 +1,67 @@
package eu.univento.core.api.gui;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToMessageDecoder;
import net.minecraft.server.v1_9_R1.NetworkManager;
import net.minecraft.server.v1_9_R1.Packet;
import net.minecraft.server.v1_9_R1.PacketPlayInUpdateSign;
import org.bukkit.Bukkit;
import org.bukkit.craftbukkit.v1_9_R1.entity.CraftPlayer;
import org.bukkit.entity.Player;
import java.lang.reflect.Field;
import java.util.List;
/**
* @author joethei
* @version 0.1
*/
public class SignInputHandler {
private static Field channelField;
static{
for(Field filed : NetworkManager.class.getDeclaredFields()) {
if(channelField.getType().isAssignableFrom(Channel.class)) {
channelField = filed;
break;
}
}
}
public static void injectNetty(final Player player) {
try {
Channel channel = (Channel) channelField.get(((CraftPlayer) player).getHandle().playerConnection.networkManager);
if (channel != null) {
channel.pipeline().addAfter("decoder", "update_sign", new MessageToMessageDecoder<Packet>() {
@Override
protected void decode(ChannelHandlerContext chc, Packet packet, List<Object> out) throws Exception {
if (packet instanceof PacketPlayInUpdateSign) {
PacketPlayInUpdateSign usePacket = (PacketPlayInUpdateSign) packet;
Bukkit.getPluginManager().callEvent(new PlayerSignInputEvent(player, usePacket.b()));
}
out.add(packet);
}
});
}
} catch (Exception e) {
e.printStackTrace();
}
}
public static void ejectNetty(Player player) {
try {
Channel channel = (Channel) channelField.get(((CraftPlayer) player).getHandle().playerConnection.networkManager);
if (channel != null) {
if (channel.pipeline().get("update_sign") != null) {
channel.pipeline().remove("update_sign");
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}

194
src/main/java/eu/univento/core/api/map/Cuboid.java Normal file
View File

@ -0,0 +1,194 @@
package eu.univento.core.api.map;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.configuration.serialization.ConfigurationSerializable;
import org.bukkit.util.Vector;
import java.util.*;
/**
* @author desht (Original code), KingFaris10 (Editor of code)
* @version 0.1
*/
public class Cuboid implements Cloneable, ConfigurationSerializable, Iterable<Block> {
protected String worldName;
protected final Vector minimumPoint, maximumPoint;
public Cuboid(Cuboid cuboid) {
this(cuboid.worldName, cuboid.minimumPoint.getX(), cuboid.minimumPoint.getY(), cuboid.minimumPoint.getZ(), cuboid.maximumPoint.getX(), cuboid.maximumPoint.getY(), cuboid.maximumPoint.getZ());
}
public Cuboid(Location loc) {
this(loc, loc);
}
public Cuboid(Location loc1, Location loc2) {
if (loc1 != null && loc2 != null) {
if (loc1.getWorld() != null && loc2.getWorld() != null) {
if (!loc1.getWorld().getUID().equals(loc2.getWorld().getUID()))
throw new IllegalStateException("The 2 locations of the cuboid must be in the same world!");
} else {
throw new NullPointerException("One/both of the worlds is/are null!");
}
this.worldName = loc1.getWorld().getName();
double xPos1 = Math.min(loc1.getX(), loc2.getX());
double yPos1 = Math.min(loc1.getY(), loc2.getY());
double zPos1 = Math.min(loc1.getZ(), loc2.getZ());
double xPos2 = Math.max(loc1.getX(), loc2.getX());
double yPos2 = Math.max(loc1.getY(), loc2.getY());
double zPos2 = Math.max(loc1.getZ(), loc2.getZ());
this.minimumPoint = new Vector(xPos1, yPos1, zPos1);
this.maximumPoint = new Vector(xPos2, yPos2, zPos2);
} else {
throw new NullPointerException("One/both of the locations is/are null!");
}
}
public Cuboid(String worldName, double x1, double y1, double z1, double x2, double y2, double z2) {
if (worldName == null || Bukkit.getServer().getWorld(worldName) == null)
throw new NullPointerException("One/both of the worlds is/are null!");
this.worldName = worldName;
double xPos1 = Math.min(x1, x2);
double xPos2 = Math.max(x1, x2);
double yPos1 = Math.min(y1, y2);
double yPos2 = Math.max(y1, y2);
double zPos1 = Math.min(z1, z2);
double zPos2 = Math.max(z1, z2);
this.minimumPoint = new Vector(xPos1, yPos1, zPos1);
this.maximumPoint = new Vector(xPos2, yPos2, zPos2);
}
public boolean containsLocation(Location location) {
return location != null && location.getWorld().getName().equals(this.worldName) && location.toVector().isInAABB(this.minimumPoint, this.maximumPoint);
}
public boolean containsVector(Vector vector) {
return vector != null && vector.isInAABB(this.minimumPoint, this.maximumPoint);
}
public List<Block> getBlocks() {
List<Block> blockList = new ArrayList<>();
World world = this.getWorld();
if (world != null) {
for (int x = this.minimumPoint.getBlockX(); x <= this.maximumPoint.getBlockX(); x++) {
for (int y = this.minimumPoint.getBlockY(); y <= this.maximumPoint.getBlockY() && y <= world.getMaxHeight(); y++) {
for (int z = this.minimumPoint.getBlockZ(); z <= this.maximumPoint.getBlockZ(); z++) {
blockList.add(world.getBlockAt(x, y, z));
}
}
}
}
return blockList;
}
public Location getLowerLocation() {
return this.minimumPoint.toLocation(this.getWorld());
}
public double getLowerX() {
return this.minimumPoint.getX();
}
public double getLowerY() {
return this.minimumPoint.getY();
}
public double getLowerZ() {
return this.minimumPoint.getZ();
}
public Location getUpperLocation() {
return this.maximumPoint.toLocation(this.getWorld());
}
public double getUpperX() {
return this.maximumPoint.getX();
}
public double getUpperY() {
return this.maximumPoint.getY();
}
public double getUpperZ() {
return this.maximumPoint.getZ();
}
public double getVolume() {
return (this.getUpperX() - this.getLowerX() + 1) * (this.getUpperY() - this.getLowerY() + 1) * (this.getUpperZ() - this.getLowerZ() + 1);
}
public World getWorld() {
World world = Bukkit.getServer().getWorld(this.worldName);
if (world == null) throw new NullPointerException("World '" + this.worldName + "' is not loaded.");
return world;
}
public void setWorld(World world) {
if (world != null) this.worldName = world.getName();
else throw new NullPointerException("The world cannot be null.");
}
public Location getRandomLocation() {
Random randomX = new Random();
Random randomY = new Random();
double x = getLowerX() + (getUpperX() - getLowerX()) * randomX.nextDouble();
double z = getLowerZ() + (getUpperZ() - getLowerZ()) * randomY.nextDouble();
int y = getWorld().getHighestBlockYAt(new Location(getWorld(), x, 0, z));
Location loc = new Location(getWorld(), x, y, z);
if(loc.getBlock().getType() == Material.GRASS || loc.getBlock().getType() == Material.SNOW_BLOCK) return getRandomLocation();
return loc;
}
@Override
public Cuboid clone() {
return new Cuboid(this);
}
@Override
public ListIterator<Block> iterator() {
return this.getBlocks().listIterator();
}
@Override
public HashMap<String, Object> serialize() {
HashMap<String, Object> serializedCuboid = new HashMap<>();
serializedCuboid.put("worldName", this.worldName);
serializedCuboid.put("x1", this.minimumPoint.getX());
serializedCuboid.put("x2", this.maximumPoint.getX());
serializedCuboid.put("y1", this.minimumPoint.getY());
serializedCuboid.put("y2", this.maximumPoint.getY());
serializedCuboid.put("z1", this.minimumPoint.getZ());
serializedCuboid.put("z2", this.maximumPoint.getZ());
return serializedCuboid;
}
public static Cuboid deserialize(HashMap<String, Object> serializedCuboid) {
try {
String worldName = (String) serializedCuboid.get("worldName");
double xPos1 = (Double) serializedCuboid.get("x1");
double xPos2 = (Double) serializedCuboid.get("x2");
double yPos1 = (Double) serializedCuboid.get("y1");
double yPos2 = (Double) serializedCuboid.get("y2");
double zPos1 = (Double) serializedCuboid.get("z1");
double zPos2 = (Double) serializedCuboid.get("z2");
return new Cuboid(worldName, xPos1, yPos1, zPos1, xPos2, yPos2, zPos2);
} catch (Exception ex) {
ex.printStackTrace();
return null;
}
}
}

32
src/main/java/eu/univento/core/api/map/Map.java Normal file
View File

@ -0,0 +1,32 @@
package eu.univento.core.api.map;
import org.bukkit.Material;
/**
* @author joethei
* @version 0.1
*/
public class Map {
private String name;
private String builder;
private Material item;
public Map(String name, String builder, Material item) {
this.name = name;
this.builder = builder;
this.item = item;
}
public String getName() {
return name;
}
public String getBuilder() {
return builder;
}
public Material getItem() {
return item;
}
}

24
src/main/java/eu/univento/core/api/map/MapDatabase.java Normal file
View File

@ -0,0 +1,24 @@
package eu.univento.core.api.map;
import eu.univento.core.api.server.Game;
import org.bukkit.Material;
import java.util.ArrayList;
/**
* @author joethei
* @version 0.1
*/
public class MapDatabase {
//TODO: add real map database
public static ArrayList<Map> getAllMaps(Game game) {
ArrayList<Map> maps = new ArrayList<>();
maps.add(new Map("Map1", "TeamVento", Material.GRASS));
maps.add(new Map("Map2", "TeamVento", Material.STONE));
maps.add(new Map("Map3", "TeamVento", Material.APPLE));
return maps;
}
}

193
src/main/java/eu/univento/core/api/map/MapVoting.java Normal file
View File

@ -0,0 +1,193 @@
package eu.univento.core.api.map;
import eu.univento.core.api.player.CustomPlayer;
import eu.univento.core.api.player.Perms;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.plugin.Plugin;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;
/**
* @author joethei
* @version 0.1
*/
public class MapVoting implements Listener{
private Map map1;
private Map map2;
private Map map3;
private String invTitle;
private ArrayList<CustomPlayer> votes1 = new ArrayList<>();
private ArrayList<CustomPlayer> votes2 = new ArrayList<>();
private ArrayList<CustomPlayer> votes3 = new ArrayList<>();
private Map forcedMap;
private ArrayList<Map> allMaps = new ArrayList<>();
public MapVoting(String invTitle) {
this.invTitle = invTitle;
}
public void vote(CustomPlayer p, Integer map) {
switch (map) {
case 1 : votes1.add(p);
case 2 : votes2.add(p);
case 3 : votes3.add(p);
}
}
public int getVotes(Integer map) {
switch (map) {
case 1 : return votes1.size();
case 2 : return votes2.size();
case 3 : return votes3.size();
default: return 0;
}
}
public Map getForcedMap() {
return forcedMap;
}
public Map getWinningMap() {
if(forcedMap != null) {
return forcedMap;
}
ArrayList<Integer> votes = new ArrayList<>();
votes.add(votes1.size());
votes.add(votes2.size());
votes.add(votes3.size());
int max = Collections.max(votes);
return getMap(getMapID(max));
}
public Map getMap(int id) {
switch (id) {
case 1: return map1;
case 2: return map2;
case 3: return map3;
default: return null;
}
}
public int getMapID(int votes) {
if(votes == votes1.size()) {
return 1;
}
if(votes == votes2.size()) {
return 2;
}
if(votes == votes3.size()) {
return 3;
}
return 0;
}
public void setVotingMaps() {
ArrayList<Map> temp = allMaps;
Random random = new Random();
map1 = allMaps.get(random.nextInt(temp.size()));
temp.remove(map1);
map2 = allMaps.get(random.nextInt(temp.size()));
temp.remove(map2);
map3 = allMaps.get(random.nextInt(temp.size()));
temp.remove(map3);
}
public void addMap(Map map) {
allMaps.add(map);
}
public Inventory getInventory(CustomPlayer p) {
if(p.isAllowed(Perms.Ranks.Admin)) {
Inventory inv = Bukkit.createInventory(p, 45, invTitle);
for(Map map : allMaps) {
ItemStack item = new ItemStack(map.getItem());
ItemMeta meta = item.getItemMeta();
meta.setDisplayName(map.getName());
ArrayList<String> lore = new ArrayList<>();
lore.add("§aby " + map.getBuilder());
meta.setLore(lore);
inv.addItem(item);
}
return inv;
}else{
Inventory inv = Bukkit.createInventory(p, 9, invTitle);
ItemStack map1 = new ItemStack(this.map1.getItem());
ItemMeta map1Meta = map1.getItemMeta();
map1Meta.setDisplayName(this.map1.getName());
ArrayList<String> map1Lore = new ArrayList<>();
map1Lore.add("§aby " + this.map1.getBuilder());
map1Meta.setLore(map1Lore);
map1.setItemMeta(map1Meta);
ItemStack map2 = new ItemStack(this.map2.getItem());
ItemMeta map2Meta = map2.getItemMeta();
map2Meta.setDisplayName(this.map2.getName());
ArrayList<String> map2Lore = new ArrayList<>();
map2Lore.add("§aby " + this.map2.getBuilder());
map2Meta.setLore(map2Lore);
map2.setItemMeta(map2Meta);
ItemStack map3 = new ItemStack(this.map3.getItem());
ItemMeta map3Meta = map3.getItemMeta();
map3Meta.setDisplayName(this.map3.getName());
ArrayList<String> map3Lore = new ArrayList<>();
map3Lore.add("§aby " + this.map3.getBuilder());
map3Meta.setLore(map3Lore);
map3.setItemMeta(map3Meta);
inv.setItem(1, map1);
inv.setItem(4, map2);
inv.setItem(7, map3);
return inv;
}
}
@EventHandler
public void onInventoryClick(InventoryClickEvent e) {
if(e.getWhoClicked() instanceof Player) {
CustomPlayer p = CustomPlayer.getPlayer(e.getWhoClicked().getName());
if(e.getInventory().getName().equals(invTitle)) {
if(p.isAllowed(Perms.Ranks.Admin)) {
allMaps.stream().filter(map -> e.getCurrentItem().getType() == map.getItem()).forEach(map -> {
forcedMap = map;
});
}else{
if(e.getCurrentItem().getType() == map1.getItem()) {
vote(p, 1);
p.closeInventory();
}
if(e.getCurrentItem().getType() == map2.getItem()) {
vote(p, 2);
p.closeInventory();
}
if(e.getCurrentItem().getType() == map3.getItem()) {
vote(p, 3);
p.closeInventory();
}
}
}
}
}
public void registerListener(Plugin plugin) {
plugin.getServer().getPluginManager().registerEvents(this, plugin);
}
}

73
src/main/java/eu/univento/core/api/player/Skin.java Normal file
View File

@ -0,0 +1,73 @@
package eu.univento.core.api.player;
import eu.univento.core.Core;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import java.net.URL;
import java.net.URLConnection;
import java.util.Scanner;
import java.util.logging.Level;
/**
* @author joethei
* @version 1.0
*/
public class Skin {
String uuid;
String name;
String value;
String signature;
public Skin(final String uuid) {
this.uuid = uuid;
this.load();
}
private void load() {
try {
URL url = new URL("https://sessionserver.mojang.com/session/minecraft/profile/" + this.uuid + "?unsigned=false");
URLConnection uc = url.openConnection();
uc.setUseCaches(false);
uc.setDefaultUseCaches(false);
uc.addRequestProperty("User-Agent", "Mozilla/5.0");
uc.addRequestProperty("Cache-Control", "no-cache, no-store, must-revalidate");
uc.addRequestProperty("Pragma", "no-cache");
String json = new Scanner(uc.getInputStream(), "UTF-8").useDelimiter("\\A").next();
JSONParser parser = new JSONParser();
Object obj = parser.parse(json);
JSONArray properties = (JSONArray)((JSONObject)obj).get("properties");
for (int i = 0; i < properties.size(); ++i) {
try {
JSONObject property = (JSONObject)properties.get(i);
String name = (String)property.get("name");
String value = (String)property.get("value");
String signature = property.containsKey("signature") ? ((String)property.get("signature")) : null;
this.name = name;
this.value = value;
this.signature = signature;
}
catch (Exception e) {
Core.log(Level.WARNING, "Failed to apply auth property");
e.printStackTrace();
}
}
}
catch (Exception ex) {}
}
public String getValue() {
return this.value;
}
public String getName() {
return this.name;
}
public String getSignature() {
return this.signature;
}
}

71
src/main/java/eu/univento/core/commands/Stats.java Normal file
View File

@ -0,0 +1,71 @@
/*
* Copyright (c) univento.eu 2016. Any attempt to use these program(s) without permission may result in a penalty of up to 1.000€
*/
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.server.Game;
import eu.univento.core.api.server.ServerSettings;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.List;
/**
* @author joethei
* @version 0.1
*/
public class Stats extends AutoCommand<Core> {
public Stats(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());
Game game = ServerSettings.getPlayedGame();
if(args.length == 0) {
p.sendMessage("§aDeine " + game.toString() + " Statistiken");
p.sendMessage("Tötungen: " + p.getStatistics(game).getKills());
p.sendMessage("Tode: " + p.getStatistics(game).getDeaths());
p.sendMessage("Gewinne: " + p.getStatistics(game).getWins());
p.sendMessage("Gespielte Runden: " + p.getStatistics(game).getPlayedRounds());
p.sendMessage("Spielzeit: " + p.getStatistics(game).getPlaytime());
}
if(args.length == 1) {
if(ServerSettings.getGameState().equals("Lobby") || ServerSettings.getGameState().equals("Restart")) {
if(Bukkit.getPlayer(args[0]) != null) {
CustomPlayer t = CustomPlayer.getPlayer(args[0]);
p.sendMessage("§a" + game.toString() + " Statistiken von " + t.getDisplayName());
p.sendMessage("Tötungen: " + t.getStatistics(game).getKills());
p.sendMessage("Tode: " + t.getStatistics(game).getDeaths());
p.sendMessage("Gewinne: " + t.getStatistics(game).getWins());
p.sendMessage("Gespielte Runden: " + t.getStatistics(game).getPlayedRounds());
p.sendMessage("Spielzeit: " + t.getStatistics(game).getPlaytime());
}else{
p.sendMessage(p.getMessages().PREFIX() + p.getMessages().NOT_ONLINE(args[0]));
}
}else{
p.sendMessage(p.getMessages().PREFIX() + " §cDu kannst dir im Moment keine Statistiken von anderen Spielern anschauen");
}
}else{
}
}else{
sender.sendMessage(Messages.Console.NOT_A_PLAYER);
}
return true;
}
@Override
public List<String> tabComplete(CommandSender sender, String label, String[] args) {
return null;
}
}

10
src/plugin.yml → src/main/resources/plugin.yml
View File

@ -1,6 +1,6 @@
main: eu.univento.core.Core
name: Core
description: univento Core
author: joethei
version: 0.6
main: eu.univento.core.Core
name: Core
description: univento Core
author: joethei
version: 0.6
website: http://univento.eu