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

development mit master zusammengeführt

This commit is contained in:
Johannes Theiner 2016-04-13 05:55:33 +02:00
parent 6a9df37421 234dec0439
commit 0304f59ef6
103 changed files with 8901 additions and 6267 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
Core.iml Normal file
View File

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

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>

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();
}
}

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;
}
}

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;
}
}

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;
}
}

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);
}
}

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;
}
}
}

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;
}
}

0
src/eu/univento/cloud/client/CloudClient.java → src/main/java/eu/univento/cloud/client/CloudClient.java
View File

135
src/main/java/eu/univento/core/Core.java Normal file
View File

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

10
src/eu/univento/core/api/Actionbar.java → src/main/java/eu/univento/core/api/Actionbar.java
View File

@ -1,9 +1,9 @@
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 net.minecraft.server.v1_9_R1.IChatBaseComponent;
import net.minecraft.server.v1_9_R1.IChatBaseComponent.ChatSerializer;
import net.minecraft.server.v1_9_R1.PacketPlayOutChat;
import org.bukkit.craftbukkit.v1_9_R1.entity.CraftPlayer;
import org.bukkit.entity.Player;
public class Actionbar {
@ -12,7 +12,7 @@ public class Actionbar {
CraftPlayer p = (CraftPlayer) player;
IChatBaseComponent cbc = ChatSerializer.a("{\"text\": \"" + message + "\"}");
PacketPlayOutChat ppoc = new PacketPlayOutChat(cbc,(byte) 2);
((CraftPlayer) p).getHandle().playerConnection.sendPacket(ppoc);
p.getHandle().playerConnection.sendPacket(ppoc);
}
}

11
src/eu/univento/core/api/AutoCommand.java → src/main/java/eu/univento/core/api/AutoCommand.java
View File

@ -1,5 +1,6 @@
package eu.univento.core.api;
import eu.univento.core.Core;
import org.bukkit.Bukkit;
import org.bukkit.command.Command;
import org.bukkit.command.CommandMap;
@ -9,6 +10,7 @@ import org.bukkit.plugin.java.JavaPlugin;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
/**
* @author PostCrafter
@ -21,10 +23,8 @@ public abstract class AutoCommand<P extends JavaPlugin> extends Command {
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);
Core.log(Level.INFO, "AutoCommand hook for Bukkit " + AutoCommand.VERSION);
}
protected final P plugin;
@ -36,16 +36,15 @@ public abstract class AutoCommand<P extends JavaPlugin> extends Command {
this.command = command;
super.setDescription(description);
List<String> aliasList = new ArrayList<String>();
List<String> aliasList = new ArrayList<>();
for (String alias : aliases) {
aliasList.add(alias);
}
super.setAliases(aliasList);
this.register();
}
public void register() {
private void register() {
try {
Field f = Class.forName("org.bukkit.craftbukkit." + AutoCommand.VERSION + ".CraftServer").getDeclaredField("commandMap");
f.setAccessible(true);

11
src/eu/univento/core/api/Blackscreen.java → src/main/java/eu/univento/core/api/Blackscreen.java
View File

@ -15,8 +15,7 @@ import java.util.UUID;
* @author janhektor
*
*/
public class Blackscreen
{
public class Blackscreen {
private static Object packetObject;
private static Class<?> packetClass;
private static String VERSION;
@ -40,24 +39,20 @@ public class Blackscreen
public static void setupUtil(Plugin instance, int repeatingTicks)
{
Bukkit.getScheduler().runTaskTimer(instance, new Runnable()
{
public void run()
{
Bukkit.getScheduler().runTaskTimer(instance, () -> {
for (UUID uuid : Blackscreen.ticksLeft.keySet()) {
Player p = Bukkit.getPlayer(uuid);
if (p == null) {
Blackscreen.ticksLeft.remove(uuid);
}
else if (((Integer)Blackscreen.ticksLeft.get(uuid)).intValue() > 0) {
Blackscreen.ticksLeft.put(uuid, Integer.valueOf(((Integer)Blackscreen.ticksLeft.get(uuid)).intValue() - 2));
Blackscreen.ticksLeft.put(uuid, Integer.valueOf((Blackscreen.ticksLeft.get(uuid)).intValue() - 2));
Blackscreen.access(p);
} else {
Blackscreen.ticksLeft.remove(uuid);
}
}
}
}
, 0L, repeatingTicks);
}

3
src/eu/univento/core/api/Config.java → src/main/java/eu/univento/core/api/Config.java
View File

@ -156,8 +156,7 @@ public class Config {
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;
return new Location(Bukkit.getWorld(world), x, y, z, yaw, pitch);
}
/**

93
src/main/java/eu/univento/core/api/Hologram.java Normal file
View File

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

26
src/eu/univento/core/api/Title.java → src/main/java/eu/univento/core/api/Title.java
View File

@ -1,11 +1,11 @@
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 net.minecraft.server.v1_9_R1.IChatBaseComponent;
import net.minecraft.server.v1_9_R1.PacketPlayOutPlayerListHeaderFooter;
import net.minecraft.server.v1_9_R1.PacketPlayOutTitle;
import net.minecraft.server.v1_9_R1.PlayerConnection;
import org.bukkit.ChatColor;
import org.bukkit.craftbukkit.v1_8_R3.entity.CraftPlayer;
import org.bukkit.craftbukkit.v1_9_R1.entity.CraftPlayer;
import org.bukkit.entity.Player;
import java.lang.reflect.Field;
@ -30,7 +30,7 @@ public class Title {
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());
PacketPlayOutTitle packetPlayOutTimes = new PacketPlayOutTitle(PacketPlayOutTitle.EnumTitleAction.TIMES, null, fadeIn, stay, fadeOut);
connection.sendPacket(packetPlayOutTimes);
if (subtitle != null) {
@ -82,18 +82,4 @@ public class Title {
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;
}
}

13
src/eu/univento/core/api/Utils.java → src/main/java/eu/univento/core/api/Utils.java
View File

@ -124,12 +124,12 @@ public class Utils {
* @return Vector
*/
public static Vector calculateVector(Location from, Location to) {
Location a = from, b = to;
Location 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();
double dX = from.getX() - b.getX();
double dY = from.getY() - b.getY();
double dZ = from.getZ() - b.getZ();
// -------------------------
// calculate the yaw
@ -145,10 +145,9 @@ public class Utils {
double y = Math.sin(pitch) * Math.sin(yaw);
double z = Math.cos(pitch);
Vector vector = new Vector(x, z, y);
// -------------------------
return vector;
return new Vector(x, z, y);
}
/**
@ -173,7 +172,5 @@ public class Utils {
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();
}
}

0
src/eu/univento/core/api/database/Database.java → src/main/java/eu/univento/core/api/database/Database.java
View File

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();
}
}
}

0
src/eu/univento/core/api/database/MySQL.java → src/main/java/eu/univento/core/api/database/MySQL.java
View File

0
src/eu/univento/core/api/database/SQLite.java → src/main/java/eu/univento/core/api/database/SQLite.java
View File

36
src/main/java/eu/univento/core/api/effects/Effects.java Normal file
View File

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

1606
src/main/java/eu/univento/core/api/effects/ParticleEffect.java Normal file
View File

File diff suppressed because it is too large Load Diff

0
src/eu/univento/core/api/effects/WorldBoarder.java → src/main/java/eu/univento/core/api/effects/WorldBoarder.java
View File

12
src/eu/univento/core/api/entity/EntityModifier.java → src/main/java/eu/univento/core/api/entity/EntityModifier.java
View File

@ -1,12 +1,12 @@
package eu.univento.core.api.entity;
import net.minecraft.server.v1_8_R3.EntityLiving;
import net.minecraft.server.v1_8_R3.NBTTagCompound;
import net.minecraft.server.v1_9_R1.EntityLiving;
import net.minecraft.server.v1_9_R1.NBTTagCompound;
import org.bukkit.Bukkit;
import org.bukkit.EntityEffect;
import org.bukkit.Location;
import org.bukkit.craftbukkit.v1_8_R3.entity.CraftCreature;
import org.bukkit.craftbukkit.v1_8_R3.entity.CraftEntity;
import org.bukkit.craftbukkit.v1_9_R1.entity.CraftCreature;
import org.bukkit.craftbukkit.v1_9_R1.entity.CraftEntity;
import org.bukkit.entity.Player;
import org.bukkit.plugin.Plugin;
@ -21,7 +21,7 @@ public class EntityModifier
{
static org.bukkit.entity.Entity entity;
static CraftEntity craftentity;
static net.minecraft.server.v1_8_R3.Entity entityS;
static net.minecraft.server.v1_9_R1.Entity entityS;
static int scheduler;
static Plugin plugin;
static Player player = null;
@ -122,7 +122,7 @@ public class EntityModifier
{
try
{
Field invulnerableField = net.minecraft.server.v1_8_R3.Entity.class
Field invulnerableField = net.minecraft.server.v1_9_R1.Entity.class
.getDeclaredField("invulnerable");
invulnerableField.setAccessible(true);
invulnerableField.setBoolean(EntityModifier.entityS, invulnerable);

0
src/eu/univento/core/api/events/MoveEventFilter.java → src/main/java/eu/univento/core/api/events/MoveEventFilter.java
View File

18
src/eu/univento/core/api/fakeplayer/FakePlayer.java → src/main/java/eu/univento/core/api/fakeplayer/FakePlayer.java
View File

@ -2,9 +2,9 @@ package eu.univento.core.api.fakeplayer;
import com.mojang.authlib.GameProfile;
import eu.univento.core.Core;
import net.minecraft.server.v1_8_R3.*;
import net.minecraft.server.v1_9_R1.*;
import org.bukkit.Location;
import org.bukkit.craftbukkit.v1_8_R3.entity.CraftPlayer;
import org.bukkit.craftbukkit.v1_9_R1.entity.CraftPlayer;
import org.bukkit.entity.ArmorStand;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.LivingEntity;
@ -21,6 +21,8 @@ import java.util.Arrays;
*/
public class FakePlayer {
//TODO: fix parts and add some stuff
private static final double MOVE_SPEED = 4.3D / 20;
private Player player;
@ -47,9 +49,9 @@ public class FakePlayer {
this.dataWatcher = new DataWatcher(null);
byte status = 0;
this.dataWatcher.a(0, status);
this.dataWatcher.a(10, (byte) 127);
this.dataWatcher.a(6, 20F);
//this.dataWatcher.a(0, status);
//this.dataWatcher.a(10, (byte) 127);
//this.dataWatcher.a(6, 20F);
}
private final BukkitRunnable tickTask = new BukkitRunnable() {
@ -106,9 +108,9 @@ public class FakePlayer {
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);
//dataWatcher.a(0, status);
//dataWatcher.a(10, (byte) 127);
//dataWatcher.a(6, 20F);
}
public void followEntity(LivingEntity entity) {

0
src/eu/univento/core/api/fakeplayer/PlayerKi.java → src/main/java/eu/univento/core/api/fakeplayer/PlayerKi.java
View File

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);
}
}

4
src/eu/univento/core/api/gui/AnvilGui.java → src/main/java/eu/univento/core/api/gui/AnvilGUI.java
View File

@ -1,9 +1,9 @@
package eu.univento.core.api.gui;
import eu.univento.core.Core;
import net.minecraft.server.v1_8_R3.*;
import net.minecraft.server.v1_9_R1.*;
import org.bukkit.Bukkit;
import org.bukkit.craftbukkit.v1_8_R3.entity.CraftPlayer;
import org.bukkit.craftbukkit.v1_9_R1.entity.CraftPlayer;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.HandlerList;

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();
}
}
}

0
src/eu/univento/core/api/items/ItemSkulls.java → src/main/java/eu/univento/core/api/items/ItemSkulls.java
View File

0
src/eu/univento/core/api/items/Pagifier.java → src/main/java/eu/univento/core/api/items/Pagifier.java
View File

0
src/eu/univento/core/api/languages/Language_DE.java → src/main/java/eu/univento/core/api/languages/Language_DE.java
View File

2
src/eu/univento/core/api/languages/Language_EN.java → src/main/java/eu/univento/core/api/languages/Language_EN.java
View File

@ -546,7 +546,7 @@ public class Language_EN implements Languages{
@Override
public String LobbyBoard_NEW() {
return "§e§lJetzt neu:";
return "§e§lNew:";
}
@Override

27
src/eu/univento/core/api/languages/Language_IT.java → src/main/java/eu/univento/core/api/languages/Language_IT.java
View File

@ -71,12 +71,12 @@ public class Language_IT implements Languages{
@Override
public String Core_BUILD_ON() {
return "§7Tu sei §aentrato nel §emodo di costruzione";
return "§7Tu sei §aentrato §7nel §emodo di costruzione";
}
@Override
public String Core_BUILD_OFF() {
return "§7Tu sei §auscito dal §emodo di costruzione";
return "§7Tu sei §auscito §7dal §emodo di costruzione";
}
@Override
@ -170,7 +170,7 @@ public class Language_IT implements Languages{
@Override
public String Core_CHAT_CLEARED(CustomPlayer p) {
return "§7La chat è stato §cpulito §7da " + p.getColor() + p.getDisplayName();
return "§7La chat è stata §cpulita §7da " + p.getColor() + p.getDisplayName();
}
@Override
@ -195,27 +195,27 @@ public class Language_IT implements Languages{
@Override
public String Lobby_AUTONICK_OFF() {
return "§7Adesso §cnon §7ti viene più dato un §esoprannome §7automatico";
return "§7Adesso §cnon §7ti viene dato un più §esoprannome §7automatico";
}
@Override
public String Lobby_FORCEFIELD_ON() {
return "§7Hai §7attivato §7il §eforcefield";
return "§7Hai §aattivato §7il §eForcefield";
}
@Override
public String Lobby_FORCEFIELD_OFF() {
return "§7Hai §cdisattivato §7il §eforcefield";
return "§7Hai §cdisattivato §7il §eForcefield";
}
@Override
public String Lobby_SILENT_LOBBY_ON() {
return "§7Sei §aentrato §7nella §esilent-lobby";
return "§7Sei §aentrato §7nella §eSilent-Lobby";
}
@Override
public String Lobby_SILENT_LOBBY_OFF() {
return "§7Sei §euscita §7della §esilent-lobby";
return "§7Sei §cuscita §7della §eSilent-Lobby";
}
@Override
@ -435,7 +435,7 @@ public class Language_IT implements Languages{
@Override
public String LobbyItems_PLAYER_MENU() {
return " menu";
return ": menu";
}
@Override
@ -510,17 +510,17 @@ public class Language_IT implements Languages{
@Override
public String LobbyItems_SETTINGS_ON() {
return "§aattivato";
return "§aattivo";
}
@Override
public String LobbyItems_SETTINGS_OFF() {
return "§cdisattivato";
return "§cdisattivo";
}
@Override
public String LobbyItems_BACK() {
return "§cindietro";
return "§cIndietro";
}
@Override
@ -530,7 +530,7 @@ public class Language_IT implements Languages{
@Override
public String LobbyBoard_COINS() {
return "§eI tuoi Coins§7:";
return "§eVenties§7:";
}
@Override
@ -552,4 +552,5 @@ public class Language_IT implements Languages{
public String LobbyBoard_NEWS() {
return "Scheibenwischer";
}
}

0
src/eu/univento/core/api/languages/Languages.java → src/main/java/eu/univento/core/api/languages/Languages.java
View File

10
src/eu/univento/core/api/languages/Messages.java → src/main/java/eu/univento/core/api/languages/Messages.java
View File

@ -3,6 +3,7 @@ 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
@ -19,14 +20,15 @@ public class Messages {
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;
if(player.getLanguage().equals("DE")) this.lang = de;
if(player.getLanguage().equals("IT")) this.lang = it;
if(player.getLanguage().equals("EN")) this.lang = en;
}
public String PREFIX() {
return " §7• §6univento§7.§eeu §7• ";
return " §6univento §8» ";
}
public String TAB_PREFIX() { return "§8• §6U N I V E N T O §8• ";}
public String UNKNOWN_ERROR() {
return lang.UNKNOWN_ERROR();

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);
}
}

2
src/eu/univento/core/api/player/BanSystem.java → src/main/java/eu/univento/core/api/player/BanSystem.java
View File

@ -70,7 +70,7 @@ static void removeAllBans(CustomPlayer p) throws SQLException, ClassNotFoundExce
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 + "';");
PreparedStatement st = sql.getConnection().prepareStatement("SELECT * FROM bans WHERE BID='" + id + "';");
ResultSet rs = st.executeQuery();
if(rs.next()) {
Date date = new Date();

60
src/main/java/eu/univento/core/api/player/Coins.java Normal file
View File

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

832
src/main/java/eu/univento/core/api/player/CustomPlayer.java Normal file
View File

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

60
src/main/java/eu/univento/core/api/player/Experience.java Normal file
View File

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

109
src/main/java/eu/univento/core/api/player/Friends.java Normal file
View File

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

219
src/main/java/eu/univento/core/api/player/NickName.java Normal file
View File

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

66
src/eu/univento/core/api/player/Perms.java → src/main/java/eu/univento/core/api/player/Perms.java
View File

@ -3,7 +3,6 @@ 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;
@ -19,14 +18,7 @@ import java.util.HashMap;
*/
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;
}
@ -116,24 +108,24 @@ static Color getArmorColor(Ranks r) {
* @author joethei
* @version 1.0
*/
public static class Teams {
static class Teams {
CustomPlayer player;
public Scoreboard board;
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;
Team Admin;
Team SrDeveloper;
Team Developer;
Team SrModerator;
Team Moderator;
Team HeadBuilder;
Team Builder;
Team Supporter;
Team Youtuber;
Team Premium;
Team Player;
public Teams(CustomPlayer player) {
Teams(CustomPlayer player) {
this.player = player;
board = player.getScoreboard();
Admin = board.getTeam("a");
@ -154,7 +146,7 @@ public static class Teams {
* @param p CustomPlayer
* @return Team
*/
public static Team getTeam(CustomPlayer p) {
static Team getTeam(CustomPlayer p) {
Teams teams = new Teams(p);
switch(p.getRank()) {
case Admin: return teams.Admin;
@ -204,17 +196,17 @@ public static void initScoreboard(CustomPlayer p) {
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);
Admin.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
SrDeveloper.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
Developer.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
SrModerator.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
HeadBuilder.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
Moderator.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
Builder.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
Supporter.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
Youtuber.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
Premium.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
Player.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
}
/**
* gets Rank of player
@ -293,7 +285,7 @@ static boolean isAllowed(CustomPlayer p, Ranks r) throws ClassNotFoundException,
* @author joethei
* @version 1.0
*/
public static enum Ranks{
public enum Ranks{
Admin(11),
SrDeveloper(10),
Developer(9),
@ -306,9 +298,9 @@ static boolean isAllowed(CustomPlayer p, Ranks r) throws ClassNotFoundException,
Premium(2),
Player(1);
public final int value;
final int value;
private Ranks(int n) {
Ranks(int n) {
this.value = n;
}
}

0
src/eu/univento/core/api/player/PlayerSettings.java → src/main/java/eu/univento/core/api/player/PlayerSettings.java
View File

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;
}
}

0
src/eu/univento/core/api/player/Spectator.java → src/main/java/eu/univento/core/api/player/Spectator.java
View File

217
src/main/java/eu/univento/core/api/player/Statistics.java Normal file
View File

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

19
src/main/java/eu/univento/core/api/server/Game.java Normal file
View File

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

0
src/eu/univento/core/api/server/GameInfo.java → src/main/java/eu/univento/core/api/server/GameInfo.java
View File

0
src/eu/univento/core/api/server/MojangService.java → src/main/java/eu/univento/core/api/server/MojangService.java
View File

22
src/eu/univento/core/api/server/ServerDatabase.java → src/main/java/eu/univento/core/api/server/ServerDatabase.java
View File

@ -13,7 +13,7 @@ import java.sql.SQLException;
*/
public class ServerDatabase {
public static String getIP(String name) {
static String getIP(String name) {
MySQL sql = Core.returnSQL();
try {
sql.openConnection();
@ -31,7 +31,7 @@ public class ServerDatabase {
}
}
public static int getPort(String name) {
static int getPort(String name) {
MySQL sql = Core.returnSQL();
try {
sql.openConnection();
@ -48,4 +48,22 @@ public class ServerDatabase {
return 0;
}
}
static String getMotd(String name) {
MySQL sql = Core.returnSQL();
try {
sql.openConnection();
PreparedStatement st = sql.getConnection().prepareStatement("SELECT motd FROM Servers WHERE name='" + name + "'");
ResultSet rs = st.executeQuery();
if(rs.next()) {
String motd = rs.getString("motd");
sql.closeConnection();
return motd;
}
return null;
} catch (SQLException | ClassNotFoundException e) {
e.printStackTrace();
return null;
}
}
}

6
src/eu/univento/core/api/server/ServerInfo.java → src/main/java/eu/univento/core/api/server/ServerInfo.java
View File

@ -31,6 +31,10 @@ public class ServerInfo {
return parts[1];
}
public boolean isOnline() {
return pinger.isOnline();
}
public int getOnlinePlayers() {
return pinger.getPlayerCount();
}
@ -40,7 +44,7 @@ public class ServerInfo {
}
public String getMotd() {
return pinger.getMotd();
return ServerDatabase.getMotd(name);
}
}

2
src/eu/univento/core/api/server/ServerPinger.java → src/main/java/eu/univento/core/api/server/ServerPinger.java
View File

@ -140,12 +140,14 @@ public class ServerPinger {
if(string.startsWith("§")){
String[] data = string.split("\0");
this.setMotd(data[3]);
this.setOnline(true);
this.setPlayerCount(Integer.parseInt(data[4]));
this.setMaxPlayers(Integer.parseInt(data[5]));
}
else{
String[] data = string.split("§");
this.setMotd(data[0]);
this.setOnline(true);
this.setPlayerCount(Integer.parseInt(data[1]));
this.setMaxPlayers(Integer.parseInt(data[2]));
}

11
src/eu/univento/core/api/server/ServerSettings.java → src/main/java/eu/univento/core/api/server/ServerSettings.java
View File

@ -15,8 +15,9 @@ public class ServerSettings {
private static boolean game;
private static Game playedGame;
private static GameMode gameMode;
private static String gameState;
public static Game getPlayedGameGame() {
public static Game getPlayedGame() {
return playedGame;
}
@ -71,4 +72,12 @@ public class ServerSettings {
public static void setMute(boolean mute) {
ServerSettings.mute = mute;
}
public static String getGameState() {
return gameState;
}
public static void setGameState(String gameState) {
ServerSettings.gameState = gameState;
}
}

0
src/eu/univento/core/api/server/Servers.java → src/main/java/eu/univento/core/api/server/Servers.java
View File

0
src/eu/univento/core/api/twitch/API.java → src/main/java/eu/univento/core/api/twitch/API.java
View File

0
src/eu/univento/core/api/twitch/Twitch_API.java → src/main/java/eu/univento/core/api/twitch/Twitch_API.java
View File

0
src/eu/univento/core/api/twitch/Twitch_Stream.java → src/main/java/eu/univento/core/api/twitch/Twitch_Stream.java
View File

0
src/eu/univento/core/api/utils/Direction.java → src/main/java/eu/univento/core/api/utils/Direction.java
View File

0
src/eu/univento/core/api/utils/GameProfileBuilder.java → src/main/java/eu/univento/core/api/utils/GameProfileBuilder.java
View File

0
src/eu/univento/core/api/utils/Maths.java → src/main/java/eu/univento/core/api/utils/Maths.java
View File

0
src/eu/univento/core/api/utils/NameFetcher.java → src/main/java/eu/univento/core/api/utils/NameFetcher.java
View File

0
src/eu/univento/core/api/utils/RandomCollection.java → src/main/java/eu/univento/core/api/utils/RandomCollection.java
View File

0
src/eu/univento/core/api/utils/Vectors.java → src/main/java/eu/univento/core/api/utils/Vectors.java
View File

0
src/eu/univento/core/api/utils/reflection/IReflection.java → src/main/java/eu/univento/core/api/utils/reflection/IReflection.java
View File

0
src/eu/univento/core/api/utils/reflection/Reflection.java → src/main/java/eu/univento/core/api/utils/reflection/Reflection.java
View File

606
src/main/java/eu/univento/core/api/utils/reflection/ReflectionUtils.java Normal file
View File

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

4
src/eu/univento/core/api/youtube/YTAPI.java → src/main/java/eu/univento/core/api/youtube/YTAPI.java
View File

@ -88,11 +88,11 @@ public class YTAPI {
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()

0
src/eu/univento/core/api/youtube/YoutubeChannel.java → src/main/java/eu/univento/core/api/youtube/YoutubeChannel.java
View File

2
src/eu/univento/core/commands/Ban.java → src/main/java/eu/univento/core/commands/Ban.java
View File

@ -26,7 +26,7 @@ public class Ban extends AutoCommand<Core>{
* @param description describes the command
* @param aliases aliases of command
*/
public Ban(Core plugin, String command, String description, String[] aliases) {
public Ban(Core plugin, String command, String description, String... aliases) {
super(plugin, command, description, aliases);
}

2
src/eu/univento/core/commands/Build.java → src/main/java/eu/univento/core/commands/Build.java
View File

@ -39,7 +39,7 @@ public class Build extends AutoCommand<Core>{
* @param description describes the command
* @param aliases aliases of command
*/
public Build(Core plugin, String command, String description, String[] aliases) {
public Build(Core plugin, String command, String description, String... aliases) {
super(plugin, command, description, aliases);
}

0
src/eu/univento/core/commands/ChatClear.java → src/main/java/eu/univento/core/commands/ChatClear.java
View File

6
src/eu/univento/core/commands/Fix.java → src/main/java/eu/univento/core/commands/Fix.java
View File

@ -24,7 +24,7 @@ public class Fix extends AutoCommand<Core>{
* @param description describes the command
* @param aliases aliases of command
*/
public Fix(Core plugin, String command, String description, String[] aliases) {
public Fix(Core plugin, String command, String description, String... aliases) {
super(plugin, command, description, aliases);
}
@ -66,8 +66,6 @@ public class Fix extends AutoCommand<Core>{
@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;
return Bukkit.getOnlinePlayers().stream().map(Player::getDisplayName).collect(Collectors.toList());
}
}

2
src/eu/univento/core/commands/GameMode.java → src/main/java/eu/univento/core/commands/GameMode.java
View File

@ -24,7 +24,7 @@ public class GameMode extends AutoCommand<Core>{
* @param description describes the command
* @param aliases aliases of command
*/
public GameMode(Core plugin, String command, String description, String[] aliases) {
public GameMode(Core plugin, String command, String description, String... aliases) {
super(plugin, command, description, aliases);
}

2
src/eu/univento/core/commands/GlobalMute.java → src/main/java/eu/univento/core/commands/GlobalMute.java
View File

@ -24,7 +24,7 @@ public class GlobalMute extends AutoCommand<Core>{
* @param description describes the command
* @param aliases aliases of command
*/
public GlobalMute(Core plugin, String command, String description, String[] aliases) {
public GlobalMute(Core plugin, String command, String description, String... aliases) {
super(plugin, command, description, aliases);
}

38
src/eu/univento/core/commands/Youtuber.java → src/main/java/eu/univento/core/commands/Nick.java
View File

@ -4,19 +4,18 @@ 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 eu.univento.core.api.player.Perms.Ranks;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.List;
/**
* sets player to youtube rank
* nick command
* @author joethei
* @version 1.0
*/
public class Youtuber extends AutoCommand<Core>{
public class Nick extends AutoCommand<Core>{
/**
* @param plugin main class
@ -24,30 +23,34 @@ public class Youtuber extends AutoCommand<Core>{
* @param description describes the command
* @param aliases aliases of command
*/
public Youtuber(Core plugin, String command, String description, String[] aliases) {
public Nick(Core plugin, String command, String description, String... aliases) {
super(plugin, command, description, aliases);
}
@SuppressWarnings("deprecation")
@Override
public boolean execute(CommandSender sender, String label, String[] args) {
if(sender instanceof Player) {
CustomPlayer p = CustomPlayer.getPlayer(sender.getName());
Messages msgs = new Messages(p);
if(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());
if(p.isAllowed(Ranks.Youtuber)) {
if(p.isNicked()) {
p.getTeam().removeEntry(p.getDisplayName());
p.setNicked(false);
p.setDisplayName(p.getName());
p.getTeam().addEntry(p.getDisplayName());
p.sendMessage(msgs.PREFIX() + msgs.Core_NICK_OFF());
p.unnick();
}else {
p.sendMessage(msgs.PREFIX() + "§cDer Youtube Kanal exsistiert nicht");
p.getTeam().removeEntry(p.getDisplayName());
p.setNicked(true);
p.setDisplayName(p.getNick());
p.getTeam().addEntry(p.getDisplayName());
p.sendMessage(msgs.PREFIX() + msgs.Core_NICK_ON());
p.nick(p.getNick());
}
}else {
p.sendMessage(msgs.PREFIX() + "§cBenutze doch /youtuber <Channel Name>");
p.sendMessage(msgs.NO_PERMS());
}
}else {
sender.sendMessage(Messages.Console.NOT_A_PLAYER);
@ -57,6 +60,7 @@ public class Youtuber extends AutoCommand<Core>{
@Override
public List<String> tabComplete(CommandSender sender, String label, String[] args) {
return null;
}

2
src/eu/univento/core/commands/RunAs.java → src/main/java/eu/univento/core/commands/RunAs.java
View File

@ -25,7 +25,7 @@ public class RunAs extends AutoCommand<Core>{
* @param description describes the command
* @param aliases aliases of command
*/
public RunAs(Core plugin, String command, String description, String[] aliases) {
public RunAs(Core plugin, String command, String description, String... aliases) {
super(plugin, command, description, aliases);
}

41
src/eu/univento/core/commands/SetRank.java → src/main/java/eu/univento/core/commands/SetRank.java
View File

@ -25,7 +25,7 @@ public class SetRank extends AutoCommand<Core>{
* @param description describes the command
* @param aliases aliases of command
*/
public SetRank(Core plugin, String command, String description, String[] aliases) {
public SetRank(Core plugin, String command, String description, String... aliases) {
super(plugin, command, description, aliases);
}
@ -33,46 +33,45 @@ public class SetRank extends AutoCommand<Core>{
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) {
CustomPlayer player = CustomPlayer.getPlayer(Bukkit.getPlayer(args[0]));
if(p.isAllowed(Ranks.HeadBuilder) && rank.equals(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) {
p.sendMessage(p.getMessages().PREFIX() + p.getMessages().Core_SETRANK_SET(player, player.getRank()));
player.kickPlayer(player.getMessages().Core_SETRANK_KICK());
}if(p.isAllowed(Ranks.SrModerator) && rank.equals(Ranks.Moderator)) {
player.setRank(rank);
p.sendMessage(msgs.PREFIX() + msgs.Core_SETRANK_SET(player, player.getRank()));
player.kickPlayer(msgs.Core_SETRANK_KICK());
}if(p.isAllowed(Ranks.SrModerator) && rank == Ranks.Supporter) {
p.sendMessage(p.getMessages().PREFIX() + p.getMessages().Core_SETRANK_SET(player, player.getRank()));
player.kickPlayer(player.getMessages().Core_SETRANK_KICK());
}if(p.isAllowed(Ranks.SrModerator) && rank.equals(Ranks.Supporter)) {
player.setRank(rank);
p.sendMessage(msgs.PREFIX() + msgs.Core_SETRANK_SET(player, player.getRank()));
player.kickPlayer(msgs.Core_SETRANK_KICK());
}if(p.isAllowed(Ranks.SrDeveloper) && rank == Ranks.Developer) {
p.sendMessage(p.getMessages().PREFIX() + p.getMessages().Core_SETRANK_SET(player, player.getRank()));
player.kickPlayer(player.getMessages().Core_SETRANK_KICK());
}if(p.isAllowed(Ranks.SrDeveloper) && rank.equals(Ranks.Developer)) {
player.setRank(rank);
p.sendMessage(msgs.PREFIX() + msgs.Core_SETRANK_SET(player, player.getRank()));
player.kickPlayer(msgs.Core_SETRANK_KICK());
p.sendMessage(p.getMessages().PREFIX() + p.getMessages().Core_SETRANK_SET(player, player.getRank()));
player.kickPlayer(player.getMessages().Core_SETRANK_KICK());
}
if(p.isAllowed(Ranks.Admin)) {
player.setRank(rank);
p.sendMessage(msgs.PREFIX() + msgs.Core_SETRANK_SET(player, player.getRank()));
player.kickPlayer(msgs.Core_SETRANK_KICK());
p.sendMessage(p.getMessages().PREFIX() + p.getMessages().Core_SETRANK_SET(player, player.getRank()));
player.kickPlayer(player.getMessages().Core_SETRANK_KICK());
}
}else {
p.sendMessage(msgs.NOT_ONLINE(args[0]));
p.sendMessage(p.getMessages().NOT_ONLINE(args[0]));
}
}else {
p.sendMessage(msgs.Core_SETRANK_NO_RANK());
p.sendMessage(p.getMessages().Core_SETRANK_NO_RANK());
}
}else {
p.sendMessage(msgs.Core_SETRANK_NO_RANK());
p.sendMessage(p.getMessages().Core_SETRANK_NO_RANK());
}
}else {
p.sendMessage(msgs.NO_PERMS());
p.sendMessage(p.getMessages().NO_PERMS());
}
}else {
sender.sendMessage(Messages.Console.NOT_A_PLAYER);

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;
}
}

2
src/eu/univento/core/commands/SystemInfo.java → src/main/java/eu/univento/core/commands/SystemInfo.java
View File

@ -24,7 +24,7 @@ public class SystemInfo extends AutoCommand<Core>{
* @param description describes the command
* @param aliases aliases of command
*/
public SystemInfo(Core plugin, String command, String description, String[] aliases) {
public SystemInfo(Core plugin, String command, String description, String... aliases) {
super(plugin, command, description, aliases);
}

4
src/eu/univento/core/commands/TS.java → src/main/java/eu/univento/core/commands/TS.java
View File

@ -21,7 +21,7 @@ public class TS extends AutoCommand<Core>{
* @param description describes the command
* @param aliases aliases of command
*/
public TS(Core plugin, String command, String description, String[] aliases) {
public TS(Core plugin, String command, String description, String... aliases) {
super(plugin, command, description, aliases);
}
@ -29,7 +29,7 @@ public class TS extends AutoCommand<Core>{
public boolean execute(CommandSender sender, String label, String[] args) {
if(sender instanceof Player) {
CustomPlayer p = CustomPlayer.getPlayer(sender.getName());
p.verifyTs();
p.sendMessage("Der TS Befehl ist momentan deaktivert");
}
return true;
}

2
src/eu/univento/core/commands/Twitch.java → src/main/java/eu/univento/core/commands/Twitch.java
View File

@ -24,7 +24,7 @@ public class Twitch extends AutoCommand<Core>{
* @param description describes the command
* @param aliases aliases of command
*/
public Twitch(Core plugin, String command, String description, String[] aliases) {
public Twitch(Core plugin, String command, String description, String... aliases) {
super(plugin, command, description, aliases);
}

2
src/eu/univento/core/commands/Vanish.java → src/main/java/eu/univento/core/commands/Vanish.java
View File

@ -36,7 +36,7 @@ public class Vanish extends AutoCommand<Core>{
* @param description describes the command
* @param aliases aliases of command
*/
public Vanish(Core plugin, String command, String description, String[] aliases) {
public Vanish(Core plugin, String command, String description, String... aliases) {
super(plugin, command, description, aliases);
}

0
src/eu/univento/core/listeners/Blocks.java → src/main/java/eu/univento/core/listeners/Blocks.java
View File

1
src/eu/univento/core/listeners/Chat.java → src/main/java/eu/univento/core/listeners/Chat.java
View File

@ -39,6 +39,7 @@ public class Chat implements Listener{
}else {
format = p.getPrefix() + p.getDisplayName() + p.getSuffix() + e.getMessage();
}
if(format.contains("%")) format = format.replace("%", "%%");
e.setFormat(format);
}

0
src/eu/univento/core/listeners/Commands.java → src/main/java/eu/univento/core/listeners/Commands.java
View File

Some files were not shown because too many files have changed in this diff Show More