From 8369f7ffc9c2ba58dcce7a75c134b294992466e6 Mon Sep 17 00:00:00 2001 From: Johannes Date: Sat, 5 Dec 2015 12:26:39 +0100 Subject: [PATCH] first commit --- .classpath | 7 + .gitignore | 1 + .project | 17 + .settings/org.eclipse.jdt.core.prefs | 11 + src/de/joethei/core/Core.java | 162 ++++ src/de/joethei/core/api/Actionbar.java | 38 + src/de/joethei/core/api/AutoCommand.java | 77 ++ src/de/joethei/core/api/BanSystem.java | 121 +++ src/de/joethei/core/api/Blackscreen.java | 79 ++ src/de/joethei/core/api/BossBar.java | 89 ++ src/de/joethei/core/api/Config.java | 165 ++++ src/de/joethei/core/api/CustomPlayer.java | 295 +++++++ src/de/joethei/core/api/Database.java | 71 ++ src/de/joethei/core/api/EntityModifier.java | 233 ++++++ src/de/joethei/core/api/Hologram.java | 148 ++++ src/de/joethei/core/api/ItemSkulls.java | 123 +++ src/de/joethei/core/api/Letters.java | 577 +++++++++++++ src/de/joethei/core/api/Messages.java | 88 ++ src/de/joethei/core/api/MojangService.java | 120 +++ src/de/joethei/core/api/MuteSystem.java | 51 ++ src/de/joethei/core/api/MySQL.java | 37 + src/de/joethei/core/api/NPC.java | 785 ++++++++++++++++++ src/de/joethei/core/api/NickName.java | 93 +++ src/de/joethei/core/api/Pagifier.java | 66 ++ src/de/joethei/core/api/Perms.java | 161 ++++ src/de/joethei/core/api/SQLite.java | 46 + src/de/joethei/core/api/ServerPinger.java | 98 +++ src/de/joethei/core/api/Servers.java | 108 +++ src/de/joethei/core/api/Settings.java | 67 ++ src/de/joethei/core/api/SignInput.java | 145 ++++ src/de/joethei/core/api/SimpleScoreboard.java | 104 +++ src/de/joethei/core/api/Spectator.java | 44 + src/de/joethei/core/api/Title.java | 86 ++ src/de/joethei/core/api/Utils.java | 179 ++++ src/de/joethei/core/api/twitch/API.java | 28 + .../joethei/core/api/twitch/Twitch_API.java | 43 + .../core/api/twitch/Twitch_Stream.java | 381 +++++++++ src/de/joethei/core/api/utils/Direction.java | 37 + src/de/joethei/core/api/utils/FakeDragon.java | 227 +++++ src/de/joethei/core/api/utils/FakeWither.java | 277 ++++++ .../core/api/utils/GameProfileBuilder.java | 145 ++++ src/de/joethei/core/api/utils/Maths.java | 281 +++++++ .../joethei/core/api/utils/NameFetcher.java | 50 ++ .../core/api/utils/RandomCollection.java | 41 + src/de/joethei/core/api/utils/Reflection.java | 140 ++++ src/de/joethei/core/api/utils/Vectors.java | 45 + src/de/joethei/core/api/youtube/YTAPI.java | 119 +++ .../core/api/youtube/YoutubeChannel.java | 242 ++++++ src/de/joethei/core/commands/Ban.java | 110 +++ src/de/joethei/core/commands/Build.java | 70 ++ src/de/joethei/core/commands/Fix.java | 75 ++ src/de/joethei/core/commands/GameMode.java | 87 ++ src/de/joethei/core/commands/GlobalMute.java | 58 ++ src/de/joethei/core/commands/RunAs.java | 77 ++ src/de/joethei/core/commands/SetRank.java | 95 +++ src/de/joethei/core/commands/SystemInfo.java | 61 ++ src/de/joethei/core/commands/Twitch.java | 65 ++ src/de/joethei/core/commands/Vanish.java | 77 ++ src/de/joethei/core/commands/Youtuber.java | 63 ++ src/de/joethei/core/listeners/Blocks.java | 46 + src/de/joethei/core/listeners/Chat.java | 38 + src/de/joethei/core/listeners/Commands.java | 72 ++ src/de/joethei/core/listeners/JoinQuit.java | 124 +++ src/plugin.yml | 6 + 64 files changed, 7672 insertions(+) create mode 100644 .classpath create mode 100644 .gitignore create mode 100644 .project create mode 100644 .settings/org.eclipse.jdt.core.prefs create mode 100644 src/de/joethei/core/Core.java create mode 100644 src/de/joethei/core/api/Actionbar.java create mode 100644 src/de/joethei/core/api/AutoCommand.java create mode 100644 src/de/joethei/core/api/BanSystem.java create mode 100644 src/de/joethei/core/api/Blackscreen.java create mode 100644 src/de/joethei/core/api/BossBar.java create mode 100644 src/de/joethei/core/api/Config.java create mode 100644 src/de/joethei/core/api/CustomPlayer.java create mode 100644 src/de/joethei/core/api/Database.java create mode 100644 src/de/joethei/core/api/EntityModifier.java create mode 100644 src/de/joethei/core/api/Hologram.java create mode 100644 src/de/joethei/core/api/ItemSkulls.java create mode 100644 src/de/joethei/core/api/Letters.java create mode 100644 src/de/joethei/core/api/Messages.java create mode 100644 src/de/joethei/core/api/MojangService.java create mode 100644 src/de/joethei/core/api/MuteSystem.java create mode 100644 src/de/joethei/core/api/MySQL.java create mode 100644 src/de/joethei/core/api/NPC.java create mode 100644 src/de/joethei/core/api/NickName.java create mode 100644 src/de/joethei/core/api/Pagifier.java create mode 100644 src/de/joethei/core/api/Perms.java create mode 100644 src/de/joethei/core/api/SQLite.java create mode 100644 src/de/joethei/core/api/ServerPinger.java create mode 100644 src/de/joethei/core/api/Servers.java create mode 100644 src/de/joethei/core/api/Settings.java create mode 100644 src/de/joethei/core/api/SignInput.java create mode 100644 src/de/joethei/core/api/SimpleScoreboard.java create mode 100644 src/de/joethei/core/api/Spectator.java create mode 100644 src/de/joethei/core/api/Title.java create mode 100644 src/de/joethei/core/api/Utils.java create mode 100644 src/de/joethei/core/api/twitch/API.java create mode 100644 src/de/joethei/core/api/twitch/Twitch_API.java create mode 100644 src/de/joethei/core/api/twitch/Twitch_Stream.java create mode 100644 src/de/joethei/core/api/utils/Direction.java create mode 100644 src/de/joethei/core/api/utils/FakeDragon.java create mode 100644 src/de/joethei/core/api/utils/FakeWither.java create mode 100644 src/de/joethei/core/api/utils/GameProfileBuilder.java create mode 100644 src/de/joethei/core/api/utils/Maths.java create mode 100644 src/de/joethei/core/api/utils/NameFetcher.java create mode 100644 src/de/joethei/core/api/utils/RandomCollection.java create mode 100644 src/de/joethei/core/api/utils/Reflection.java create mode 100644 src/de/joethei/core/api/utils/Vectors.java create mode 100644 src/de/joethei/core/api/youtube/YTAPI.java create mode 100644 src/de/joethei/core/api/youtube/YoutubeChannel.java create mode 100644 src/de/joethei/core/commands/Ban.java create mode 100644 src/de/joethei/core/commands/Build.java create mode 100644 src/de/joethei/core/commands/Fix.java create mode 100644 src/de/joethei/core/commands/GameMode.java create mode 100644 src/de/joethei/core/commands/GlobalMute.java create mode 100644 src/de/joethei/core/commands/RunAs.java create mode 100644 src/de/joethei/core/commands/SetRank.java create mode 100644 src/de/joethei/core/commands/SystemInfo.java create mode 100644 src/de/joethei/core/commands/Twitch.java create mode 100644 src/de/joethei/core/commands/Vanish.java create mode 100644 src/de/joethei/core/commands/Youtuber.java create mode 100644 src/de/joethei/core/listeners/Blocks.java create mode 100644 src/de/joethei/core/listeners/Chat.java create mode 100644 src/de/joethei/core/listeners/Commands.java create mode 100644 src/de/joethei/core/listeners/JoinQuit.java create mode 100644 src/plugin.yml diff --git a/.classpath b/.classpath new file mode 100644 index 0000000..6797ae4 --- /dev/null +++ b/.classpath @@ -0,0 +1,7 @@ + + + + + + + diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..ae3c172 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +/bin/ diff --git a/.project b/.project new file mode 100644 index 0000000..22f9e97 --- /dev/null +++ b/.project @@ -0,0 +1,17 @@ + + + Core + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + diff --git a/.settings/org.eclipse.jdt.core.prefs b/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000..bb35fa0 --- /dev/null +++ b/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,11 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=1.8 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.source=1.8 diff --git a/src/de/joethei/core/Core.java b/src/de/joethei/core/Core.java new file mode 100644 index 0000000..12a341c --- /dev/null +++ b/src/de/joethei/core/Core.java @@ -0,0 +1,162 @@ +package de.joethei.core; + +import java.sql.SQLException; +import java.util.HashMap; +import java.util.logging.Level; +import java.util.logging.Logger; + +import org.bukkit.Bukkit; +import org.bukkit.plugin.PluginManager; +import org.bukkit.plugin.java.JavaPlugin; + +import de.joethei.core.api.Messages; +import de.joethei.core.api.Config; +import de.joethei.core.api.CustomPlayer; +import de.joethei.core.api.MySQL; +import de.joethei.core.api.Settings; +import de.joethei.core.commands.Ban; +import de.joethei.core.commands.Build; +import de.joethei.core.commands.Fix; +import de.joethei.core.commands.GameMode; +import de.joethei.core.commands.GlobalMute; +import de.joethei.core.commands.RunAs; +import de.joethei.core.commands.SetRank; +import de.joethei.core.commands.SystemInfo; +import de.joethei.core.commands.Vanish; +import de.joethei.core.commands.Youtuber; +import de.joethei.core.listeners.Blocks; +import de.joethei.core.listeners.Chat; +import de.joethei.core.listeners.Commands; +import de.joethei.core.listeners.JoinQuit; + +/** + * main class + * @author joethei + * @version 1.0 + */ +public class Core extends JavaPlugin{ + + /** + * 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; + } + + /** + * nick names of players + */ + public static HashMap nicks = new HashMap(); + + /** + * logging and stuff + */ + private static Logger log = Bukkit.getLogger(); + + /** + * @param level Log level + * @param string String + */ + public static void log(Level level, String string) { + log.log(level, "[" + Messages.CONSOLE_PREFIX + Core.getInstance().getDescription().getName() + "] " + string); + } + + @Override + public void onEnable() { + Settings.setDebug(true); + Settings.setBuild(true); + instance = this; + if(Settings.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); + + if(Settings.isDebug()) log(Level.INFO, "Events registriert"); + + String[] fix = {""}; + 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 Server 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 Server", globalmute); + + String[] youtuber = {""}; + new Youtuber(this, "youtuber", "setzt Spieler in den Youtuber Rang", youtuber); + + String[] ban = {""}; + new Ban(this, "ban", "Bannt Spieler", ban); + + if(Settings.isBuild()) { + String[] build = {"b"}; + new Build(this, "build", "Setzt den Spieler in den Bau Modus", build); + + if(Settings.isDebug()) log(Level.INFO, "Build Modus aktiviert"); + } + if(Settings.isDebug()) log(Level.INFO, "Alle Befehle registriert"); + + try + { + MySQL tempSQL = sql; + tempSQL.openConnection(); + + tempSQL.getConnection().createStatement().execute("CREATE TABLE IF NOT EXISTS PlayerData(ID bigint PRIMARY KEY auto_increment, player_uuid varchar(50), FirstJoin TIMESTAMP default now(), Coins bigint, mute boolean, Rank varchar(10), nick boolean, FastMenu boolean, teleport boolean);"); + if(Settings.isDebug()) log(Level.INFO, "MySQL PlayerData ausgeführt"); + + tempSQL.getConnection().createStatement().execute("CREATE TABLE IF NOT EXISTS bans(ID bigint PRIMARY KEY auto_increment, player_uuid varchar(50), Reason varchar(50), who varchar(50));"); + if(Settings.isDebug()) log(Level.INFO, "MySQL Bans erstellt"); + + tempSQL.getConnection().createStatement().execute("CREATE TABLE IF NOT EXISTS bugs(ID bigint PRIMARY KEY auto_increment, player_uuid varchar(50), time timestamp, msg varchar(250));"); + if(Settings.isDebug()) log(Level.INFO, "MySQL Bugs erstellt"); + + tempSQL.getConnection().createStatement().execute("CREATE TABLE IF NOT EXISTS Friends(ID bigint PRIMARY KEY auto_increment, player_uuid VARCHAR(64), Friends VARCHAR(2500));"); + if(Settings.isDebug()) log(Level.INFO, "MySQL Friends erstellt"); + + tempSQL.getConnection().createStatement().execute("CREATE TABLE IF NOT EXISTS Messages(ID bigint PRIMARY KEY auto_increment,Ident varchar(25), Message varchar(250));"); + if(Settings.isDebug()) log(Level.INFO, "MySQL Messages erstellt"); + + tempSQL.closeConnection(); + } catch (SQLException | ClassNotFoundException e) { + e.printStackTrace(); + } + Bukkit.getMessenger().registerOutgoingPluginChannel(this, "BungeeCord"); + log(Level.INFO, "Plugin ver. " + getDescription().getVersion() + " gestartet"); + } + + @Override + public void onDisable() { + Core.log(Level.INFO, "Plugin beendet"); + } + +} \ No newline at end of file diff --git a/src/de/joethei/core/api/Actionbar.java b/src/de/joethei/core/api/Actionbar.java new file mode 100644 index 0000000..2c013c9 --- /dev/null +++ b/src/de/joethei/core/api/Actionbar.java @@ -0,0 +1,38 @@ +package de.joethei.core.api; + +import java.lang.reflect.Field; + +import org.bukkit.craftbukkit.v1_8_R3.entity.CraftPlayer; +import org.bukkit.entity.Player; + +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; + +public class Actionbar { + + + public static void send(Player p, String text) { + + CraftPlayer cp = (CraftPlayer)p; + + IChatBaseComponent textC = ChatSerializer.a("{\"text\": \"" + text + "\"}"); + + PacketPlayOutChat actionbar = new PacketPlayOutChat(textC); + + try { + Field field = actionbar.getClass().getDeclaredField("a"); + field.setAccessible(true); + try { + field.set(actionbar, (byte)2); + } catch (IllegalArgumentException | IllegalAccessException e) { + e.printStackTrace(); + } + } catch (NoSuchFieldException | SecurityException e) { + e.printStackTrace(); + } finally { + cp.getHandle().playerConnection.sendPacket(actionbar); + } + } + +} diff --git a/src/de/joethei/core/api/AutoCommand.java b/src/de/joethei/core/api/AutoCommand.java new file mode 100644 index 0000000..403400e --- /dev/null +++ b/src/de/joethei/core/api/AutoCommand.java @@ -0,0 +1,77 @@ +package de.joethei.core.api; + +import java.lang.reflect.Field; +import java.util.ArrayList; +import java.util.List; +import org.bukkit.Bukkit; +import org.bukkit.command.Command; +import org.bukkit.command.CommandMap; +import org.bukkit.command.CommandSender; +import org.bukkit.plugin.java.JavaPlugin; + +public abstract class AutoCommand

extends Command { + + /** + * @author PostCrafter + * @see http://postcrafter.de/viewtopic.php?f=15&t=143 + */ + + private static String VERSION; + + static { + String path = Bukkit.getServer().getClass().getPackage().getName(); + + AutoCommand.VERSION = path.substring(path.lastIndexOf(".") + 1, path.length()); + + System.out.println("[PostLib] AutoCommand hook for Bukkit " + AutoCommand.VERSION); + } + + protected final P plugin; + protected final String command; + + public AutoCommand(P plugin, String command, String description, String... aliases) { + super(command); + this.plugin = plugin; + this.command = command; + + super.setDescription(description); + List aliasList = new ArrayList(); + for (String alias : aliases) { + aliasList.add(alias); + } + super.setAliases(aliasList); + + this.register(); + } + + public void register() { + try { + Field f = Class.forName("org.bukkit.craftbukkit." + AutoCommand.VERSION + ".CraftServer").getDeclaredField("commandMap"); + f.setAccessible(true); + + CommandMap map = (CommandMap) f.get(Bukkit.getServer()); + map.register(this.plugin.getName(), this); + } catch (Exception exc) { + exc.printStackTrace(); + } + } + + public abstract boolean execute(CommandSender sender, String label, String[] args); + + public abstract List tabComplete(CommandSender sender, String label, String[] args); + + public String buildString(String[] args, int start) { + String str = ""; + if (args.length > start) { + str += args[start]; + for (int i = start + 1; i < args.length; i++) { + str += " " + args[i]; + } + } + return str; + } + + public P getPlugin() { + return this.plugin; + } +} diff --git a/src/de/joethei/core/api/BanSystem.java b/src/de/joethei/core/api/BanSystem.java new file mode 100644 index 0000000..ea2d1ee --- /dev/null +++ b/src/de/joethei/core/api/BanSystem.java @@ -0,0 +1,121 @@ +package de.joethei.core.api; + +import de.joethei.core.Core; +import de.joethei.core.api.utils.NameFetcher; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.Date; +import java.util.List; +import java.util.UUID; +import org.bukkit.OfflinePlayer; +import org.bukkit.entity.Player; + +/** + * bans and unbans players + * @author joethei + * @version 1.2 + */ +public class BanSystem{ + + /** + * sets player banned + * @param p player + * @param reason reason + * @param who who banned + * @param time duration + * @throws SQLException SQL server not available or throwing error + * @throws ClassNotFoundException class couldn't be found + */ +public static void setBanned(Player p, String reason, Player who, int time)throws SQLException, ClassNotFoundException { + MySQL sql = Core.returnSQL(); + sql.openConnection(); + String uuid = p.getUniqueId().toString(); + String whouuid = who.getUniqueId().toString(); + + Date date = new Date(); + date.setTime(date.getTime() + (time + 24)); + + Core.returnSQL().getConnection().createStatement().execute("INSERT INTO bans (player_uuid, Reason, who, time) VALUES ('" + uuid + "', '" + reason + "', '" + whouuid + "', '" + date.getTime() + "');"); + p.kickPlayer("§cDu wurdest gebannt. §6Grund: " + reason + "\nDauer: " + time); + who.sendMessage("§cDu hast den Spieler " + p.getName() + " für " + time + " Tage gebannt"); + sql.closeConnection(); + } + +/** + * unbans a player + * @param p player + * @throws SQLException SQL server not available or throwing error + * @throws ClassNotFoundException class couldn't be found + */ +public static void unban(OfflinePlayer p)throws SQLException, ClassNotFoundException{ + MySQL sql = Core.returnSQL(); + sql.openConnection(); + String uuid = p.getUniqueId().toString(); + Core.returnSQL().getConnection().createStatement().executeUpdate("DELETE FROM bans WHERE player_uuid ='" + uuid + "';"); + sql.closeConnection(); + } + +/** + * checks if player is banned + * @param p player + * @return true /false + * @throws SQLException SQL server not available or throwing error + * @throws ClassNotFoundException class couldn't be found + */ +public static boolean isBanned(OfflinePlayer p)throws SQLException, ClassNotFoundException { + MySQL sql = Core.returnSQL(); + sql.openConnection(); + String uuid = p.getUniqueId().toString(); + ResultSet rs = Core.returnSQL().getConnection().createStatement().executeQuery("SELECT * FROM bans WHERE player_uuid='" + uuid + "';"); + sql.closeConnection(); + return rs.next(); + + } + +/** + * return reason for ban + * @param p player + * @return String + * @throws SQLException SQL server not available or throwing error + * @throws ClassNotFoundException class couldn't be found + */ +public static String getBanReason(OfflinePlayer p)throws SQLException, ClassNotFoundException { + MySQL sql = Core.returnSQL(); + sql.openConnection(); + String uuid = p.getUniqueId().toString(); + ResultSet rs = Core.returnSQL().getConnection().createStatement().executeQuery("SELECT * FROM bans WHERE player_uuid='" + uuid + "';"); + if (!rs.next()) { + sql.closeConnection(); + return null; + } + sql.closeConnection(); + return rs.getString("Reason"); + } + +/** + * gets the name of the player who banned the player + * @param p player + * @return String + * @throws SQLException SQL server not available or throwing error + * @throws ClassNotFoundException class couldn't be found + */ +public static String getWhoBanned(OfflinePlayer p)throws SQLException, ClassNotFoundException { + MySQL sql = Core.returnSQL(); + sql.openConnection(); + String uuid = p.getUniqueId().toString(); + ResultSet rs = Core.returnSQL().getConnection().createStatement().executeQuery("SELECT * FROM bans WHERE player_uuid='" + uuid + "';"); + if (!rs.next()) { + sql.closeConnection(); + return null; + } + String whouuid = rs.getString("who"); + UUID who = UUID.fromString(whouuid); + List list = new ArrayList(); + list.add(who); + NameFetcher name = new NameFetcher(list); + sql.closeConnection(); + return name.toString(); + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/Blackscreen.java b/src/de/joethei/core/api/Blackscreen.java new file mode 100644 index 0000000..cbab265 --- /dev/null +++ b/src/de/joethei/core/api/Blackscreen.java @@ -0,0 +1,79 @@ +package de.joethei.core.api; + +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.util.HashMap; +import java.util.Map; +import java.util.UUID; +import org.bukkit.Bukkit; +import org.bukkit.entity.Player; +import org.bukkit.plugin.Plugin; + +public class Blackscreen +{ + private static Object packetObject; + private static Class packetClass; + private static String VERSION; + private static Map ticksLeft = new HashMap(); + + static { String path = Bukkit.getServer().getClass().getPackage().getName(); + VERSION = path.substring(path.lastIndexOf(".") + 1, path.length()); + try { + packetClass = Class.forName("net.minecraft.server." + VERSION + ".Packet"); + Class packetGameStateClass = Class.forName("net.minecraft.server." + VERSION + ".PacketPlayOutGameStateChange"); + packetObject = packetGameStateClass.getConstructor(new Class[] { Integer.TYPE, Float.TYPE }).newInstance(new Object[] { Integer.valueOf(4), Integer.valueOf(0) }); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + + public static void setupUtil(Plugin instance) + { + setupUtil(instance, 2); + } + + public static void setupUtil(Plugin instance, int repeatingTicks) + { + Bukkit.getScheduler().runTaskTimer(instance, new Runnable() + { + public void run() + { + for (UUID uuid : Blackscreen.ticksLeft.keySet()) { + Player p = Bukkit.getPlayer(uuid); + if (p == null) { + Blackscreen.ticksLeft.remove(uuid); + } + else if (((Integer)Blackscreen.ticksLeft.get(uuid)).intValue() > 0) { + Blackscreen.ticksLeft.put(uuid, Integer.valueOf(((Integer)Blackscreen.ticksLeft.get(uuid)).intValue() - 2)); + Blackscreen.access(p); + } else { + Blackscreen.ticksLeft.remove(uuid); + } + } + } + } + , 0L, repeatingTicks); + } + + protected static void access(Player p) { + +} + +private static void sendPacket(Player p) { + try { + Object nmsPlayer = p.getClass().getMethod("getHandle", new Class[0]).invoke(p, new Object[0]); + Field playerConnectionField = nmsPlayer.getClass().getField("playerConnection"); + Object pConnection = playerConnectionField.get(nmsPlayer); + Method sendPacket = pConnection.getClass().getMethod("sendPacket", new Class[] { packetClass }); + sendPacket.invoke(pConnection, new Object[] { packetObject }); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + + public static void setBlack(Player p, int seconds) + { + ticksLeft.put(p.getUniqueId(), Integer.valueOf(seconds * 20)); + sendPacket(p); + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/BossBar.java b/src/de/joethei/core/api/BossBar.java new file mode 100644 index 0000000..7ff3241 --- /dev/null +++ b/src/de/joethei/core/api/BossBar.java @@ -0,0 +1,89 @@ +package de.joethei.core.api; + +import de.joethei.core.api.utils.FakeDragon; +import de.joethei.core.api.utils.FakeWither; +import java.util.HashMap; +import java.util.Map; +import org.bukkit.entity.Player; + +public class BossBar +{ + public static Map playerdragonbartask = new HashMap(); + public static Map healthdragonbartask = new HashMap(); + public static Map cooldownsdragonbar = new HashMap(); + public static Map starttimerdragonbar = new HashMap(); + + public static Map playerwitherbartask = new HashMap(); + public static Map healthwitherbartask = new HashMap(); + public static Map cooldownswitherbar = new HashMap(); + public static Map starttimerwitherbar = new HashMap(); + + public static void setBarDragon(Player p, String text) { + playerdragonbartask.put(p, text); + FakeDragon.setBossBartext(p, text); + } + + public static void setBarDragonHealth(Player p, String text, float health) + { + if ((health <= 0.0F) || (health > 100.0F)) { health = 100.0F; text = "health must be between 1 and 100 it's a %"; } + playerdragonbartask.put(p, text); + healthdragonbartask.put(p, Float.valueOf(health / 100.0F * 200.0F)); + FakeDragon.setBossBar(p, text, health); + } + + public static void setBarDragonTimer(Player p, String text, int timer) { + playerdragonbartask.put(p, text); + cooldownsdragonbar.put(p, Integer.valueOf(timer)); + if (!starttimerdragonbar.containsKey(p)) starttimerdragonbar.put(p, Integer.valueOf(timer)); + int unite = Math.round(200 / starttimerdragonbar.get(p).intValue()); + FakeDragon.setBossBar(p, text, unite * timer); + } + + public static void removeBarDragon(Player p) + { + playerdragonbartask.remove(p); + healthdragonbartask.remove(p); + cooldownsdragonbar.remove(p); + starttimerdragonbar.remove(p); + FakeDragon.removeBossBar(p); + } + + public static boolean hasBarDragon(Player p) { + return playerdragonbartask.get(p) != null; + } + + public static void setBarWither(Player p, String text) + { + playerwitherbartask.put(p, text); + FakeWither.setBossBartext(p, text); + } + + public static void setBarWitherHealth(Player p, String text, float health) + { + if ((health <= 0.0F) || (health > 100.0F)) { health = 100.0F; text = "health must be between 1 and 100 it's a %"; } + playerwitherbartask.put(p, text); + healthwitherbartask.put(p, Float.valueOf(health / 100.0F * 300.0F)); + FakeWither.setBossBar(p, text, health); + } + + public static void setBarWitherTimer(Player p, String text, int timer) { + playerwitherbartask.put(p, text); + cooldownswitherbar.put(p, Integer.valueOf(timer)); + if (!starttimerwitherbar.containsKey(p)) starttimerwitherbar.put(p, Integer.valueOf(timer)); + int unite = Math.round(300 / starttimerwitherbar.get(p).intValue()); + FakeWither.setBossBar(p, text, unite * timer); + } + + public static void removeBarWither(Player p) + { + playerwitherbartask.remove(p); + healthwitherbartask.remove(p); + cooldownswitherbar.remove(p); + starttimerwitherbar.remove(p); + FakeWither.removeBossBar(p); + } + + public static boolean hasBarWither(Player p) { + return playerwitherbartask.get(p) != null; + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/Config.java b/src/de/joethei/core/api/Config.java new file mode 100644 index 0000000..9086a9d --- /dev/null +++ b/src/de/joethei/core/api/Config.java @@ -0,0 +1,165 @@ +package de.joethei.core.api; + +import java.io.File; +import java.io.IOException; +import java.sql.SQLException; + +import org.bukkit.Bukkit; +import org.bukkit.Location; +import org.bukkit.configuration.file.FileConfiguration; +import org.bukkit.configuration.file.YamlConfiguration; + +/** + * gets data from config file + * @author joethei + * @version 1.1 + */ +public class Config { + + private static File file = new File("plugins/Core", "config.yml"); + private static FileConfiguration cfg = YamlConfiguration.loadConfiguration(file); + + /** + * write default data to config + * @throws ClassNotFoundException Class couldn't be found + * @throws SQLException SQL server not available or throwing error + * @throws IOException I/O failed + */ + public static void writeDefault() throws ClassNotFoundException, SQLException, IOException { + //editable messages will be set here, but do not edit this messages. + + //seting the default MySQL config. + cfg.set("MySQL.Host", "192.168.0.101"); + cfg.set("MySQL.Port", "3306"); + cfg.set("MySQL.DB", "core"); + cfg.set("MySQL.User", "root");//best user name + cfg.set("MySQL.Pass", "");//best password + + cfg.save(file); + + } + + /** + * write data as string to config + * @param path path to data + * @param obj data + */ + public static void write(String path, String obj) { + cfg.set(path, obj); + try { + cfg.save(file); + } catch (IOException e) { + e.printStackTrace(); + } + } + + /** + * write data as integer to config + * @param path path to data + * @param obj data + */ + public static void write(String path, int obj) { + cfg.set(path, obj); + try { + cfg.save(file); + } catch (IOException e) { + e.printStackTrace(); + } + } + + /** + * write data as double to config + * @param path path to data + * @param obj data + */ + public static void write(String path, double obj) { + cfg.set(path, obj); + try { + cfg.save(file); + } catch (IOException e) { + e.printStackTrace(); + } + } + + + /** + * write location to config + * @param path path to data + * @param loc location + */ + public static void write(String path, Location loc) { + String world = loc.getWorld().getName(); + double x = loc.getX(); + double y = loc.getY(); + double z = loc.getZ(); + double yaw = (double) loc.getYaw(); + double pitch = (double) loc.getPitch(); + + cfg.set(path + ".World", world); + cfg.set(path + ".X", x); + cfg.set(path + ".Y", y); + cfg.set(path + ".Z", z); + cfg.set(path + ".Yaw", yaw); + cfg.set(path + ".Pitch", pitch); + + try { + cfg.save(file); + } catch (IOException e) { + e.printStackTrace(); + } + } + + /** + * read integer from config + * @param path path to data + * @return Integer + */ + public static int readInt(String path) { + return cfg.getInt(path); + } + + /** + * read double from config + * @param path path to data + * @return Double + */ + public static double readDouble(String path) { + return cfg.getDouble(path); + } + + /** + * read string from config + * @param path path to data + * @return String + */ + public static String readString(String path) { + return cfg.getString(path); + } + + /** + * read location from config + * @param path path to data + * @return Location + */ + public static Location readLocation(String path) { + String world = cfg.getString(path + ".World"); + double x = cfg.getDouble(path + ".X"); + double y = cfg.getDouble(path + ".Y"); + double z = cfg.getDouble(path + ".Z"); + float yaw = (float) cfg.getDouble(path + ".Yaw"); + float pitch = (float) cfg.getDouble(path + ".Pitch"); + + Location loc = new Location(Bukkit.getWorld(world), x, y, z, yaw, pitch); + return loc; + } + + /** + * checks if data is existing + * @param path path do data + * @return true / false + */ + public static boolean isExsisting(String path) { + return cfg.contains(path); + } + +} \ No newline at end of file diff --git a/src/de/joethei/core/api/CustomPlayer.java b/src/de/joethei/core/api/CustomPlayer.java new file mode 100644 index 0000000..24f218a --- /dev/null +++ b/src/de/joethei/core/api/CustomPlayer.java @@ -0,0 +1,295 @@ +package de.joethei.core.api; + +import java.sql.SQLException; +import java.util.HashMap; + +import org.bukkit.Bukkit; +import org.bukkit.craftbukkit.v1_8_R3.CraftServer; +import org.bukkit.craftbukkit.v1_8_R3.entity.CraftPlayer; +import org.bukkit.entity.Player; + +import de.joethei.core.api.Perms.Ranks; + +/** + * custom player implementation + * @author joethei + * @version 1.0 + */ +public class CustomPlayer extends CraftPlayer { + + /** + * all normal players + */ + private static final HashMap 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; + + /** + * inits player + * @param player Player + */ + private CustomPlayer(Player player) { + super((CraftServer) Bukkit.getServer(), ((CraftPlayer) player).getHandle()); + PLAYERS.put(player.getName().toLowerCase(), this); + PLAYER = player; + } + + /** + * 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); + } + } + + /** + * get normal player + * @return Player + */ + public Player getPLAYER() { + return PLAYER; + } + + /** + * connects player to server in bungeecord + * @param server Server 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(Ranks rank) { + try { + return Perms.isAllowed(this, rank); + } catch (ClassNotFoundException | SQLException e) { + e.printStackTrace(); + return false; + } + } + + /** + * gets fresh rank of player + * @return Ranks + */ + public Ranks getRankFresh() { + try { + return Perms.getRankFresh(this); + } catch (SQLException | ClassNotFoundException e) { + e.printStackTrace(); + return null; + } + } + + /** + * rank of player + * @return Ranks + */ + public Ranks getRank() { + return Perms.getRank(this); + } + + /** + * prefix of player + * @return String + */ + public String getPrefix() { + if(customPrefix != null) { + return customPrefix; + }else { + return Perms.getPrefix(this); + } + } + + /** + * suffix of player + * @return String + */ + public String getSuffix() { + if(customSuffix != null) { + return customSuffix; + } + return Perms.getSuffix(this); + } + + /** + * color of player (Ranks) + * @return String + */ + public String getColor() { + if(customColor != null) { + return customColor; + } + return Perms.getColor(this); + } + + /** + * 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; + } + + /** + * if player is muted + * @return true/false + */ + public boolean isMuted() { + try { + return MuteSystem.isMuted(PLAYER); + } catch (SQLException | ClassNotFoundException e) { + e.printStackTrace(); + return false; + } + } + + /** + * 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(PLAYER, reason, who.getPLAYER(), time); + } catch (SQLException | ClassNotFoundException e) { + e.printStackTrace(); + } + } + /** + * if player is banned + * @return true/false + */ + public boolean isBanned() { + try { + return BanSystem.isBanned(PLAYER); + } catch (SQLException | ClassNotFoundException e) { + e.printStackTrace(); + return false; + } + } + + /** + * get ban reason + * @return String + */ + public String getBanReason() { + try { + return BanSystem.getBanReason(PLAYER); + } catch (SQLException | ClassNotFoundException e) { + e.printStackTrace(); + return null; + } + + } + + /** + * get uuid of player who banned + * @return String + */ + public String getWhoBanned() { + try { + return BanSystem.getWhoBanned(PLAYER); + } catch (SQLException | ClassNotFoundException e) { + e.printStackTrace(); + return null; + } + } + + /** + * unbans the player + */ + public void unban() { + try { + BanSystem.unban(PLAYER); + } catch (SQLException | ClassNotFoundException e) { + e.printStackTrace(); + } + } + + /** + * get nickname of player + * @return String + */ + public String getNick() { + return NickName.getNick(PLAYER); + } + + /** + * if player is nicked + * @return true/false + */ + public boolean isNicked() { + try { + return NickName.isNicked(PLAYER); + } catch (SQLException | ClassNotFoundException e) { + e.printStackTrace(); + return false; + } + } + + /** + * sets nickname + * @param is boolean + */ + public void setNick(boolean is) { + try { + NickName.setNick(PLAYER, is); + } catch (SQLException | ClassNotFoundException e) { + e.printStackTrace(); + } + } + +} \ No newline at end of file diff --git a/src/de/joethei/core/api/Database.java b/src/de/joethei/core/api/Database.java new file mode 100644 index 0000000..a8d3676 --- /dev/null +++ b/src/de/joethei/core/api/Database.java @@ -0,0 +1,71 @@ +package de.joethei.core.api; + +import java.sql.Connection; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Statement; +import org.bukkit.plugin.Plugin; + +public abstract class Database +{ + protected Connection connection; + protected Plugin plugin; + + protected Database(Plugin plugin) + { + this.plugin = plugin; + this.connection = null; + } + + public abstract Connection openConnection() + throws SQLException, ClassNotFoundException; + + public boolean checkConnection() + throws SQLException + { + return (this.connection != null) && (!this.connection.isClosed()); + } + + public Connection getConnection() + { + return this.connection; + } + + public boolean closeConnection() + throws SQLException + { + if (this.connection == null) { + return false; + } + this.connection.close(); + return true; + } + + public ResultSet querySQL(String query) + throws SQLException, ClassNotFoundException + { + if (!checkConnection()) { + openConnection(); + } + + Statement statement = this.connection.createStatement(); + + ResultSet result = statement.executeQuery(query); + + return result; + } + + public int updateSQL(String query) + throws SQLException, ClassNotFoundException + { + if (!checkConnection()) { + openConnection(); + } + + Statement statement = this.connection.createStatement(); + + int result = statement.executeUpdate(query); + + return result; + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/EntityModifier.java b/src/de/joethei/core/api/EntityModifier.java new file mode 100644 index 0000000..523c3d0 --- /dev/null +++ b/src/de/joethei/core/api/EntityModifier.java @@ -0,0 +1,233 @@ +package de.joethei.core.api; + +import java.lang.reflect.Field; +import net.minecraft.server.v1_8_R3.EntityLiving; +import net.minecraft.server.v1_8_R3.NBTTagCompound; +import org.bukkit.Bukkit; +import org.bukkit.EntityEffect; +import org.bukkit.Location; +import org.bukkit.craftbukkit.v1_8_R3.entity.CraftCreature; +import org.bukkit.craftbukkit.v1_8_R3.entity.CraftEntity; +import org.bukkit.entity.Player; +import org.bukkit.plugin.Plugin; + +public class EntityModifier +{ + static org.bukkit.entity.Entity entity; + static CraftEntity craftentity; + static net.minecraft.server.v1_8_R3.Entity entityS; + static int scheduler; + static Plugin plugin; + static Player player = null; + static float Speed; + + public EntityModifier(org.bukkit.entity.Entity entity, Plugin plugin) + { + EntityModifier.entity = entity; + craftentity = (CraftEntity)entity; + entityS = craftentity.getHandle(); + EntityModifier.plugin = plugin; + } + + public static Builder modify() + { + return new Builder(); + } + + public static final class Builder + { + public Builder setDisplayName(String display) + { + EntityModifier.entity.setCustomName(display); + EntityModifier.entity.setCustomNameVisible(true); + return this; + } + + public Builder setDisplayNameVisible(Boolean visible) + { + EntityModifier.entity.setCustomNameVisible(visible.booleanValue()); + return this; + } + + public Builder playEffekt(EntityEffect entityeffect) + { + EntityModifier.entity.playEffect(entityeffect); + return this; + } + + public Builder remove() + { + EntityModifier.entity.remove(); + return this; + } + + public Builder setPassenger(org.bukkit.entity.Entity passenger) + { + EntityModifier.entity.setPassenger(passenger); + return this; + } + + public Builder setFireTicks(int ticks) + { + EntityModifier.entity.setFireTicks(ticks); + return this; + } + + public Builder setLocation(Location location) + { + teleport(location); + return this; + } + + public Builder setYawPitch(float yaw, float pitch) + { + Location loc = EntityModifier.entity.getLocation().clone(); + teleport( + new Location(loc.getWorld(), loc.getX(), loc.getY(), + loc.getZ(), yaw, pitch)); + return this; + } + + public Builder teleport(Location location) + { + EntityModifier.entity.teleport(location); + return this; + } + + public Builder die() + { + EntityModifier.entityS.die(); + return this; + } + + public Builder setInvisible(boolean invisible) + { + EntityModifier.entityS.setInvisible(invisible); + return this; + } + + public Builder noClip(boolean noClip) + { + EntityModifier.entityS.noclip = noClip; + return this; + } + + public Builder setInvulnerable(boolean invulnerable) + { + try + { + Field invulnerableField = net.minecraft.server.v1_8_R3.Entity.class + .getDeclaredField("invulnerable"); + invulnerableField.setAccessible(true); + invulnerableField.setBoolean(EntityModifier.entityS, invulnerable); + } catch (Exception ex) { + ex.printStackTrace(); + } + return this; + } + + public Builder setNoAI(boolean noAI) + { + NBTTagCompound tag = new NBTTagCompound(); + EntityModifier.entityS.c(tag); + tag.setBoolean("NoAI", noAI); + EntityLiving el = (EntityLiving)EntityModifier.entityS; + el.a(tag); + return this; + } + + public Builder setSilent(boolean silent) + { + NBTTagCompound tag = new NBTTagCompound(); + EntityModifier.entityS.c(tag); + tag.setBoolean("Silent", silent); + EntityLiving el = (EntityLiving)EntityModifier.entityS; + el.a(tag); + return this; + } + + public Builder setCanPickUpLoot(boolean canpickuploot) + { + NBTTagCompound tag = new NBTTagCompound(); + EntityModifier.entityS.c(tag); + tag.setBoolean("CanPickUpLoot", canpickuploot); + EntityLiving el = (EntityLiving)EntityModifier.entityS; + el.a(tag); + return this; + } + + public Builder setHealth(float health) + { + NBTTagCompound tag = new NBTTagCompound(); + EntityModifier.entityS.c(tag); + tag.setFloat("HealF", health); + EntityLiving el = (EntityLiving)EntityModifier.entityS; + el.a(tag); + return this; + } + + public Builder setCanDespawn(boolean candespawn) + { + candespawn = !candespawn; + NBTTagCompound tag = new NBTTagCompound(); + EntityModifier.entityS.c(tag); + tag.setBoolean("PersistenceRequired", candespawn); + EntityLiving el = (EntityLiving)EntityModifier.entityS; + el.a(tag); + return this; + } + + public Builder walkToLocation(Location location, float speed) + { + ((CraftCreature)EntityModifier.entity) + .getHandle() + .getNavigation() + .a(location.getX(), location.getY(), location.getZ(), speed); + return this; + } + + public Builder followPlayer(Player target, float speed) + { + EntityModifier.player = target; + EntityModifier.Speed = speed; + EntityModifier.scheduler = Bukkit.getScheduler().scheduleSyncRepeatingTask(EntityModifier.plugin, + new Runnable() + { + @SuppressWarnings("deprecation") + public void run() { + double distance = EntityModifier.entity.getLocation().distance( + EntityModifier.player.getLocation()); + if (distance < 11.0D) { + float speed = EntityModifier.Speed; + if (distance < 3.0D) { + speed = 0.0F; + } + ((CraftCreature)EntityModifier.entity) + .getHandle() + .getNavigation() + .a(EntityModifier.player.getLocation().getX(), + EntityModifier.player.getLocation().getY(), + EntityModifier.player.getLocation().getZ(), + speed); + } + else if (EntityModifier.player.isOnGround()) { + EntityModifier.entity.teleport(EntityModifier.player); + } + } + } + , 0L, 1L); + return this; + } + + public Builder stopFollowingPlayer() + { + Bukkit.getScheduler().cancelTask(EntityModifier.scheduler); + return this; + } + + public org.bukkit.entity.Entity build() + { + return EntityModifier.entity; + } + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/Hologram.java b/src/de/joethei/core/api/Hologram.java new file mode 100644 index 0000000..1e18174 --- /dev/null +++ b/src/de/joethei/core/api/Hologram.java @@ -0,0 +1,148 @@ +package de.joethei.core.api; + +import java.lang.reflect.Constructor; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.List; +import org.bukkit.Bukkit; +import org.bukkit.Location; +import org.bukkit.World; +import org.bukkit.entity.Player; + +public class Hologram +{ + private List 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 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; +} +} \ No newline at end of file diff --git a/src/de/joethei/core/api/ItemSkulls.java b/src/de/joethei/core/api/ItemSkulls.java new file mode 100644 index 0000000..fdbe580 --- /dev/null +++ b/src/de/joethei/core/api/ItemSkulls.java @@ -0,0 +1,123 @@ +package de.joethei.core.api; + +import com.mojang.authlib.GameProfile; +import com.mojang.authlib.properties.Property; +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.util.Base64; +import java.util.UUID; +import org.bukkit.Location; +import org.bukkit.Material; +import org.bukkit.block.Block; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.SkullMeta; + +public class ItemSkulls +{ + private static Class skullMetaClass; + private static Class tileEntityClass; + private static Class blockPositionClass; + private static int mcVersion; + + static + { + String version = org.bukkit.Bukkit.getServer().getClass().getPackage().getName() + .split("\\.")[3]; + mcVersion = Integer.parseInt(version.replaceAll("[^0-9]", "")); + try { + skullMetaClass = Class.forName("org.bukkit.craftbukkit." + version + + ".inventory.CraftMetaSkull"); + tileEntityClass = Class.forName("net.minecraft.server." + version + + ".TileEntitySkull"); + if (mcVersion > 174) + blockPositionClass = Class.forName("net.minecraft.server." + + version + ".BlockPosition"); + else + blockPositionClass = null; + } + catch (ClassNotFoundException e) { + e.printStackTrace(); + } + } + + public static ItemStack getSkull(String skinURL) + { + return getSkull(skinURL, 1); + } + + public static ItemStack getSkull(String skinURL, int amount) + { + ItemStack skull = new ItemStack(Material.SKULL_ITEM, amount, (short) 3); + SkullMeta meta = (SkullMeta)skull.getItemMeta(); + try { + Field profileField = skullMetaClass.getDeclaredField("profile"); + profileField.setAccessible(true); + profileField.set(meta, getProfile(skinURL)); + } catch (Exception ex) { + ex.printStackTrace(); + } + skull.setItemMeta(meta); + return skull; + } + + public static boolean setBlock(Location loc, String skinURL) + { + return setBlock(loc.getBlock(), skinURL); + } + + public static boolean setBlock(Block block, String skinURL) + { + boolean flag = block.getType() == Material.SKULL; + if (!flag) + block.setType(Material.SKULL); + try + { + Object nmsWorld = block.getWorld().getClass() + .getMethod("getHandle", new Class[0]).invoke(block.getWorld(), new Object[0]); + Object tileEntity = null; + + if (mcVersion <= 174) { + Method getTileEntity = nmsWorld.getClass().getMethod( + "getTileEntity", new Class[] { Integer.TYPE, Integer.TYPE, Integer.TYPE }); + tileEntity = tileEntityClass.cast(getTileEntity.invoke( + nmsWorld, new Object[] { Integer.valueOf(block.getX()), Integer.valueOf(block.getY()), Integer.valueOf(block.getZ()) })); + } else { + Method getTileEntity = nmsWorld.getClass().getMethod( + "getTileEntity", new Class[] { blockPositionClass }); + tileEntity = tileEntityClass.cast(getTileEntity.invoke( + nmsWorld, new Object[] { + getBlockPositionFor(block.getX(), block.getY(), + block.getZ()) })); + } + + tileEntityClass.getMethod("setGameProfile", new Class[] { GameProfile.class }) + .invoke(tileEntity, new Object[] { getProfile(skinURL) }); + } catch (Exception ex) { + ex.printStackTrace(); + } + return !flag; + } + + private static GameProfile getProfile(String skinURL) { + GameProfile profile = new GameProfile(UUID.randomUUID(), null); + String base64encoded = Base64.getEncoder().encodeToString( + new String("{textures:{SKIN:{url:\"" + skinURL + "\"}}}") + .getBytes()); + Property property = new Property("textures", base64encoded); + profile.getProperties().put("textures", property); + return profile; + } + + private static Object getBlockPositionFor(int x, int y, int z) { + Object blockPosition = null; + try { + Constructor cons = blockPositionClass.getConstructor(new Class[] { Integer.TYPE, + Integer.TYPE, Integer.TYPE }); + blockPosition = cons.newInstance(new Object[] { Integer.valueOf(x), Integer.valueOf(y), Integer.valueOf(z) }); + } catch (Exception ex) { + ex.printStackTrace(); + } + return blockPosition; + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/Letters.java b/src/de/joethei/core/api/Letters.java new file mode 100644 index 0000000..12c8f3a --- /dev/null +++ b/src/de/joethei/core/api/Letters.java @@ -0,0 +1,577 @@ +package de.joethei.core.api; + +import de.joethei.core.api.utils.Direction; +import java.util.ArrayList; +import java.util.List; +import org.bukkit.Location; +import org.bukkit.Material; +import org.bukkit.block.Block; + +public enum Letters +{ + LETTER_A('a', + new boolean[][] { + { false, true }, + { true, false, true }, + { true, false, true }, + { true, true, true }, + { true, false, true } }), + + LETTER_B('b', + new boolean[][] { + { true, true }, + { true, false, true }, + { true, true, true }, + { true, false, true }, + { true, true } }), + + LETTER_C('c', + new boolean[][] { + { false, true, true }, + { true }, + { true }, + { true }, + { false, true, true } }), + + LETTER_D('d', + new boolean[][] { + { true, true }, + { true, false, true }, + { true, false, true }, + { true, false, true }, + { true, true } }), + + LETTER_E('e', + new boolean[][] { + { true, true, true }, + { true }, + { true, true }, + { true }, + { true, true, true } }), + + LETTER_F('f', + new boolean[][] { + { true, true, true }, + { true }, + { true, true }, + { true }, + { true } }), + + LETTER_G('g', + new boolean[][] { + { false, true, true }, + { true }, + { true, false, true, true }, + { true, false, false, true }, + { false, true, true, true } }), + + LETTER_H('h', + new boolean[][] { + { true, false, true }, + { true, false, true }, + { true, true, true }, + { true, false, true }, + { true, false, true } }), + + LETTER_I('i', + new boolean[][] { + { true }, + { true }, + { true }, + { true }, + { true } }), + + LETTER_J('j', + new boolean[][] { + { false, false, true }, + { false, false, true }, + { false, false, true }, + { true, false, true }, + { true, true, true } }), + + LETTER_K('k', + new boolean[][] { + { true, false, false, true }, + { true, false, true }, + { true, true }, + { true, false, true }, + { true, false, false, true } }), + + LETTER_L('l', + new boolean[][] { + { true }, + { true }, + { true }, + { true }, + { true, true, true } }), + + LETTER_M('m', + new boolean[][] { + { true, true, true, true, true }, + { true, false, true, false, true }, + { true, false, true, false, true }, + { true, false, false, false, true }, + { true, false, false, false, true } }), + + LETTER_N('n', + new boolean[][] { + { true, false, false, true }, + { true, true, false, true }, + { true, false, true, true }, + { true, false, false, true }, + { true, false, false, true } }), + + LETTER_O('o', + new boolean[][] { + { false, true }, + { true, false, true }, + { true, false, true }, + { true, false, true }, + { false, true } }), + + LETTER_P('p', + new boolean[][] { + { true, true }, + { true, false, true }, + { true, true }, + { true }, + { true } }), + + LETTER_Q('q', + new boolean[][] { + { false, true, true }, + { true, false, false, true }, + { true, false, false, true }, + { true, false, true, true }, + { false, true, true } }), + + LETTER_R('r', + new boolean[][] { + { true, true }, + { true, false, true }, + { true, false, true }, + { true, true }, + { true, false, true } }), + + LETTER_S('s', + new boolean[][] { + { false, true, true }, + { true }, + { false, true }, + { false, false, true }, + { true, true } }), + + LETTER_T('t', + new boolean[][] { + { true, true, true }, + { false, true }, + { false, true }, + { false, true }, + { false, true } }), + + LETTER_U('u', + new boolean[][] { + { true, false, true }, + { true, false, true }, + { true, false, true }, + { true, false, true }, + { false, true } }), + + LETTER_V('v', + new boolean[][] { + { true, false, false, false, true }, + { true, false, false, false, true }, + { false, true, false, true }, + { false, true, false, true }, + { false, false, true } }), + + LETTER_W('w', + new boolean[][] { + { true, false, false, false, true }, + { true, false, false, false, true }, + { true, false, false, false, true }, + { true, false, true, false, true }, + { true, true, true, true, true } }), + + LETTER_X('x', + new boolean[][] { + { true, false, false, false, true }, + { false, true, false, true }, + { false, false, true }, + { false, true, false, true }, + { true, false, false, false, true } }), + + LETTER_Y('y', + new boolean[][] { + { true, false, false, true }, + { false, true, true }, + { false, false, true }, + { false, true }, + { true } }), + + LETTER_Z('z', + new boolean[][] { + { true, true, true, true, true }, + { false, false, false, true }, + { false, false, true }, + { false, true }, + { true, true, true, true, true } }), + + LETTER_0('0', + new boolean[][] { + { true, true, true }, + { true, false, true }, + { true, false, true }, + { true, false, true }, + { true, true, true } }), + + LETTER_1('1', + new boolean[][] { + { true, true }, + { false, true }, + { false, true }, + { false, true }, + { true, true, true } }), + + LETTER_2('2', + new boolean[][] { + { true, true }, + { false, false, true }, + { false, true }, + { true }, + { true, true, true } }), + + LETTER_3('3', + new boolean[][] { + { true, true }, + { false, false, true }, + { true, true }, + { false, false, true }, + { true, true } }), + + LETTER_4('4', + new boolean[][] { + { true, false, true }, + { true, false, true }, + { true, true, true }, + { false, false, true }, + { false, false, true } }), + + LETTER_5('5', + new boolean[][] { + { true, true, true }, + { true }, + { true, true, true }, + { false, false, true }, + { true, true, true } }), + + LETTER_6('6', + new boolean[][] { + { true, true, true }, + { true }, + { true, true, true }, + { true, false, true }, + { true, true, true } }), + + LETTER_7('7', + new boolean[][] { + { true, true, true }, + { false, false, true }, + { false, false, true }, + { false, false, true }, + { false, false, true } }), + + LETTER_8('8', + new boolean[][] { + { true, true, true }, + { true, false, true }, + { true, true, true }, + { true, false, true }, + { true, true, true } }), + + LETTER_9('9', + new boolean[][] { + { true, true, true }, + { true, false, true }, + { true, true, true }, + { false, false, true }, + { true, true, true } }), + + LETTER_DOT('.', + new boolean[][] { + { true } }), + + LETTER_UNDERSCORE('_', + new boolean[][] { + { true, true, true } }), + + LETTER_SPACE(' ', + new boolean[][] { + new boolean[3] }), + + LETTER_PERCENT('%', + new boolean[][] { + { true, false, false, false, true }, + { false, false, false, true }, + { false, false, true }, + { false, true }, + { true, false, false, false, true } }), + + LETTER_UP_ARROW('^', + new boolean[][] { + { false, false, true }, + { false, true, false, true }, + { true, false, false, false, true }, + new boolean[5], + new boolean[5] }), + + LETTER_LEFT_ARROW('<', + new boolean[][] { + { false, false, true }, + { false, true }, + { true }, + { false, true }, + { false, false, true } }), + + LETTER_RIGHT_ARROW('>', + new boolean[][] { + { true }, + { false, true }, + { false, false, true }, + { false, true }, + { true } }), + + LETTER_AMPERSAND('*', + new boolean[][] { + { true, false, true, false, true }, + { false, true, true, true }, + { true, true, true, true, true }, + { false, true, true, true }, + { true, false, true, false, true } }), + + LETTER_HASHTAG('#', + new boolean[][] { + { false, true, false, true }, + { true, true, true, true, true }, + { false, true, false, true }, + { true, true, true, true, true }, + { false, true, false, true } }), + + LETTER_COMMA(',', + new boolean[][] { + { true }, + { true } }), + + LETTER_COLON(':', + new boolean[][] { + { true }, + new boolean[1], + new boolean[1], + new boolean[1], + { true } }), + + LETTER_DASH('-', + new boolean[][] { + { true, true, true }, + new boolean[3], + new boolean[3] }), + + LETTER_PLUS('+', + new boolean[][] { + { false, false, true }, + { false, false, true }, + { true, true, true, true, true }, + { false, false, true }, + { false, false, true } }), + + LETTER_MINUS('-', + new boolean[][] { + { true, true, true, true, true }, + new boolean[5], + new boolean[5] }), + + LETTER_EQUAL('=', + new boolean[][] { + { true, true, true, true, true }, + new boolean[5], + { true, true, true, true, true }, + new boolean[5] }), + + LETTER_LEFT_ROUND_BRACKET('(', + new boolean[][] { + { false, true }, + { true }, + { true }, + { true }, + { false, true } }), + + LETTER_RIGHT_ROUND_BRACKET(')', + new boolean[][] { + { true }, + { false, true }, + { false, true }, + { false, true }, + { true } }), + + LETTER_LEFT_SQUARE_BRACKET('[', + new boolean[][] { + { true, true }, + { true }, + { true }, + { true }, + { true, true } }), + + LETTER_RIGHT_SQUARE_BRACKET(']', + new boolean[][] { + { true, true }, + { false, true }, + { false, true }, + { false, true }, + { true, true } }), + + LETTER_QUESTION('?', + new boolean[][] { + { true, true, true }, + { false, false, true }, + { false, true, true }, + new boolean[3], + { false, true } }); + + private char character; + private int height; + private int width; + private boolean[][] blocks; + + private Letters(char character, boolean[][] blocks) { + this.character = character; + this.blocks = blocks; + this.height = blocks.length; + this.width = blocks[0].length; + boolean[][] reversed = new boolean[this.height][this.width]; + for (int i = 0; i < this.height; i++) + { + reversed[(this.height - i - 1)] = blocks[i]; + } + this.blocks = reversed; + } + + public int getWidth() { + return this.width; + } + + public int getHeight() { + return this.height; + } + + public char getCharacter() { + return this.character; + } + + @SuppressWarnings("deprecation") +public void draw(Material type, byte data, Location loc, Direction dir) + { + for (int y = 0; y < this.height; y++) + { + for (int x = 0; x < this.width; x++) + { + Location l = loc.clone().add(x * dir.getX(), y, x * dir.getZ()); + if ((l.getBlock() == null) || (this.blocks[y][x] == 0)) + continue; + l.getBlock().setType(type); + l.getBlock().setData(data); + } + } + } + + public static int strHeight() + { + return 5; + } + + public static int strHeight(String[] str) { + return (strHeight() + 1) * str.length - 1; + } + + public static int strWidth(String str) { + int w = 0; + List letters = fromString(str); + for (Letters l : letters) + { + w += l.getWidth() + 1; + } + return w > 0 ? w - 1 : w; + } + + public static int strWidth(String[] str) { + int width = 0; + String[] arrayOfString = str; int j = str.length; for (int i = 0; i < j; i++) { String s = arrayOfString[i]; + + if (strWidth(s) > width) + width = strWidth(s); + } + return width; + } + + public static void centreString(String text, Material type, byte data, Location centre, Direction dir) + { + int width = strWidth(text); + Location start = centre.subtract(width / 2 * dir.getX(), 0.0D, width / 2 * + dir.getZ()); + drawString(text, type, data, start, dir); + } + + public static void centreString(String[] text, Material type, byte data, Location centre, Direction dir) + { + int height = 0; + String[] arrayOfString = text; int j = text.length; for (int i = 0; i < j; i++) { String s = arrayOfString[i]; + + height++; + height += strHeight(); + centreString(s, type, data, centre.clone().subtract(0.0D, height, 0.0D), dir); } + } + + public static void drawString(String str, Material type, byte data, Location loc, Direction dir) + { + List letters = fromString(str); + for (Letters l : letters) + { + l.draw(type, data, loc.clone(), dir); + loc = loc.add((l.getWidth() + 1) * dir.getX(), 0.0D, (l.getWidth() + 1) * + dir.getZ()); + } + } + + public static void drawString(String[] text, Material type, byte data, Location loc, Direction dir) { + int height = 0; + String[] arrayOfString = text; int j = text.length; for (int i = 0; i < j; i++) { String s = arrayOfString[i]; + + height++; + height += strHeight(); + centreString(s, type, data, loc.clone().subtract(0.0D, height, 0.0D), dir); } + } + + public static Letters fromCharacter(char character) + { + for (Letters l : values()) + { + if (l.character.equalsIgnoreCase(character)) + { + return l; + } + } + return null; + } + + public static List fromString(String string) { + List letters = new ArrayList(); + for (char character : string.toCharArray()) + { + Letters l = fromCharacter(character); + if (l == null) + continue; + letters.add(l); + } + + return letters; + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/Messages.java b/src/de/joethei/core/api/Messages.java new file mode 100644 index 0000000..947b765 --- /dev/null +++ b/src/de/joethei/core/api/Messages.java @@ -0,0 +1,88 @@ +package de.joethei.core.api; + +import java.sql.ResultSet; +import java.sql.SQLException; + +import de.joethei.core.Core; + +/** + * messages from database + * @author joethei + * @version 1.0 + */ +public class Messages { + + public static String PREFIX; + public static String CONSOLE_PREFIX; + public static String UNKNOWN_ERROR; + public static String NOT_A_PLAYER; + public static String NO_PERMS; + public static String ERROR; + public static String NOT_ONLINE; + public static String KICK_RESTART; + public static String KICK_FULL; + + /** + * write default data + * @throws ClassNotFoundException Class couldn't be found + * @throws SQLException SQL server not available or throwing error + */ + public static void writeDefault() throws ClassNotFoundException, SQLException { + //editable messages will be set here, but do not edit this messages. + MySQL sql = Core.returnSQL(); + sql.openConnection(); + sql.getConnection().createStatement().execute("INSERT INTO MESSAGES(Ident, Message) values ('Prefix', '§aunivento §8»');"); + sql.getConnection().createStatement().execute("INSERT INTO Messages(Ident, Message) values ('ConsolePrefix', '[univento Core]');"); + sql.getConnection().createStatement().execute("INSERT INTO Messages(Ident, Message) values ('UnknownError', '§cEs ist leider ein unbekannter Fehler aufgetreten');"); + sql.getConnection().createStatement().execute("INSERT INTO Messages(Ident, Message) values ('Commands.NoPlayer', '§cDu bist leider kein Spieler');"); + sql.getConnection().createStatement().execute("INSERT INTO Messages(Ident, Message) values ('Commands.NoPerms', '§cDu hast keine Berechtigungen diesen Befehl auszuführen')"); + sql.getConnection().createStatement().execute("INSERT INTO Messages(Ident, Message) values ('Commands.Error', '§cBeim ausführen dieses Befehls ist ein Fehler aufgetreten');"); + sql.getConnection().createStatement().execute("INSERT INTO Messages(Ident, Message) values ('Commands.NotOnline', '§cDer Spieler $player ist nicht online');"); + sql.getConnection().createStatement().execute("INSERT INTO Messages(Ident, Message) values ('Commands.Unknown', '§6Der Befehl $cmd konnte leider nicht gefunden werden');"); + sql.getConnection().createStatement().execute("INSERT INTO Messages(Ident, Message) values ('Kick.Restart', '§cDer Server startet gerade neu');"); + sql.getConnection().createStatement().execute("INSERT INTO Messages(Ident, Message) values ('Kick.Full', '§cDer Server ist leider schon voll')"); + + sql.closeConnection(); + + } + + /** + * reads all string to variables + * @throws ClassNotFoundException Class couldn't be found + * @throws SQLException SQL server not available or throwing error + */ + public static void readStrings() throws ClassNotFoundException, SQLException { + PREFIX = readString("Prefix") + " "; + CONSOLE_PREFIX = readString("ConsolePrefix") + " "; + UNKNOWN_ERROR = readString("UnknownError") + " "; + NOT_A_PLAYER = readString("Commands.NoPlayer") + " "; + NO_PERMS = readString("Commands.NoPerms") + " "; + ERROR = readString("Commands.Error") + " "; + NOT_ONLINE = readString("Commands.NotOnline") + " "; + KICK_RESTART = readString("Kick.Restart") + " "; + KICK_FULL = readString("Kick.Full") + " "; + } + + /** + * reads single message from database + * @param path path + * @return String + */ + public static String readString(String path) { + MySQL sql = Core.returnSQL(); + try { + sql.openConnection(); + ResultSet rs = sql.getConnection().createStatement().executeQuery("SELECT * FROM Messages WHERE Ident='" + path + "';"); + if (!rs.next()) { + sql.closeConnection(); + return null; + } + sql.closeConnection(); + return rs.getString("Message"); + } catch (ClassNotFoundException | SQLException e) { + e.printStackTrace(); + return null; + } + } + +} \ No newline at end of file diff --git a/src/de/joethei/core/api/MojangService.java b/src/de/joethei/core/api/MojangService.java new file mode 100644 index 0000000..76ba579 --- /dev/null +++ b/src/de/joethei/core/api/MojangService.java @@ -0,0 +1,120 @@ +package de.joethei.core.api; + +import java.io.BufferedReader; +import java.io.InputStreamReader; +import java.net.URL; +import org.json.simple.JSONObject; +import org.json.simple.parser.JSONParser; + +public class MojangService +{ + private static JSONParser parser = new JSONParser(); + + public static ServiceStatus getStatus(MinecraftServer service) + { + String status = null; + try + { + URL url = new URL("http://status.mojang.com/check?service=" + service.getURL()); + BufferedReader input = new BufferedReader(new InputStreamReader(url.openStream())); + + Object object = parser.parse(input); + JSONObject jsonObject = (JSONObject)object; + + status = (String)jsonObject.get(service.getURL()); + } catch (Exception e) { + return ServiceStatus.UNKNOWN; + } + + return status(status); + } + + public static ServiceStatus getStatus(MojangServer service) { + String status = null; + try + { + URL url = new URL("http://status.mojang.com/check?service=" + service.getURL()); + BufferedReader input = new BufferedReader(new InputStreamReader(url.openStream())); + + Object object = parser.parse(input); + JSONObject jsonObject = (JSONObject)object; + + status = (String)jsonObject.get(service.getURL()); + } catch (Exception e) { + return ServiceStatus.UNKNOWN; + } + + return status(status); + } + + private static ServiceStatus status(String status) + { + String str; + switch ((str = status.toLowerCase()).hashCode()) { case -734239628: + if (str.equals("yellow")) break; break; + case 112785: + if (str.equals("red")); + case 98619139: + if ((goto 92) && (str.equals("green"))) + { + return ServiceStatus.ONLINE; + + return ServiceStatus.EXPERIENCE; + + return ServiceStatus.OFFLINE; + } + } + return ServiceStatus.UNKNOWN; + } + + public static enum MinecraftServer + { + WEBSITE("minecraft.net"), + LOGIN("login.minecraft.net"), + SKIN("skins.minecraft.net"), + SESSION("session.minecraft.net"); + + private String url; + + private MinecraftServer(String url) { this.url = url; } + + private String getURL() + { + return this.url; + } + } + + public static enum MojangServer + { + ACCOUNT("account.mojang.com"), + AUTH("auth.mojang.com"), + AUTHSERVER("authserver.mojang.com"), + SESSION("sessionserver.mojang.com"); + + private String url; + + private MojangServer(String url) { this.url = url; } + + private String getURL() + { + return this.url; + } + } + + public static enum ServiceStatus + { + ONLINE("No problems detected!"), + EXPERIENCE("May be experiencing issues"), + OFFLINE("Experiencing problems!"), + UNKNOWN("Couldn't connect to Mojang!"); + + private String description; + + private ServiceStatus(String description) { this.description = description; } + + public String getDescription() + { + return this.description; + } + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/MuteSystem.java b/src/de/joethei/core/api/MuteSystem.java new file mode 100644 index 0000000..02089cc --- /dev/null +++ b/src/de/joethei/core/api/MuteSystem.java @@ -0,0 +1,51 @@ +package de.joethei.core.api; + +import java.sql.ResultSet; +import java.sql.SQLException; +import org.bukkit.entity.Player; + +import de.joethei.core.Core; + +/** + * querys database for muted players + * @author joethei + * @version 1.0 + */ +public class MuteSystem { + + + /** + * checks if player is muted + * @param p player + * @return true /false + * @throws SQLException SQL server not available or throwing error + * @throws ClassNotFoundException class couldn't be found + */ + public static boolean isMuted(Player p) throws SQLException, ClassNotFoundException { + MySQL sql = Core.returnSQL(); + sql.openConnection(); + String uuid = p.getUniqueId().toString(); + ResultSet rs = sql.getConnection().createStatement().executeQuery("SELECT mute FROM PlayerData WHERE player_uuid='" + uuid + "';"); + if (rs.next()) { + return rs.getInt("mute") == 1; + } + sql.closeConnection(); + return false; + } + + + /** + * sets / unsets mute + * @param p player + * @param mute boolean + * @throws SQLException SQL server not available or throwing error + * @throws ClassNotFoundException class couldn't be found + */ + public static void setUser(Player p, boolean mute) throws SQLException, ClassNotFoundException { + MySQL sql = Core.returnSQL(); + sql.openConnection(); + String uuid = p.getUniqueId().toString(); + sql.getConnection().createStatement().executeUpdate("UPDATE PlayerData SET mute = " + mute + " WHERE player_uuid='" + uuid + "';"); + sql.closeConnection(); + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/MySQL.java b/src/de/joethei/core/api/MySQL.java new file mode 100644 index 0000000..a7dbf9e --- /dev/null +++ b/src/de/joethei/core/api/MySQL.java @@ -0,0 +1,37 @@ +package de.joethei.core.api; + +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.SQLException; +import org.bukkit.plugin.Plugin; + +public class MySQL extends Database +{ + private final String user; + private final String database; + private final String password; + private final String port; + private final String hostname; + + public MySQL(Plugin plugin, String hostname, String port, String database, String username, String password) { + super(plugin); + this.hostname = hostname; + this.port = port; + this.database = database; + this.user = username; + this.password = password; + } + + public Connection openConnection() + throws SQLException, ClassNotFoundException + { + if (checkConnection()) { + return this.connection; + } + Class.forName("com.mysql.jdbc.Driver"); + this.connection = DriverManager.getConnection("jdbc:mysql://" + + this.hostname + ":" + this.port + "/" + this.database, + this.user, this.password); + return this.connection; + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/NPC.java b/src/de/joethei/core/api/NPC.java new file mode 100644 index 0000000..8f44283 --- /dev/null +++ b/src/de/joethei/core/api/NPC.java @@ -0,0 +1,785 @@ +package de.joethei.core.api; + +import com.google.gson.Gson; +import com.google.gson.GsonBuilder; +import com.google.gson.JsonDeserializationContext; +import com.google.gson.JsonDeserializer; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import com.google.gson.JsonParseException; +import com.google.gson.JsonParser; +import com.google.gson.JsonPrimitive; +import com.google.gson.JsonSerializationContext; +import com.google.gson.JsonSerializer; +import com.mojang.authlib.GameProfile; +import com.mojang.authlib.properties.Property; +import com.mojang.authlib.properties.PropertyMap; +import com.mojang.authlib.properties.PropertyMap.Serializer; +import com.mojang.util.UUIDTypeAdapter; +import io.netty.channel.Channel; +import io.netty.channel.ChannelHandlerContext; +import io.netty.channel.ChannelPipeline; +import io.netty.handler.codec.MessageToMessageDecoder; +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +import java.lang.reflect.Field; +import java.lang.reflect.Type; +import java.net.HttpURLConnection; +import java.net.URL; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Random; +import java.util.UUID; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import net.md_5.bungee.api.ChatColor; +import net.minecraft.server.v1_8_R3.DataWatcher; +import net.minecraft.server.v1_8_R3.EntityPlayer; +import net.minecraft.server.v1_8_R3.NetworkManager; +import net.minecraft.server.v1_8_R3.Packet; +import net.minecraft.server.v1_8_R3.PacketPlayInUseEntity; +import net.minecraft.server.v1_8_R3.PacketPlayInUseEntity.EnumEntityUseAction; +import net.minecraft.server.v1_8_R3.PacketPlayOutEntityDestroy; +import net.minecraft.server.v1_8_R3.PacketPlayOutEntityEquipment; +import net.minecraft.server.v1_8_R3.PacketPlayOutEntityTeleport; +import net.minecraft.server.v1_8_R3.PacketPlayOutNamedEntitySpawn; +import net.minecraft.server.v1_8_R3.PacketPlayOutPlayerInfo; +import net.minecraft.server.v1_8_R3.PacketPlayOutPlayerInfo.EnumPlayerInfoAction; +import net.minecraft.server.v1_8_R3.PacketPlayOutPlayerInfo.PlayerInfoData; +import net.minecraft.server.v1_8_R3.PlayerConnection; +import net.minecraft.server.v1_8_R3.WorldSettings; +import net.minecraft.server.v1_8_R3.WorldSettings.EnumGamemode; +import org.bukkit.Bukkit; +import org.bukkit.Location; +import org.bukkit.Material; +import org.bukkit.block.Block; +import org.bukkit.craftbukkit.v1_8_R3.entity.CraftPlayer; +import org.bukkit.craftbukkit.v1_8_R3.inventory.CraftItemStack; +import org.bukkit.craftbukkit.v1_8_R3.util.CraftChatMessage; +import org.bukkit.entity.Player; +import org.bukkit.event.HandlerList; +import org.bukkit.event.player.PlayerEvent; +import org.bukkit.inventory.ItemStack; +import org.bukkit.plugin.PluginManager; +import org.yaml.snakeyaml.external.biz.base64Coder.Base64Coder; + +public class NPC +{ + private static Map npcs = new HashMap(); + private static Field channelField; + private static Field idField; + private DataWatcher watcher; + private GameProfile profile; + private Material chestplate; + private boolean hideTablist; + private Material leggings; + private Location location; + private String skinName; + private Material inHand; + private Material helmet; + private Material boots; + private String tablist; + private int entityID; + private String name; + + static + { + try + { + idField = PacketPlayInUseEntity.class.getDeclaredField("a"); + idField.setAccessible(true); + } catch (Exception e) { + e.printStackTrace(); + } + for (Field field : NetworkManager.class.getDeclaredFields()) + if (field.getType().isAssignableFrom(Channel.class)) { + channelField = field; + break; + } + } + + public NPC(String skinName, String name, String tablist, int entityID, Location location, Material inHand, boolean hideTablist) + { + this.location = location; + this.tablist = ChatColor.translateAlternateColorCodes('&', tablist); + this.name = ChatColor.translateAlternateColorCodes('&', name); + this.entityID = entityID; + this.inHand = inHand; + this.skinName = skinName; + this.watcher = new DataWatcher(null); + this.hideTablist = hideTablist; + this.watcher.a(6, Float.valueOf(20.0F)); + } + + public NPC(String name, Location location, boolean hideTablist) + { + this(null, name, name, new Random().nextInt(10000), location, + Material.AIR, hideTablist); + } + + public NPC(String skinName, String name, Location location, boolean hideTablist) + { + this(skinName, name, name, new Random().nextInt(10000), location, + Material.AIR, hideTablist); + } + + public NPC(String name, Location location, Material inHand, boolean hideTablist) + { + this(null, name, name, new Random().nextInt(10000), location, inHand, + hideTablist); + } + + public NPC(String name, String tablist, Location location, Material inHand, boolean hideTablist) + { + this(null, name, tablist, new Random().nextInt(10000), location, + inHand, hideTablist); + } + + @SuppressWarnings("deprecation") +public void spawn() + { + try { + PacketPlayOutNamedEntitySpawn packet = new PacketPlayOutNamedEntitySpawn(); + addToTablist(); + setValue(packet, "a", Integer.valueOf(this.entityID)); + setValue(packet, "b", this.profile.getId()); + setValue(packet, "c", Integer.valueOf(toFixedPoint(this.location.getX()))); + setValue(packet, "d", Integer.valueOf(toFixedPoint(this.location.getY()))); + setValue(packet, "e", Integer.valueOf(toFixedPoint(this.location.getZ()))); + setValue(packet, "f", Byte.valueOf(toPackedByte(this.location.getYaw()))); + setValue(packet, "g", Byte.valueOf(toPackedByte(this.location.getPitch()))); + setValue(packet, "h", Integer.valueOf(this.inHand == null ? 0 : this.inHand.getId())); + setValue(packet, "i", this.watcher); + for (Player online : Bukkit.getOnlinePlayers()) { + ((CraftPlayer)online).getHandle().playerConnection + .sendPacket(packet); + } + npcs.put(Integer.valueOf(this.entityID), this); + if (this.hideTablist) + removeFromTablist(); + } catch (Exception e) { + e.printStackTrace(); + } + } + + public void despawn() { + PacketPlayOutEntityDestroy packet = new PacketPlayOutEntityDestroy(new int[] { + this.entityID }); + removeFromTablist(); + for (Player online : Bukkit.getOnlinePlayers()) { + ((CraftPlayer)online).getHandle().playerConnection + .sendPacket(packet); + } + npcs.remove(Integer.valueOf(this.entityID)); + } + + public void changePlayerlistName(String name) { + try { + PacketPlayOutPlayerInfo packet = new PacketPlayOutPlayerInfo( + PacketPlayOutPlayerInfo.EnumPlayerInfoAction.UPDATE_DISPLAY_NAME, new EntityPlayer[0]); + PacketPlayOutPlayerInfo tmp20_19 = packet; tmp20_19.getClass(); PacketPlayOutPlayerInfo.PlayerInfoData data = new PacketPlayOutPlayerInfo.PlayerInfoData(tmp20_19, + this.profile, 0, WorldSettings.EnumGamemode.NOT_SET, + CraftChatMessage.fromString(name)[0]); + + List players = (List) + getValue(packet, "b"); + players.add(data); + setValue(packet, "b", players); + this.tablist = name; + for (Player online : Bukkit.getOnlinePlayers()) + ((CraftPlayer)online).getHandle().playerConnection + .sendPacket(packet); + } + catch (Exception e) { + e.printStackTrace(); + } + } + + private void addToTablist() { + try { + PacketPlayOutPlayerInfo packet = new PacketPlayOutPlayerInfo(); + GameProfile profile = this.profile = getProfile(); + PacketPlayOutPlayerInfo tmp23_22 = packet; tmp23_22.getClass(); PacketPlayOutPlayerInfo.PlayerInfoData data = new PacketPlayOutPlayerInfo.PlayerInfoData(tmp23_22, + profile, 1, WorldSettings.EnumGamemode.NOT_SET, + org.bukkit.craftbukkit.v1_8_R3.util.CraftChatMessage.fromString(this.tablist)[0]); + + List players = (List)getValue( + packet, "b"); + players.add(data); + setValue(packet, "a", + PacketPlayOutPlayerInfo.EnumPlayerInfoAction.ADD_PLAYER); + setValue(packet, "b", players); + for (Player online : Bukkit.getOnlinePlayers()) + ((CraftPlayer)online).getHandle().playerConnection + .sendPacket(packet); + } + catch (Exception e) { + e.printStackTrace(); + } + } + + private void removeFromTablist() { + try { + PacketPlayOutPlayerInfo packet = new PacketPlayOutPlayerInfo( + PacketPlayOutPlayerInfo.EnumPlayerInfoAction.REMOVE_PLAYER, new EntityPlayer[0]); + PacketPlayOutPlayerInfo tmp20_19 = packet; tmp20_19.getClass(); PacketPlayOutPlayerInfo.PlayerInfoData data = new PacketPlayOutPlayerInfo.PlayerInfoData(tmp20_19, + this.profile, -1, null, null); + + List players = (List) + getValue(packet, "b"); + players.add(data); + setValue(packet, "b", players); + for (Player online : Bukkit.getOnlinePlayers()) + ((CraftPlayer)online).getHandle().playerConnection + .sendPacket(packet); + } + catch (Exception e) { + e.printStackTrace(); + } + } + + public void teleport(Location location) { + try { + PacketPlayOutEntityTeleport packet = new PacketPlayOutEntityTeleport(); + setValue(packet, "a", Integer.valueOf(this.entityID)); + setValue(packet, "b", Integer.valueOf(toFixedPoint(location.getX()))); + setValue(packet, "c", Integer.valueOf(toFixedPoint(location.getY()))); + setValue(packet, "d", Integer.valueOf(toFixedPoint(location.getZ()))); + setValue(packet, "e", Byte.valueOf(toPackedByte(location.getYaw()))); + setValue(packet, "f", Byte.valueOf(toPackedByte(location.getPitch()))); + setValue(packet, "g", + Boolean.valueOf(this.location.getBlock().getType() != Material.AIR)); + this.location = location; + for (Player online : Bukkit.getOnlinePlayers()) + ((CraftPlayer)online).getHandle().playerConnection + .sendPacket(packet); + } + catch (Exception e) { + e.printStackTrace(); + } + } + + public void setItemInHand(Material material) { + try { + PacketPlayOutEntityEquipment packet = new PacketPlayOutEntityEquipment(); + setValue(packet, "a", Integer.valueOf(this.entityID)); + setValue(packet, "b", Integer.valueOf(0)); + setValue( + packet, + "c", + (material == Material.AIR) || (material == null) ? + CraftItemStack.asNMSCopy(new ItemStack(Material.AIR)) : + CraftItemStack.asNMSCopy(new ItemStack(material))); + this.inHand = material; + for (Player online : Bukkit.getOnlinePlayers()) + ((CraftPlayer)online).getHandle().playerConnection + .sendPacket(packet); + } + catch (Exception e) { + e.printStackTrace(); + } + } + + public Material getItemInHand() { + return this.inHand; + } + + public void setHelmet(Material material) { + try { + PacketPlayOutEntityEquipment packet = new PacketPlayOutEntityEquipment(); + setValue(packet, "a", Integer.valueOf(this.entityID)); + setValue(packet, "b", Integer.valueOf(4)); + setValue( + packet, + "c", + (material == Material.AIR) || (material == null) ? + CraftItemStack.asNMSCopy(new ItemStack(Material.AIR)) : + CraftItemStack.asNMSCopy(new ItemStack(material))); + this.helmet = material; + for (Player online : Bukkit.getOnlinePlayers()) + ((CraftPlayer)online).getHandle().playerConnection + .sendPacket(packet); + } + catch (Exception e) { + e.printStackTrace(); + } + } + + public Material getHelmet() { + return this.helmet; + } + + public void setChestplate(Material material) { + try { + PacketPlayOutEntityEquipment packet = new PacketPlayOutEntityEquipment(); + setValue(packet, "a", Integer.valueOf(this.entityID)); + setValue(packet, "b", Integer.valueOf(3)); + setValue( + packet, + "c", + (material == Material.AIR) || (material == null) ? + CraftItemStack.asNMSCopy(new ItemStack(Material.AIR)) : + CraftItemStack.asNMSCopy(new ItemStack(material))); + this.chestplate = material; + for (Player online : Bukkit.getOnlinePlayers()) + ((CraftPlayer)online).getHandle().playerConnection + .sendPacket(packet); + } + catch (Exception e) { + e.printStackTrace(); + } + } + + public Material getChestplate() { + return this.chestplate; + } + + public void setLeggings(Material material) { + try { + PacketPlayOutEntityEquipment packet = new PacketPlayOutEntityEquipment(); + setValue(packet, "a", Integer.valueOf(this.entityID)); + setValue(packet, "b", Integer.valueOf(2)); + setValue( + packet, + "c", + (material == Material.AIR) || (material == null) ? + CraftItemStack.asNMSCopy(new ItemStack(Material.AIR)) : + CraftItemStack.asNMSCopy(new ItemStack(material))); + this.leggings = material; + for (Player online : Bukkit.getOnlinePlayers()) + ((CraftPlayer)online).getHandle().playerConnection + .sendPacket(packet); + } + catch (Exception e) { + e.printStackTrace(); + } + } + + public Material getLeggings() { + return this.leggings; + } + + public void setBoots(Material material) { + try { + PacketPlayOutEntityEquipment packet = new PacketPlayOutEntityEquipment(); + setValue(packet, "a", Integer.valueOf(this.entityID)); + setValue(packet, "b", Integer.valueOf(1)); + setValue( + packet, + "c", + (material == Material.AIR) || (material == null) ? + CraftItemStack.asNMSCopy(new ItemStack(Material.AIR)) : + CraftItemStack.asNMSCopy(new ItemStack(material))); + this.boots = material; + for (Player online : Bukkit.getOnlinePlayers()) + ((CraftPlayer)online).getHandle().playerConnection + .sendPacket(packet); + } + catch (Exception e) { + e.printStackTrace(); + } + } + + public Material getBoots() { + return this.boots; + } + + public int getEntityID() { + return this.entityID; + } + + public UUID getUUID() { + return this.profile.getId(); + } + + public Location getLocation() { + return this.location; + } + + public String getName() { + return this.name; + } + + public String getPlayerlistName() { + return this.tablist; + } + + private void setValue(Object instance, String field, Object value) throws Exception + { + Field f = instance.getClass().getDeclaredField(field); + f.setAccessible(true); + f.set(instance, value); + } + + private Object getValue(Object instance, String field) throws Exception { + Field f = instance.getClass().getDeclaredField(field); + f.setAccessible(true); + return f.get(instance); + } + + private int toFixedPoint(double d) { + return (int)(d * 32.0D); + } + + private byte toPackedByte(float f) { + return (byte)(int)(f * 256.0F / 360.0F); + } + + private GameProfile getProfile() { + try { + GameProfile profile = GameProfileBuilder.fetch( + UUIDFetcher.getUUID(ChatColor.stripColor(this.name))); + Field name = profile.getClass().getDeclaredField("name"); + name.setAccessible(true); + name.set(profile, this.name); + return profile; } catch (Exception e) { + } + return getFakeProfile(); + } + + private GameProfile getFakeProfile() + { + try { + GameProfile profile = GameProfileBuilder.fetch( + UUIDFetcher.getUUID(ChatColor.stripColor(this.skinName))); + Field name = profile.getClass().getDeclaredField("name"); + name.setAccessible(true); + name.set(profile, this.name); + return profile; } catch (Exception e) { + } + return new GameProfile(UUID.randomUUID(), this.name); + } + + public static void injectNetty(Player player) + { + try + { + Channel channel = (Channel)channelField.get(((CraftPlayer)player) + .getHandle().playerConnection.networkManager); + if (channel != null) + channel.pipeline().addAfter("decoder", "npc_interact", + new MessageToMessageDecoder(player) + { + protected void decode(ChannelHandlerContext chc, Packet packet, List out) + throws Exception + { + if ((packet instanceof PacketPlayInUseEntity)) { + PacketPlayInUseEntity usePacket = (PacketPlayInUseEntity)packet; + if (usePacket.a() == PacketPlayInUseEntity.EnumEntityUseAction.INTERACT) { + int entityId = + ((Integer)NPC.idField + .get(usePacket)).intValue(); + if (NPC.npcs.containsKey(Integer.valueOf(entityId))) { + Bukkit.getPluginManager() + .callEvent( + new NPC.PlayerInteractNPCEvent( + NPC.this, + (NPC)NPC.npcs.get(Integer.valueOf(entityId)))); + } + } + } + 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) && + (channel.pipeline().get("npc_interact") != null)) + channel.pipeline().remove("npc_interact"); + } + catch (Exception e) + { + e.printStackTrace(); + } + } + + private static class GameProfileBuilder + { + private static final String SERVICE_URL = "https://sessionserver.mojang.com/session/minecraft/profile/%s?unsigned=false"; + private static final String JSON_SKIN = "{\"timestamp\":%d,\"profileId\":\"%s\",\"profileName\":\"%s\",\"isPublic\":true,\"textures\":{\"SKIN\":{\"url\":\"%s\"}}}"; + private static final String JSON_CAPE = "{\"timestamp\":%d,\"profileId\":\"%s\",\"profileName\":\"%s\",\"isPublic\":true,\"textures\":{\"SKIN\":{\"url\":\"%s\"},\"CAPE\":{\"url\":\"%s\"}}}"; + private static Gson gson = new GsonBuilder() + .disableHtmlEscaping() + .registerTypeAdapter(UUID.class, new UUIDTypeAdapter()) + .registerTypeAdapter(GameProfile.class, + new GameProfileSerializer(null)) + .registerTypeAdapter(PropertyMap.class, + new PropertyMap.Serializer()).create(); + private static HashMap cache = new HashMap(); + private static long cacheTime = -1L; + + public static GameProfile fetch(UUID uuid) + throws IOException + { + return fetch(uuid, false); + } + + public static GameProfile fetch(UUID uuid, boolean forceNew) + throws IOException + { + if ((!forceNew) && (cache.containsKey(uuid)) && + (((CachedProfile)cache.get(uuid)).isValid())) { + return ((CachedProfile)cache.get(uuid)).profile; + } + HttpURLConnection connection = (HttpURLConnection)new URL( + String.format("https://sessionserver.mojang.com/session/minecraft/profile/%s?unsigned=false", new Object[] { + UUIDTypeAdapter.fromUUID(uuid) })) + .openConnection(); + connection.setReadTimeout(5000); + if (connection.getResponseCode() == 200) { + String json = new BufferedReader( + new InputStreamReader(connection.getInputStream())).readLine(); + GameProfile result = (GameProfile)gson.fromJson(json, GameProfile.class); + cache.put(uuid, new CachedProfile(result)); + return result; + } + if ((!forceNew) && (cache.containsKey(uuid))) { + return ((CachedProfile)cache.get(uuid)).profile; + } + JsonObject error = (JsonObject)new JsonParser() + .parse(new BufferedReader( + new InputStreamReader(connection.getErrorStream())).readLine()); + throw new IOException(error.get("error").getAsString() + + ": " + error.get("errorMessage").getAsString()); + } + + public static GameProfile getProfile(UUID uuid, String name, String skin) + { + return getProfile(uuid, name, skin, null); + } + + public static GameProfile getProfile(UUID uuid, String name, String skinUrl, String capeUrl) + { + GameProfile profile = new GameProfile(uuid, name); + boolean cape = (capeUrl != null) && (!capeUrl.isEmpty()); + List args = new ArrayList(); + args.add(Long.valueOf(System.currentTimeMillis())); + args.add(UUIDTypeAdapter.fromUUID(uuid)); + args.add(name); + args.add(skinUrl); + if (cape) + args.add(capeUrl); + profile.getProperties().put( + "textures", + new Property("textures", Base64Coder.encodeString( + String.format(cape ? "{\"timestamp\":%d,\"profileId\":\"%s\",\"profileName\":\"%s\",\"isPublic\":true,\"textures\":{\"SKIN\":{\"url\":\"%s\"},\"CAPE\":{\"url\":\"%s\"}}}" : "{\"timestamp\":%d,\"profileId\":\"%s\",\"profileName\":\"%s\",\"isPublic\":true,\"textures\":{\"SKIN\":{\"url\":\"%s\"}}}", + args.toArray(new Object[args.size()]))))); + return profile; + } + + public static void setCacheTime(long time) + { + cacheTime = time; + } + private static class CachedProfile { + private long timestamp = System.currentTimeMillis(); + private GameProfile profile; + + public CachedProfile(GameProfile profile) { + this.profile = profile; + } + + public boolean isValid() { + return (NPC.GameProfileBuilder.cacheTime < 0L) || ( + System.currentTimeMillis() - this.timestamp < NPC.GameProfileBuilder.cacheTime); + } + } + + private static class GameProfileSerializer + implements JsonSerializer, JsonDeserializer + { + public GameProfile deserialize(JsonElement json, Type type, JsonDeserializationContext context) + throws JsonParseException + { + JsonObject object = (JsonObject)json; + UUID id = object.has("id") ? (UUID)context.deserialize( + object.get("id"), UUID.class) : + null; + String name = object.has("name") ? object.getAsJsonPrimitive( + "name").getAsString() : null; + GameProfile profile = new GameProfile(id, name); + if (object.has("properties")) + { + Iterator localIterator = ((PropertyMap)context + .deserialize(object.get("properties"), + PropertyMap.class)).entries().iterator(); + + while (localIterator.hasNext()) + { + Map.Entry prop = (Map.Entry)localIterator.next(); + profile.getProperties().put((String)prop.getKey(), + (Property)prop.getValue()); + } + } + return profile; + } + + public JsonElement serialize(GameProfile profile, Type type, JsonSerializationContext context) + { + JsonObject result = new JsonObject(); + if (profile.getId() != null) + result.add("id", context.serialize(profile.getId())); + if (profile.getName() != null) + result.addProperty("name", profile.getName()); + if (!profile.getProperties().isEmpty()) + result.add("properties", + context.serialize(profile.getProperties())); + return result; + } + } + } + + public static class PlayerInteractNPCEvent extends PlayerEvent + { + public static HandlerList handlers = new HandlerList(); + private NPC npc; + + public PlayerInteractNPCEvent(Player who, NPC npc) + { + super(); + this.npc = npc; + } + + public NPC getNpc() { + return this.npc; + } + + public HandlerList getHandlers() + { + return handlers; + } + + public static HandlerList getHandlerList() { + return handlers; + } + } + + private static class UUIDFetcher + { + public static final long FEBRUARY_2015 = 1422748800000L; + private static Gson gson = new GsonBuilder().registerTypeAdapter( + UUID.class, new UUIDTypeAdapter()).create(); + private static final String UUID_URL = "https://api.mojang.com/users/profiles/minecraft/%s?at=%d"; + private static final String NAME_URL = "https://api.mojang.com/user/profiles/%s/names"; + private static Map uuidCache = new HashMap(); + private static Map nameCache = new HashMap(); + private static ExecutorService pool = Executors.newCachedThreadPool(); + private String name; + private UUID id; + + public static void getUUID(String name, Consumer action) + { + pool.execute(new Acceptor(action, name) + { + public UUID getValue() { + return NPC.UUIDFetcher.getUUID(this.val$name); + } + }); + } + + public static UUID getUUID(String name) + { + return getUUIDAt(name, System.currentTimeMillis()); + } + + public static void getUUIDAt(String name, long timestamp, Consumer action) + { + pool.execute(new Acceptor(action, name, timestamp) + { + public UUID getValue() { + return NPC.UUIDFetcher.getUUIDAt(this.val$name, this.val$timestamp); + } + }); + } + + public static UUID getUUIDAt(String name, long timestamp) + { + name = name.toLowerCase(); + if (uuidCache.containsKey(name)) + return (UUID)uuidCache.get(name); + try + { + HttpURLConnection connection = (HttpURLConnection)new URL( + String.format("https://api.mojang.com/users/profiles/minecraft/%s?at=%d", new Object[] { name, Long.valueOf(timestamp / 1000L) })) + .openConnection(); + connection.setReadTimeout(5000); + UUIDFetcher data = (UUIDFetcher)gson.fromJson( + new BufferedReader(new InputStreamReader(connection.getInputStream())), + UUIDFetcher.class); + uuidCache.put(name, data.id); + nameCache.put(data.id, data.name); + return data.id; + } catch (Exception localException) { + } + return null; + } + + public static void getName(UUID uuid, Consumer action) + { + pool.execute(new Acceptor(action, uuid) + { + public String getValue() { + return NPC.UUIDFetcher.getName(this.val$uuid); + } + }); + } + + public static String getName(UUID uuid) + { + if (nameCache.containsKey(uuid)) + return (String)nameCache.get(uuid); + try + { + HttpURLConnection connection = (HttpURLConnection)new URL( + String.format("https://api.mojang.com/user/profiles/%s/names", new Object[] { UUIDTypeAdapter.fromUUID(uuid) })) + .openConnection(); + connection.setReadTimeout(5000); + UUIDFetcher[] nameHistory = (UUIDFetcher[])gson.fromJson( + new BufferedReader(new InputStreamReader(connection.getInputStream())), + [Lde.joethei.core.api.NPC.UUIDFetcher.class); + UUIDFetcher currentNameData = nameHistory[(nameHistory.length - 1)]; + uuidCache.put(currentNameData.name.toLowerCase(), uuid); + nameCache.put(uuid, currentNameData.name); + return currentNameData.name; + } catch (Exception e) { + e.printStackTrace(); + } + return null; + } + + public static abstract class Acceptor + implements Runnable + { + private NPC.UUIDFetcher.Consumer consumer; + + public Acceptor(NPC.UUIDFetcher.Consumer consumer) + { + this.consumer = consumer; + } + + public abstract T getValue(); + + public void run() { + this.consumer.accept(getValue()); + } + } + + public static abstract interface Consumer + { + public abstract void accept(T paramT); + } + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/NickName.java b/src/de/joethei/core/api/NickName.java new file mode 100644 index 0000000..96f34d0 --- /dev/null +++ b/src/de/joethei/core/api/NickName.java @@ -0,0 +1,93 @@ +package de.joethei.core.api; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.Random; +import org.bukkit.entity.Player; + +import de.joethei.core.Core; + +/** + * gets nick settings for players + * @author joethei + * @version 1.1 + */ +public class NickName { + + /** + * + * @param p remove nickname from player + */ + public static void remove(Player p) { + if (Core.nicks.containsKey(p)) + Core.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 + */ + public static void setNick(Player p, boolean nick) throws SQLException, ClassNotFoundException { + MySQL sql = Core.returnSQL(); + sql.openConnection(); + String uuid = p.getUniqueId().toString(); + if (nick) + sql.getConnection().createStatement().executeUpdate("UPDATE PlayerData SET nick = '1' WHERE player_uuid = '" + uuid + "';"); + else + sql.getConnection().createStatement().executeUpdate("UPDATE PlayerData SET nick = '0' WHERE player_uuid = '" + uuid + "';"); + 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 + */ + public static boolean isNicked(Player p) throws SQLException, ClassNotFoundException { + MySQL sql = Core.returnSQL(); + sql.openConnection(); + String uuid = p.getUniqueId().toString(); + ResultSet rs = sql.getConnection().createStatement().executeQuery("SELECT nick FROM PlayerData WHERE player_uuid = '" + uuid + "';"); + if (rs.next()) { + return rs.getInt("nick") == 1; + } + sql.closeConnection(); + return false; + } + + /** + * gets nickname of player + * @param p player + * @return String + */ + public static String getNick(Player p) { + if (Core.nicks.containsKey(p)) { + String nick = (String) Core.nicks.get(p); + return nick; + } + return null; + } + + /** + * gets random Nickname + * @return String + * @throws SQLException SQL server not available or throwing error + */ + public static String getNicks() throws SQLException { + ArrayList names = new ArrayList(); + names.add("XXKevinXX"); + names.add("xxGamelcrafterxx"); + names.add("LiaaamDesigns"); + + Random r = new Random(); + int i = r.nextInt(names.size()); + + return (String) names.get(i); + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/Pagifier.java b/src/de/joethei/core/api/Pagifier.java new file mode 100644 index 0000000..aab2585 --- /dev/null +++ b/src/de/joethei/core/api/Pagifier.java @@ -0,0 +1,66 @@ +package de.joethei.core.api; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +/*************************** + * Pagifier by leNic * + ***************************/ +/** + * @author leNic + * @version 1.0 + */ + public class Pagifier { + // Properties + private int pageSize; + // List of pages + private List> pages; + // Constructor + public Pagifier(int pageSize){ + this.pageSize = pageSize; + this.pages = new ArrayList<>(); + // Create first page + this.pages.add(new ArrayList<>()); + } + /** + * Add item to pages + * (Creates a new page if the previous page is not existing or full) + * @param item The item you want to add + */ + public void addItem(T item){ + int pageNum = pages.size() - 1; + List currentPage = this.pages.get(pageNum); + // Add page if full + if(currentPage.size() >= this.pageSize) { + currentPage = new ArrayList<>(); + this.pages.add(currentPage); + pageNum++; + } + currentPage.add(item); + } + /** + * Get the items of a page + * @param pageNum Number of the page (beginning at 0) + * @return Optional with a list of the page's items + */ + public Optional> getPage(int pageNum){ + if(this.pages.size() == 0) + return Optional.empty(); + return Optional.of(this.pages.get(pageNum)); + } + /** + * Get all pages + * @return List containing all pages + */ + public List> getPages(){ + return this.pages; + } + /** + * Get the current set page size + * @return The current page size + */ + public int getPageSize(){ + return this.pageSize; + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/Perms.java b/src/de/joethei/core/api/Perms.java new file mode 100644 index 0000000..993c348 --- /dev/null +++ b/src/de/joethei/core/api/Perms.java @@ -0,0 +1,161 @@ +package de.joethei.core.api; + +import de.joethei.core.Core; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.HashMap; + +/** + * some permission management + * @author joethei + * @version 1.0 + */ +public class Perms{ + + private static HashMap ranks = new HashMap(); + public static HashMap getRanks() { + return ranks; + } + +/** + * gets the prefix of a player + * @param p player + * @return String + */ +public static String getPrefix(CustomPlayer p) { + switch(p.getRank()) { + case Admin: return "§7[§4Admin§7]§4 "; + case Developer: return "§7[§3Developer§7] §3 "; + case HeadBuild: return "§7[§aHead-Builder§7]§a "; + case Builder: return "§7[§2Builder§7]§2 "; + case Moderator: return "§7[§cModerator§7]§c "; + case Supporter: return "§7[§bSupporter§7]§b "; + case Youtuber: return "§5"; + case Premium: return "§6"; + case Spieler: return "§7"; + default: return "§cFehler "; + } + } + +/** + * gets the suffix of a player + * @param p Player + * @return String + */ +public static String getSuffix(CustomPlayer p) { + switch(p.getRank()) { + case Admin: return " §8» §f§l"; + case Developer: return " §8» §f§l"; + case HeadBuild: return " §8» §f§l"; + case Builder: return " §8» §f§l"; + case Moderator: return " §8» §f§l"; + case Supporter: return " §8» §f§l"; + case Youtuber: return " §8» §f§l"; + case Premium: return " §8» §f§l"; + case Spieler: return " §8» §f§l"; + default: return "§cFehler"; + } + } + +/** + * gets color of a player + * @param p Player + * @return String + */ +public static String getColor(CustomPlayer p) { + switch(p.getRank()) { + case Admin: return "§4"; + case Developer: return "§3"; + case HeadBuild: return "§a"; + case Builder: return "§2"; + case Moderator: return "§c"; + case Supporter: return "§b"; + case Youtuber: return "§5"; + case Premium: return "§6"; + case Spieler: return "§7"; + default: return "§cFehler"; + } + } + +/** + * gets Rank of player + * @param p Player + * @return Ranks + */ +public static Ranks getRank(CustomPlayer p) { + return getRanks().get(p); + } + +/** + * gets Rank of player fresh from database + * @param p Player + * @return Ranks + * @throws ClassNotFoundException Class couldn't be found + * @throws SQLException SQL server not available or throwing error + */ +public static Ranks getRankFresh(CustomPlayer p) throws SQLException, ClassNotFoundException { + MySQL sql = Core.returnSQL(); + sql.openConnection(); + ResultSet rs = sql.getConnection().createStatement().executeQuery("SELECT * FROM PlayerData WHERE player_uuid='" + p.getUniqueId() + "'"); + rs.next(); + if (rs.getString("player_uuid") != null) { + String rank = rs.getString("Rank"); + Ranks Rank = Ranks.valueOf(rank); + sql.closeConnection(); + return Rank; + } + sql.closeConnection(); + return null; + } + + /** + * sets rank for player + * @param p Player + * @param r Ranks + * @throws ClassNotFoundException Class couldn't be found + * @throws SQLException SQL server not available or throwing error + */ +public static void setRank(CustomPlayer p, Ranks r) throws ClassNotFoundException, SQLException { + MySQL sql = Core.returnSQL(); + sql.openConnection(); + sql.getConnection().createStatement().execute("UPDATE PlayerData SET Rank='" + r.toString() + "' WHERE player_uuid='" + p.getUniqueId() + "';"); + sql.closeConnection(); + } + +/** + * if player is allowed to do + * @param p Player + * @param r Ranks + * @return true / false + * @throws ClassNotFoundException Class couldn't be found + * @throws SQLException SQL server not available or throwing error + */ +public static boolean isAllowed(CustomPlayer p, Ranks r) throws ClassNotFoundException, SQLException{ + Ranks rank; + if(getRank(p) == null) { + rank = getRankFresh(p); + }else { + rank = getRank(p); + } + return rank.value >= r.value; + } + + public static enum Ranks{ + Admin(9), + Developer(8), + HeadBuild(7), + Builder(6), + Moderator(5), + Supporter(4), + Youtuber(3), + Premium(2), + Spieler(1); + + public final int value; + + private Ranks(int n) { + this.value = n; + } + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/SQLite.java b/src/de/joethei/core/api/SQLite.java new file mode 100644 index 0000000..46f203f --- /dev/null +++ b/src/de/joethei/core/api/SQLite.java @@ -0,0 +1,46 @@ +package de.joethei.core.api; + +import java.io.File; +import java.io.IOException; +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.SQLException; +import java.util.logging.Level; +import org.bukkit.plugin.Plugin; + +public class SQLite extends Database +{ + private final String dbLocation; + + public SQLite(Plugin plugin, String dbLocation) + { + super(plugin); + this.dbLocation = dbLocation; + } + + public Connection openConnection() + throws SQLException, ClassNotFoundException + { + if (checkConnection()) { + return this.connection; + } + if (!this.plugin.getDataFolder().exists()) { + this.plugin.getDataFolder().mkdirs(); + } + File file = new File(this.plugin.getDataFolder(), this.dbLocation); + if (!file.exists()) { + try { + file.createNewFile(); + } catch (IOException e) { + this.plugin.getLogger().log(Level.SEVERE, + "Unable to create database!"); + } + } + Class.forName("org.sqlite.JDBC"); + this.connection = + DriverManager.getConnection("jdbc:sqlite:" + + this.plugin.getDataFolder().toPath().toString() + "/" + + this.dbLocation); + return this.connection; + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/ServerPinger.java b/src/de/joethei/core/api/ServerPinger.java new file mode 100644 index 0000000..18713d9 --- /dev/null +++ b/src/de/joethei/core/api/ServerPinger.java @@ -0,0 +1,98 @@ +package de.joethei.core.api; + +import java.io.DataOutputStream; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.OutputStream; +import java.net.InetSocketAddress; +import java.net.Socket; +import java.nio.charset.Charset; + +public class ServerPinger +{ + private String host; + private int port; + + public ServerPinger(String host, int port) + { + this.host = host; + this.port = port; + } + + public ServerPinger(String host) { + this.host = host; + this.port = 25565; + } + + public ServerPinger() { + this.host = "127.0.0.1"; + this.port = 25565; + } + + @SuppressWarnings("resource") +public String parseData(Connection connection) + { + try + { + Socket socket = new Socket(); + + socket.setSoTimeout(2500); + socket.connect(new InetSocketAddress(this.host, this.port)); + + OutputStream os = socket.getOutputStream(); + DataOutputStream dos = new DataOutputStream(os); + + InputStream is = socket.getInputStream(); + InputStreamReader isr = new InputStreamReader(is, Charset.forName("UTF-16BE")); + + dos.write(new byte[] { -2, 1 }); + + int packetID = is.read(); + + if (packetID == -1) { + System.out.println("Invalid Packet ID! (End Of Stream)"); + } + if (packetID != 255) { + System.out.println("Invalid Packet Id! " + packetID); + } + + int length = isr.read(); + + if (length == -1) { + System.out.println("End Of Stream"); + } + + if (length == 0) { + System.out.println("Invalid length"); + } + + char[] chars = new char[length]; + + if (isr.read(chars, 0, length) != length) { + System.out.println("End Of Stream"); + } + + String string = new String(chars); + String[] data = string.split(""); + + if (connection == Connection.ONLINE_PLAYERS) + return data[4]; + if (connection == Connection.MOTD) + return data[3]; + if (connection == Connection.MAX_PLAYERS) { + return data[5]; + } + System.out.println("Connection value not handled!"); + } + catch (Exception localException) + { + localException.printStackTrace(); + } + + return null; + } + + public static enum Connection { + ONLINE_PLAYERS, MAX_PLAYERS, MOTD; + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/Servers.java b/src/de/joethei/core/api/Servers.java new file mode 100644 index 0000000..598aac0 --- /dev/null +++ b/src/de/joethei/core/api/Servers.java @@ -0,0 +1,108 @@ +package de.joethei.core.api; + +import com.google.common.collect.Iterables; +import com.google.common.io.ByteArrayDataOutput; +import com.google.common.io.ByteStreams; +import de.joethei.core.Core; + +import java.io.ByteArrayOutputStream; +import java.io.DataOutputStream; +import java.io.IOException; +import org.bukkit.Bukkit; +import org.bukkit.entity.Player; + +/** + * sends player to other bungeecord servers + * @author joethei + * @version 1.0 + */ +public class Servers { + + + /** + * sends player to server + * @param p player + * @param server name of server + */ + public static void connectServer(Player p, String server) { + if ((p instanceof Player)) { + ByteArrayOutputStream b = new ByteArrayOutputStream(); + DataOutputStream out = new DataOutputStream(b); + try { + out.writeUTF("Connect"); + out.writeUTF(server); + } catch (IOException el) { + el.printStackTrace(); + } + p.sendPluginMessage(Core.getInstance(), "BungeeCord", b.toByteArray()); + } + } + + /** + * connects all player to server + * @param server name of server + */ + public static void connectAllToServer(String server) { + for (Player all : Bukkit.getOnlinePlayers()) + connectServer(all, server); + } + + /** + * gets player count of server + * @param server name of server + * @return player count + */ + public static int getOnlinePlayers(String server) { + int online = 0; + + ByteArrayDataOutput out = ByteStreams.newDataOutput(); + + out.writeUTF("PlayerCount"); + out.writeUTF(server); + + Player player = (Player) Iterables.getFirst(Bukkit.getOnlinePlayers(), null); + player.sendPluginMessage(Core.getInstance(), "BungeeCord", out.toByteArray()); + + return online; + } + + /** + * gets ip of server from bungeecord + * @param server server name + * @return server ip + */ + public static String getServerIP(String server) { + String ip = null; + + ByteArrayDataOutput out = ByteStreams.newDataOutput(); + + out.writeUTF("ServerInfo"); + out.writeUTF(server); + + Player player = (Player) Iterables.getFirst(Bukkit.getOnlinePlayers(), null); + player.sendPluginMessage(Core.getInstance(), "BungeeCord", out.toByteArray()); + + return ip; + + } + + /** + * gets port of server from bungeecord + * @param server server name + * @return server port + */ + public static int getServerPort(String server) { + int port = 0; + + ByteArrayDataOutput out = ByteStreams.newDataOutput(); + + out.writeUTF("ServerInfo"); + out.writeUTF(server); + + Player player = (Player) Iterables.getFirst(Bukkit.getOnlinePlayers(), null); + player.sendPluginMessage(Core.getInstance(), "BungeeCord", out.toByteArray()); + + return port; + + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/Settings.java b/src/de/joethei/core/api/Settings.java new file mode 100644 index 0000000..21e8dc3 --- /dev/null +++ b/src/de/joethei/core/api/Settings.java @@ -0,0 +1,67 @@ +package de.joethei.core.api; + +/** + * server-wide settings + * @author joethei + * @version 0.1 + */ + +public class Settings { + + private static boolean build; + private static boolean lobby; + private static boolean debug; + private static boolean mute; + /** + * @return is build + */ + public static boolean isBuild() { + return build; + } + /** + * @param build the build to set + */ + public static void setBuild(boolean build) { + Settings.build = build; + } + /** + * @return is lobby + */ + public static boolean isLobby() { + return lobby; + } + /** + * @param lobby the lobby to set + */ + public static void setLobby(boolean lobby) { + Settings.lobby = lobby; + } + /** + * @return is debug + */ + public static boolean isDebug() { + return debug; + } + /** + * @param debug the debug to set + */ + public static void setDebug(boolean debug) { + Settings.debug = debug; + } + + /** + * @return is mute + */ + public static boolean isMute() { + return mute; + } + + /** + * + * @param mute the mute to set + */ + public static void setMute(boolean mute) { + Settings.mute = mute; + } + +} \ No newline at end of file diff --git a/src/de/joethei/core/api/SignInput.java b/src/de/joethei/core/api/SignInput.java new file mode 100644 index 0000000..72a5979 --- /dev/null +++ b/src/de/joethei/core/api/SignInput.java @@ -0,0 +1,145 @@ +package de.joethei.core.api; + +import io.netty.channel.Channel; +import io.netty.channel.ChannelHandlerContext; +import io.netty.channel.ChannelPipeline; +import io.netty.handler.codec.MessageToMessageDecoder; +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; +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 org.bukkit.scheduler.BukkitScheduler; + +public final class SignInput + implements Listener, Runnable +{ + private static final String VERSION; + private final Plugin plugin; + private final Map> inputResults; + + static + { + String path = Bukkit.getServer().getClass().getPackage().getName(); + VERSION = path.substring(path.lastIndexOf(".") + 1, path.length()); + } + + public SignInput(Plugin plugin) + { + this.plugin = plugin; + this.inputResults = new HashMap(); + Bukkit.getScheduler().runTaskTimer(this.plugin, this, 0L, 60L); + } + + public boolean readInput(Player p, Consumer result) + { + this.inputResults.put(p.getUniqueId(), result); + try { + Class packetClass = + Class.forName(getNMSClass("PacketPlayOutOpenSignEditor")); + Class blockPositionClass = + Class.forName(getNMSClass("BlockPosition")); + Constructor blockPosCon = blockPositionClass + .getConstructor(new Class[] { Integer.TYPE, Integer.TYPE, + Integer.TYPE }); + Object blockPosition = blockPosCon.newInstance(new Object[] { Integer.valueOf(0), Integer.valueOf(0), + Integer.valueOf(0) }); + Constructor packetCon = packetClass + .getConstructor(new Class[] { blockPositionClass }); + Object packet = packetCon + .newInstance(new Object[] { blockPosition }); + + Method getHandle = p.getClass().getMethod("getHandle", new Class[0]); + Object nmsPlayer = getHandle.invoke(p, new Object[0]); + 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; + } + + public void run() + { + for (UUID uuid : this.inputResults.keySet()) + if (Bukkit.getPlayer(uuid) == null) + this.inputResults.remove(uuid); + } + + @EventHandler + public void onJoin(PlayerJoinEvent e) + { + Player p = e.getPlayer(); + getNettyChannel(p).pipeline().addAfter("decoder", "signListener", + new MessageToMessageDecoder() { + protected void decode(ChannelHandlerContext chc, Object packet, List packetList) throws Exception { + if (SignInput.this.instanceOf(packet, + SignInput.access(SignInput.this, "PacketPlayInUpdateSign"))) { + Method bMethod = packet.getClass().getMethod("b", new Class[0]); + Object chatBaseComponents = bMethod.invoke(packet, new Object[0]); + String[] lines = new String[4]; + for (int i = 0; i < 4; i++) { + Object chatComponent = Array.get( + chatBaseComponents, i); + Method getText = chatComponent.getClass() + .getMethod("getText", new Class[0]); + lines[i] = + ((String)getText + .invoke(chatComponent, new Object[0])); + } + if (SignInput.this.inputResults.containsKey(p.getUniqueId())) { + ((Consumer)SignInput.this.inputResults.get(p.getUniqueId())).accept(lines); + SignInput.this.inputResults.remove(p.getUniqueId()); + } + } + packetList.add(packet); + } + }); + } + + private Channel getNettyChannel(Player p) { + Channel ch = null; + try { + Method getHandle = p.getClass().getMethod("getHandle", new Class[0]); + Object nmsPlayer = getHandle.invoke(p, new Object[0]); + 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; + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/SimpleScoreboard.java b/src/de/joethei/core/api/SimpleScoreboard.java new file mode 100644 index 0000000..314a9d5 --- /dev/null +++ b/src/de/joethei/core/api/SimpleScoreboard.java @@ -0,0 +1,104 @@ +package de.joethei.core.api; + +import com.google.common.base.Preconditions; +import com.google.common.base.Splitter; +import com.google.common.collect.Lists; +import com.google.common.collect.Maps; + +import java.util.AbstractMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import org.bukkit.Bukkit; +import org.bukkit.OfflinePlayer; +import org.bukkit.entity.Player; +import org.bukkit.scoreboard.DisplaySlot; +import org.bukkit.scoreboard.Objective; +import org.bukkit.scoreboard.Scoreboard; +import org.bukkit.scoreboard.Team; + +public class SimpleScoreboard +{ + private Scoreboard scoreboard; + private String title; + private Map scores; + private List teams; + + public SimpleScoreboard(String title) + { + this.scoreboard = Bukkit.getScoreboardManager().getNewScoreboard(); + this.title = title; + this.scores = Maps.newLinkedHashMap(); + this.teams = Lists.newArrayList(); + } + + public void add(String text) { + add(text, null); + } + + public void add(String text, Integer score) { + Preconditions.checkArgument(text.length() < 48, "text cannot be over 48 characters in length"); + text = fixDuplicates(text); + this.scores.put(text, score); + } + + private String fixDuplicates(String text) { + while (this.scores.containsKey(text)) + text = text + "§r"; + if (text.length() > 48) + text = text.substring(0, 47); + return text; + } + + private Map.Entry createTeam(String text) + { + String result = ""; + if (text.length() <= 16) + return new AbstractMap.SimpleEntry(null, text); + Team team = this.scoreboard.registerNewTeam("text-" + this.scoreboard.getTeams().size()); + Iterator iterator = Splitter.fixedLength(16).split(text).iterator(); + team.setPrefix((String)iterator.next()); + result = (String)iterator.next(); + if (text.length() > 32) + team.setSuffix((String)iterator.next()); + this.teams.add(team); + return new AbstractMap.SimpleEntry(team, result); + } + + @SuppressWarnings({ "deprecation", "rawtypes" }) +public void build() + { + Objective obj = this.scoreboard.registerNewObjective(this.title.length() > 16 ? this.title.substring(0, 15) : this.title, "dummy"); + obj.setDisplayName(this.title); + obj.setDisplaySlot(DisplaySlot.SIDEBAR); + + int index = this.scores.size(); + + for (Map.Entry text : this.scores.entrySet()) { + Map.Entry team = createTeam((String)text.getKey()); + Integer score = Integer.valueOf(text.getValue() != null ? ((Integer)text.getValue()).intValue() : index); + OfflinePlayer player = Bukkit.getOfflinePlayer((String)team.getValue()); + if (team.getKey() != null) + ((Team)team.getKey()).addPlayer(player); + obj.getScore(player.getName()).setScore(score.intValue()); + index--; + } + } + + public void reset() { + this.title = null; + this.scores.clear(); + for (Team t : this.teams) + t.unregister(); + this.teams.clear(); + } + + public Scoreboard getScoreboard() { + return this.scoreboard; + } + + public void send(Player[] players) { + for (Player p : players) + p.setScoreboard(this.scoreboard); + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/Spectator.java b/src/de/joethei/core/api/Spectator.java new file mode 100644 index 0000000..a184c83 --- /dev/null +++ b/src/de/joethei/core/api/Spectator.java @@ -0,0 +1,44 @@ +package de.joethei.core.api; + +import java.util.ArrayList; + +import org.bukkit.Bukkit; +import org.bukkit.GameMode; +import org.bukkit.entity.Player; + +public class Spectator { + + private static ArrayList spectators = new ArrayList(); + + public Spectator() { + } + + public static void add(Player p) { + for(Player on : Bukkit.getOnlinePlayers()) { + on.hidePlayer(p); + } + spectators.add(CustomPlayer.getPlayer(p.getName())); + p.setGameMode(GameMode.CREATIVE); + p.setAllowFlight(true); + p.setFlying(true); + } + + public static void remove(Player p) { + for(Player on : Bukkit.getOnlinePlayers()) { + on.showPlayer(p); + } + spectators.remove(CustomPlayer.getPlayer(p.getName())); + p.setGameMode(GameMode.SURVIVAL); + p.setAllowFlight(false); + p.setFlying(false); + } + + public static ArrayList getSpectators() { + return spectators; + } + + public static boolean is(CustomPlayer p) { + return spectators.contains(p.getName()); + } + +} \ No newline at end of file diff --git a/src/de/joethei/core/api/Title.java b/src/de/joethei/core/api/Title.java new file mode 100644 index 0000000..f70ee97 --- /dev/null +++ b/src/de/joethei/core/api/Title.java @@ -0,0 +1,86 @@ +package de.joethei.core.api; + +import java.lang.reflect.Field; +import net.minecraft.server.v1_8_R3.IChatBaseComponent; +import net.minecraft.server.v1_8_R3.PacketPlayOutPlayerListHeaderFooter; +import net.minecraft.server.v1_8_R3.PacketPlayOutTitle; +import net.minecraft.server.v1_8_R3.PlayerConnection; +import org.bukkit.ChatColor; +import org.bukkit.craftbukkit.v1_8_R3.entity.CraftPlayer; +import org.bukkit.entity.Player; + +public class Title +{ + @Deprecated + public static void sendTitle(Player player, Integer fadeIn, Integer stay, Integer fadeOut, String message) + { + sendTitle(player, fadeIn, stay, fadeOut, message, null); + } + @Deprecated + public static void sendSubtitle(Player player, Integer fadeIn, Integer stay, Integer fadeOut, String message) { + sendTitle(player, fadeIn, stay, fadeOut, null, message); + } + @Deprecated + public static void sendFullTitle(Player player, Integer fadeIn, Integer stay, Integer fadeOut, String title, String subtitle) { + sendTitle(player, fadeIn, stay, fadeOut, title, subtitle); + } + + public static void sendTitle(Player player, Integer fadeIn, Integer stay, Integer fadeOut, String title, String subtitle) { + PlayerConnection connection = ((CraftPlayer)player).getHandle().playerConnection; + + PacketPlayOutTitle packetPlayOutTimes = new PacketPlayOutTitle(PacketPlayOutTitle.EnumTitleAction.TIMES, null, fadeIn.intValue(), stay.intValue(), fadeOut.intValue()); + connection.sendPacket(packetPlayOutTimes); + + if (subtitle != null) { + subtitle = subtitle.replaceAll("%player%", player.getDisplayName()); + subtitle = ChatColor.translateAlternateColorCodes('&', subtitle); + IChatBaseComponent titleSub = IChatBaseComponent.ChatSerializer.a("{\"text\": \"" + subtitle + "\"}"); + PacketPlayOutTitle packetPlayOutSubTitle = new PacketPlayOutTitle(PacketPlayOutTitle.EnumTitleAction.SUBTITLE, titleSub); + connection.sendPacket(packetPlayOutSubTitle); + } + + if (title != null) { + title = title.replaceAll("%player%", player.getDisplayName()); + title = ChatColor.translateAlternateColorCodes('&', title); + IChatBaseComponent titleMain = IChatBaseComponent.ChatSerializer.a("{\"text\": \"" + title + "\"}"); + PacketPlayOutTitle packetPlayOutTitle = new PacketPlayOutTitle(PacketPlayOutTitle.EnumTitleAction.TITLE, titleMain); + connection.sendPacket(packetPlayOutTitle); + } + } + + public static void sendTabTitle(Player player, String header, String footer) { + if (header == null) header = ""; + header = ChatColor.translateAlternateColorCodes('&', header); + + if (footer == null) footer = ""; + footer = ChatColor.translateAlternateColorCodes('&', footer); + + header = header.replaceAll("%player%", player.getDisplayName()); + footer = footer.replaceAll("%player%", player.getDisplayName()); + + PlayerConnection connection = ((CraftPlayer)player).getHandle().playerConnection; + IChatBaseComponent tabTitle = IChatBaseComponent.ChatSerializer.a("{\"text\": \"" + header + "\"}"); + IChatBaseComponent tabFoot = IChatBaseComponent.ChatSerializer.a("{\"text\": \"" + footer + "\"}"); + PacketPlayOutPlayerListHeaderFooter headerPacket = new PacketPlayOutPlayerListHeaderFooter(tabTitle); + try + { + Field field = headerPacket.getClass().getDeclaredField("b"); + field.setAccessible(true); + field.set(headerPacket, tabFoot); + } catch (Exception e) { + e.printStackTrace(); + } finally { + connection.sendPacket(headerPacket); + } + } + + boolean isInteger(String s) + { + try { + Integer.parseInt(s); + } catch (NumberFormatException e) { + return false; + } + return true; + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/Utils.java b/src/de/joethei/core/api/Utils.java new file mode 100644 index 0000000..d94cc90 --- /dev/null +++ b/src/de/joethei/core/api/Utils.java @@ -0,0 +1,179 @@ +package de.joethei.core.api; + +import java.io.File; +import java.util.List; +import java.util.Random; +import net.minecraft.server.v1_8_R3.EnumParticle; +import net.minecraft.server.v1_8_R3.PacketPlayOutWorldParticles; +import org.bukkit.Bukkit; +import org.bukkit.Color; +import org.bukkit.Effect; +import org.bukkit.FireworkEffect; +import org.bukkit.Location; +import org.bukkit.Material; +import org.bukkit.Sound; +import org.bukkit.craftbukkit.v1_8_R3.entity.CraftPlayer; +import org.bukkit.entity.Entity; +import org.bukkit.entity.EntityType; +import org.bukkit.entity.Firework; +import org.bukkit.entity.Player; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.FireworkMeta; +import org.bukkit.inventory.meta.ItemMeta; +import org.bukkit.potion.PotionEffect; +import org.bukkit.util.Vector; + +public class Utils +{ + + public static void deleteFolder(File folder) + { + File[] files = folder.listFiles(); + if (files != null) { + for (File f : files) { + if (f.isDirectory()) + deleteFolder(f); + else { + f.delete(); + } + } + } + + folder.delete(); + } + + public static void PlaySoundToAll(Sound s) { + for (Player all : Bukkit.getOnlinePlayers()) + all.playSound(all.getLocation(), s, 3.0F, 3.0F); + } + + @SuppressWarnings("deprecation") +public static void PlayEffectToAll(Effect s) + { + for (Player all : Bukkit.getOnlinePlayers()) + all.playEffect(all.getLocation(), s, 3); + } + + public static boolean isSpigot() { + return Bukkit.getVersion().contains("Spigot"); + } + public static void deleteDir(File file) { + if (file.isDirectory()) { + if (file.list().length == 0) { + file.delete(); + } else { + String[] files = file.list(); + for (String tmp : files) { + File fileDelete = new File(file, tmp); + deleteDir(fileDelete); + } + if (file.list().length == 0) + file.delete(); + } + } + else + file.delete(); + } + + public static double random(int low, int high) { + return Math.random() * (high - low) + low; + } + + @SuppressWarnings("deprecation") +public static ItemStack createItemStack(int id, int anzahl, int sh, String name) { + ItemStack item = new ItemStack(id, anzahl, (short)sh); + ItemMeta im = item.getItemMeta(); + im.setDisplayName(name); + item.setItemMeta(im); + return item; + } + public static boolean emptyInventory(Player p) { + for (ItemStack item : p.getInventory().getContents()) { + if ((item != null) && + (item.getType() != Material.AIR)) + return false; + } + for (ItemStack item : p.getInventory().getArmorContents()) { + if ((item != null) && + (item.getType() != Material.AIR)) + return false; + } + return true; + } + public static void randomFirework(Location loc) { + Firework fw = (Firework)loc.getWorld().spawnEntity(loc, EntityType.FIREWORK); + FireworkMeta fwm = fw.getFireworkMeta(); + Random r = new Random(); + int rt = r.nextInt(5) + 1; + FireworkEffect.Type type = FireworkEffect.Type.BALL; + if (rt == 1) type = FireworkEffect.Type.BALL; + if (rt == 2) type = FireworkEffect.Type.BALL_LARGE; + if (rt == 3) type = FireworkEffect.Type.BURST; + if (rt == 4) type = FireworkEffect.Type.CREEPER; + if (rt == 5) type = FireworkEffect.Type.STAR; + + int red = r.nextInt(256); + int b = r.nextInt(256); + int g = r.nextInt(256); + + Color c1 = Color.fromRGB(red, g, b); + + red = r.nextInt(256); + b = r.nextInt(256); + g = r.nextInt(256); + Color c2 = Color.fromRGB(red, g, b); + + FireworkEffect effect = FireworkEffect.builder().flicker(r.nextBoolean()).withColor(c1).withFade(c2).with(type).trail(r.nextBoolean()).build(); + fwm.addEffect(effect); + int rp = r.nextInt(2) + 1; + fwm.setPower(rp); + fw.setFireworkMeta(fwm); + } + + public static int removeEntitys(List e) { + int i = 0; + for (Entity en : e) { + en.remove(); + i++; + } + return i; + } + + public static void clearPotionEffects(Player player) { + for (PotionEffect effect : player.getActivePotionEffects()) + player.removePotionEffect(effect.getType()); + } + 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, new int[] { 0, 0 }); + for (Player p : Bukkit.getOnlinePlayers()) + ((CraftPlayer)p).getHandle().playerConnection.sendPacket(packet); + } + + public static Vector calculateVector(Location from, Location to) { + Location a = from, b = to; + + //calculate the distance between the locations (a => from || b => to) + double dX = a.getX() - b.getX(); + double dY = a.getY() - b.getY(); + double dZ = a.getZ() - b.getZ(); + // ------------------------- + + //calculate the yaw + double yaw = Math.atan2(dZ, dX); + // ------------------------- + + //calculate the pitch + double pitch = Math.atan2(Math.sqrt(dZ * dZ + dX * dX), dY) + Math.PI; + // ------------------------- + + //calculate and create the new vector + double x = Math.sin(pitch) * Math.cos(yaw); + double y = Math.sin(pitch) * Math.sin(yaw); + double z = Math.cos(pitch); + + Vector vector = new Vector(x, z, y); + // ------------------------- + + return vector; + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/twitch/API.java b/src/de/joethei/core/api/twitch/API.java new file mode 100644 index 0000000..25f5545 --- /dev/null +++ b/src/de/joethei/core/api/twitch/API.java @@ -0,0 +1,28 @@ +package de.joethei.core.api.twitch; + + +import java.io.BufferedReader; +import java.io.InputStreamReader; +import java.net.URL; + + +public class API { +public static String readJsonFromUrl(String urlString) throws Exception { +BufferedReader reader = null; +try { +URL url = new URL(urlString); +reader = new BufferedReader(new InputStreamReader(url.openStream())); +StringBuffer buffer = new StringBuffer(); +int read; +char[] chars = new char[1024]; +while ((read = reader.read(chars)) != -1) +buffer.append(chars, 0, read); + + +return buffer.toString(); +} finally { +if (reader != null) +reader.close(); +} +} +} \ No newline at end of file diff --git a/src/de/joethei/core/api/twitch/Twitch_API.java b/src/de/joethei/core/api/twitch/Twitch_API.java new file mode 100644 index 0000000..b061394 --- /dev/null +++ b/src/de/joethei/core/api/twitch/Twitch_API.java @@ -0,0 +1,43 @@ +package de.joethei.core.api.twitch; + + +import com.google.gson.Gson; +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; + + +public class Twitch_API { +public static Gson gson = new Gson(); + + + + +public static Twitch_Stream getStream(String channelname){ +try{ +String json = API.readJsonFromUrl("http://api.justin.tv/api/stream/list.json?channel="+channelname); + + +Twitch_Stream stream = new Twitch_Stream(); +if(json.equalsIgnoreCase("[]")){ +stream.setOnline(false); +return stream; +} +JsonArray jb = gson.fromJson(json, JsonArray.class); +JsonObject jo = (JsonObject) jb.get(0); +stream.setOnline(true); +stream.load(jo); +return stream; +} catch (Exception error){ +error.printStackTrace(); +} + + + + +return null; + + + + +} +} \ No newline at end of file diff --git a/src/de/joethei/core/api/twitch/Twitch_Stream.java b/src/de/joethei/core/api/twitch/Twitch_Stream.java new file mode 100644 index 0000000..796cdde --- /dev/null +++ b/src/de/joethei/core/api/twitch/Twitch_Stream.java @@ -0,0 +1,381 @@ +package de.joethei.core.api.twitch; + +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; + +public class Twitch_Stream { + boolean online; + int broadcast_part; + boolean featured; + boolean channel_subscription; + String id; + String category; + String title; + int channel_count; + int video_height; + int site_count; + boolean embed_enabled; + String up_time; + String meta_game; + String format; + int embed_count; + String stream_type; + boolean abuse_reported; + int video_width; + String geo; + String name; + String language; + int stream_count; + double video_bitrate; + String broadcaster; + int channel_view_count; + String username; + String status; + String channel_url; + boolean producer; + String subcategory_title; + String screen_cap_url_large; + String screen_cap_url_small; + String screen_cap_url_medium; + String screen_cap_url_huge; + String timezone; + String category_title; + int views_count; + + public void load(JsonObject job) { + setBroadcast_part(job.get("broadcast_part").getAsInt()); + setFeatured(job.get("featured").getAsBoolean()); + setChannel_subscription(job.get("channel_subscription").getAsBoolean()); + setId(job.get("id").getAsString()); + setCategory(job.get("category").getAsString()); + setTitle(job.get("title").getAsString()); + setChannel_count(job.get("channel_count").getAsInt()); + setVideo_height(job.get("video_height").getAsInt()); + setSite_count(job.get("site_count").getAsInt()); + setEmbed_enabled(job.get("embed_enabled").getAsBoolean()); + setUp_time(job.get("up_time").getAsString()); + setMeta_game(job.get("meta_game").getAsString()); + setFormat(job.get("format").getAsString()); + setEmbed_count(job.get("embed_count").getAsInt()); + setStream_type(job.get("stream_type").getAsString()); + setAbuse_reported(job.get("abuse_reported").getAsBoolean()); + setVideo_width(job.get("video_width").getAsInt()); + setGeo(job.get("geo").getAsString()); + setName(job.get("name").getAsString()); + setLanguage(job.get("language").getAsString()); + setStream_count(job.get("stream_count").getAsInt()); + setVideo_bitrate(job.get("video_bitrate").getAsDouble()); + setBroadcaster(job.get("broadcaster").getAsString()); + setChannel_view_count(job.get("channel_view_count").getAsInt()); + + setUsername(job.get("channel").getAsJsonObject().get("login").getAsString()); + setTitle(job.get("channel").getAsJsonObject().get("status").getAsString()); + setChannel_url(job.get("channel").getAsJsonObject().get("channel_url").getAsString()); + setProducer(job.get("channel").getAsJsonObject().get("producer").getAsBoolean()); + + setSubcategory_title(job.get("channel").getAsJsonObject().get("subcategory_title").getAsString()); + setScreen_cap_url_large(job.get("channel").getAsJsonObject().get("screen_cap_url_large").getAsString()); + setScreen_cap_url_small(job.get("channel").getAsJsonObject().get("screen_cap_url_small").getAsString()); + setScreen_cap_url_medium(job.get("channel").getAsJsonObject().get("screen_cap_url_medium").getAsString()); + setScreen_cap_url_huge(job.get("channel").getAsJsonObject().get("screen_cap_url_huge").getAsString()); + setTimezone(job.get("channel").getAsJsonObject().get("timezone").getAsString()); + setCategory_title(job.get("channel").getAsJsonObject().get("category_title").getAsString()); + setViews_count(job.get("channel").getAsJsonObject().get("views_count").getAsInt()); + } + + public boolean isOnline() { + return this.online; + } + + public void setOnline(boolean online) { + this.online = online; + } + + public int getBroadcast_part() { + return this.broadcast_part; + } + + public void setBroadcast_part(int broadcast_part) { + this.broadcast_part = broadcast_part; + } + + public boolean isFeatured() { + return this.featured; + } + + public void setFeatured(boolean featured) { + this.featured = featured; + } + + public boolean isChannel_subscription() { + return this.channel_subscription; + } + + public void setChannel_subscription(boolean channel_subscription) { + this.channel_subscription = channel_subscription; + } + + public String getId() { + return this.id; + } + + public void setId(String id) { + this.id = id; + } + + public String getCategory() { + return this.category; + } + + public void setCategory(String category) { + this.category = category; + } + + public String getTitle() { + return this.title; + } + + public void setTitle(String title) { + this.title = title; + } + + public int getChannel_count() { + return this.channel_count; + } + + public void setChannel_count(int channel_count) { + this.channel_count = channel_count; + } + + public int getVideo_height() { + return this.video_height; + } + + public void setVideo_height(int video_height) { + this.video_height = video_height; + } + + public int getSite_count() { + return this.site_count; + } + + public void setSite_count(int site_count) { + this.site_count = site_count; + } + + public boolean isEmbed_enabled() { + return this.embed_enabled; + } + + public void setEmbed_enabled(boolean embed_enabled) { + this.embed_enabled = embed_enabled; + } + + public String getUp_time() { + return this.up_time; + } + + public void setUp_time(String up_time) { + this.up_time = up_time; + } + + public String getMeta_game() { + return this.meta_game; + } + + public void setMeta_game(String meta_game) { + this.meta_game = meta_game; + } + + public String getFormat() { + return this.format; + } + + public void setFormat(String format) { + this.format = format; + } + + public int getEmbed_count() { + return this.embed_count; + } + + public void setEmbed_count(int embed_count) { + this.embed_count = embed_count; + } + + public String getStream_type() { + return this.stream_type; + } + + public void setStream_type(String stream_type) { + this.stream_type = stream_type; + } + + public boolean isAbuse_reported() { + return this.abuse_reported; + } + + public void setAbuse_reported(boolean abuse_reported) { + this.abuse_reported = abuse_reported; + } + + public int getVideo_width() { + return this.video_width; + } + + public void setVideo_width(int video_width) { + this.video_width = video_width; + } + + public String getGeo() { + return this.geo; + } + + public void setGeo(String geo) { + this.geo = geo; + } + + public String getName() { + return this.name; + } + + public void setName(String name) { + this.name = name; + } + + public String getLanguage() { + return this.language; + } + + public void setLanguage(String language) { + this.language = language; + } + + public int getStream_count() { + return this.stream_count; + } + + public void setStream_count(int stream_count) { + this.stream_count = stream_count; + } + + public double getVideo_bitrate() { + return this.video_bitrate; + } + + public void setVideo_bitrate(double video_bitrate) { + this.video_bitrate = video_bitrate; + } + + public String getBroadcaster() { + return this.broadcaster; + } + + public void setBroadcaster(String broadcaster) { + this.broadcaster = broadcaster; + } + + public int getChannel_view_count() { + return this.channel_view_count; + } + + public void setChannel_view_count(int channel_view_count) { + this.channel_view_count = channel_view_count; + } + + public String getUsername() { + return this.username; + } + + public void setUsername(String username) { + this.username = username; + } + + public String getStatus() { + return this.status; + } + + public void setStatus(String status) { + this.status = status; + } + + public String getChannel_url() { + return this.channel_url; + } + + public void setChannel_url(String channel_url) { + this.channel_url = channel_url; + } + + public boolean isProducer() { + return this.producer; + } + + public void setProducer(boolean producer) { + this.producer = producer; + } + + public String getSubcategory_title() { + return this.subcategory_title; + } + + public void setSubcategory_title(String subcategory_title) { + this.subcategory_title = subcategory_title; + } + + public String getScreen_cap_url_large() { + return this.screen_cap_url_large; + } + + public void setScreen_cap_url_large(String screen_cap_url_large) { + this.screen_cap_url_large = screen_cap_url_large; + } + + public String getScreen_cap_url_small() { + return this.screen_cap_url_small; + } + + public void setScreen_cap_url_small(String screen_cap_url_small) { + this.screen_cap_url_small = screen_cap_url_small; + } + + public String getScreen_cap_url_medium() { + return this.screen_cap_url_medium; + } + + public void setScreen_cap_url_medium(String screen_cap_url_medium) { + this.screen_cap_url_medium = screen_cap_url_medium; + } + + public String getScreen_cap_url_huge() { + return this.screen_cap_url_huge; + } + + public void setScreen_cap_url_huge(String screen_cap_url_huge) { + this.screen_cap_url_huge = screen_cap_url_huge; + } + + public String getTimezone() { + return this.timezone; + } + + public void setTimezone(String timezone) { + this.timezone = timezone; + } + + public String getCategory_title() { + return this.category_title; + } + + public void setCategory_title(String category_title) { + this.category_title = category_title; + } + + public int getViews_count() { + return this.views_count; + } + + public void setViews_count(int views_count) { + this.views_count = views_count; + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/utils/Direction.java b/src/de/joethei/core/api/utils/Direction.java new file mode 100644 index 0000000..98d7015 --- /dev/null +++ b/src/de/joethei/core/api/utils/Direction.java @@ -0,0 +1,37 @@ +package de.joethei.core.api.utils; + +public enum Direction +{ + NORTH(1, 0), + SOUTH(-1, 0), + EAST(0, 1), + WEST(0, -1), + NORTHEAST(1, 1), + SOUTHEAST(-1, 1), + NORTHWEST(1, -1), + SOUTHWEST(-1, -1); + + private int x; + private int z; + + private Direction(int x, int z) { this.x = x; + this.z = z; } + + public int getX() + { + return this.x; + } + + public int getZ() { + return this.z; + } + + public static Direction getDirection(String direction) { + for (Direction dir : values()) + { + if (dir.name().equalsIgnoreCase(direction)) + return dir; + } + return null; + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/utils/FakeDragon.java b/src/de/joethei/core/api/utils/FakeDragon.java new file mode 100644 index 0000000..4a7aa9f --- /dev/null +++ b/src/de/joethei/core/api/utils/FakeDragon.java @@ -0,0 +1,227 @@ +package de.joethei.core.api.utils; + +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 org.bukkit.Location; +import org.bukkit.entity.Player; + +public class FakeDragon +{ + 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 playerDragons = new HashMap(); + public static Map playerTextDragon = new HashMap(); + + static + { + try { + packetPlayOutSpawnEntityLiving = getMCClass("PacketPlayOutSpawnEntityLiving").getConstructor(new Class[] { getMCClass("EntityLiving") }); + entityEnderdragon = getMCClass("EntityEnderDragon").getConstructor(new Class[] { getMCClass("World") }); + + setLocation = getMCClass("EntityEnderDragon").getMethod("setLocation", new Class[] { Double.TYPE, Double.TYPE, Double.TYPE, Float.TYPE, Float.TYPE }); + setCustomName = getMCClass("EntityEnderDragon").getMethod("setCustomName", new Class[] { String.class }); + setHealth = getMCClass("EntityEnderDragon").getMethod("setHealth", new Class[] { Float.TYPE }); + setInvisible = getMCClass("EntityEnderDragon").getMethod("setInvisible", new Class[] { Boolean.TYPE }); + + getWorldHandle = getCraftClass("CraftWorld").getMethod("getHandle", new Class[0]); + getPlayerHandle = getCraftClass("entity.CraftPlayer").getMethod("getHandle", new Class[0]); + playerConnection = getMCClass("EntityPlayer").getDeclaredField("playerConnection"); + sendPacket = getMCClass("PlayerConnection").getMethod("sendPacket", new Class[] { getMCClass("Packet") }); + + getDatawatcher = getMCClass("EntityEnderDragon").getMethod("getDataWatcher", new Class[0]); + a = getMCClass("DataWatcher").getMethod("a", new Class[] { Integer.TYPE, 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 (playerDragons.containsKey(p.getName())) { + return playerDragons.get(p.getName()); + } + Object nms_world = getWorldHandle.invoke(p.getWorld(), new Object[0]); + playerDragons.put(p.getName(), entityEnderdragon.newInstance(new Object[] { nms_world })); + return 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, new Object[] { Double.valueOf(getPlayerLoc(p).getX()), Double.valueOf(getPlayerLoc(p).getY() + 800.0D), Double.valueOf(getPlayerLoc(p).getZ()), Float.valueOf(0.0F), Float.valueOf(0.0F) }); + setCustomName.invoke(nms_dragon, new Object[] { text }); + setHealth.invoke(nms_dragon, new Object[] { Integer.valueOf(200) }); + setInvisible.invoke(nms_dragon, new Object[] { Boolean.valueOf(true) }); + changeWatcher(nms_dragon, text); + Object nms_packet = packetPlayOutSpawnEntityLiving.newInstance(new Object[] { nms_dragon }); + Object nms_player = getPlayerHandle.invoke(p, new Object[0]); + Object nms_connection = playerConnection.get(nms_player); + sendPacket.invoke(nms_connection, new Object[] { 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, new Object[] { Double.valueOf(getPlayerLoc(p).getX()), Double.valueOf(getPlayerLoc(p).getY() + 800.0D), Double.valueOf(getPlayerLoc(p).getZ()), Float.valueOf(0.0F), Float.valueOf(0.0F) }); + setCustomName.invoke(nms_dragon, new Object[] { text }); + setHealth.invoke(nms_dragon, new Object[] { Float.valueOf(vie) }); + setInvisible.invoke(nms_dragon, new Object[] { Boolean.valueOf(true) }); + changeWatcher(nms_dragon, text); + Object nms_packet = packetPlayOutSpawnEntityLiving.newInstance(new Object[] { nms_dragon }); + Object nms_player = getPlayerHandle.invoke(p, new Object[0]); + Object nms_connection = playerConnection.get(nms_player); + sendPacket.invoke(nms_connection, new Object[] { 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, new Object[] { Double.valueOf(p.getLocation().getX()), Integer.valueOf(-5000), Double.valueOf(p.getLocation().getZ()), Float.valueOf(0.0F), Float.valueOf(0.0F) }); + setCustomName.invoke(nms_dragon, new Object[] { " " }); + setHealth.invoke(nms_dragon, new Object[] { Integer.valueOf(0) }); + setInvisible.invoke(nms_dragon, new Object[] { Boolean.valueOf(true) }); + changeWatcher(nms_dragon, " "); + Object nms_packet = packetPlayOutSpawnEntityLiving.newInstance(new Object[] { nms_dragon }); + Object nms_player = getPlayerHandle.invoke(p, new Object[0]); + Object nms_connection = playerConnection.get(nms_player); + sendPacket.invoke(nms_connection, new Object[] { nms_packet }); + } catch (Exception e) { + e.printStackTrace(); + } + } + + public 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, new Object[0]); + Map map = (Map)d.get(nms_watcher); + map.remove(Integer.valueOf(10)); + a.invoke(nms_watcher, new Object[] { Integer.valueOf(10), text }); + } + + private static Class getMCClass(String name) throws ClassNotFoundException { + String version = org.bukkit.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 = org.bukkit.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.0F) % 360.0F; + if (rotation < 0.0D) { + rotation += 360.0D; + } + if ((0.0D <= rotation) && (rotation < 22.5D)) + return "N"; + if ((22.5D <= rotation) && (rotation < 67.5D)) + return "NE"; + if ((67.5D <= rotation) && (rotation < 112.5D)) + return "E"; + if ((112.5D <= rotation) && (rotation < 157.5D)) + return "SE"; + if ((157.5D <= rotation) && (rotation < 202.5D)) + return "S"; + if ((202.5D <= rotation) && (rotation < 247.5D)) + return "SW"; + if ((247.5D <= rotation) && (rotation < 292.5D)) + return "W"; + if ((292.5D <= rotation) && (rotation < 337.5D)) + return "NW"; + if ((337.5D <= rotation) && (rotation < 360.0D)) { + return "N"; + } + return null; + } + + public static Location getPlayerLoc(Player p) + { + Location loc = p.getLocation(); + String str; + switch ((str = getCardinalDirection(p)).hashCode()) { case 69: + if (!str.equals("E")) break; + break; + case 78: + case 83: + if ((!str.equals("N")) || (goto 284) || + (!str.equals("S"))) break; + break; + case 87: + case 2487: + if ((!str.equals("W")) || + (goto 284) || + (!str.equals("NE"))) break; + break; + case 2505: + case 2642: + if ((!str.equals("NW")) || + (goto 284) || + (!str.equals("SE"))) break; + break; + case 2660: + if (!str.equals("SW")) + { + loc.add(0.0D, 0.0D, -150.0D); + + loc.add(150.0D, 0.0D, 0.0D); + + loc.add(0.0D, 0.0D, 150.0D); + + loc.add(-150.0D, 0.0D, 0.0D); + + loc.add(150.0D, 0.0D, -150.0D); + + loc.add(150.0D, 0.0D, 150.0D); + + loc.add(-150.0D, 0.0D, -150.0D); + } + else { + loc.add(-150.0D, 0.0D, 150.0D); + } + } + + return loc; + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/utils/FakeWither.java b/src/de/joethei/core/api/utils/FakeWither.java new file mode 100644 index 0000000..c7a1673 --- /dev/null +++ b/src/de/joethei/core/api/utils/FakeWither.java @@ -0,0 +1,277 @@ +package de.joethei.core.api.utils; + +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; +import org.bukkit.Location; +import org.bukkit.entity.Player; + +public class FakeWither +{ + 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 playerWithers = new HashMap(); + private static Map playerWithers2 = new HashMap(); + private static Map playerTextWither = new HashMap(); + + static + { + try { + packetPlayOutSpawnEntityLiving = getMCClass("PacketPlayOutSpawnEntityLiving").getConstructor(new Class[] { getMCClass("EntityLiving") }); + entityEntityWither = getMCClass("EntityWither").getConstructor(new Class[] { getMCClass("World") }); + + setLocation = getMCClass("EntityWither").getMethod("setLocation", new Class[] { Double.TYPE, Double.TYPE, Double.TYPE, Float.TYPE, Float.TYPE }); + setCustomName = getMCClass("EntityWither").getMethod("setCustomName", new Class[] { String.class }); + setHealth = getMCClass("EntityWither").getMethod("setHealth", new Class[] { Float.TYPE }); + setInvisible = getMCClass("EntityWither").getMethod("setInvisible", new Class[] { Boolean.TYPE }); + + getWorldHandle = getCraftClass("CraftWorld").getMethod("getHandle", new Class[0]); + getPlayerHandle = getCraftClass("entity.CraftPlayer").getMethod("getHandle", new Class[0]); + playerConnection = getMCClass("EntityPlayer").getDeclaredField("playerConnection"); + sendPacket = getMCClass("PlayerConnection").getMethod("sendPacket", new Class[] { getMCClass("Packet") }); + + getDatawatcher = getMCClass("EntityWither").getMethod("getDataWatcher", new Class[0]); + a = getMCClass("DataWatcher").getMethod("a", new Class[] { Integer.TYPE, 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()); + } + Object nms_world = getWorldHandle.invoke(p.getWorld(), new Object[0]); + playerWithers.put(p.getName(), entityEntityWither.newInstance(new Object[] { 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()); + } + Object nms_world = getWorldHandle.invoke(p.getWorld(), new Object[0]); + playerWithers2.put(p.getName(), entityEntityWither.newInstance(new Object[] { 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, new Object[] { Double.valueOf(getPlayerLoc(p).getX() + xr), Double.valueOf(getPlayerLoc(p).getY()), Double.valueOf(getPlayerLoc(p).getZ() + xr2), Float.valueOf(0.0F), Float.valueOf(0.0F) }); + setCustomName.invoke(nms_wither, new Object[] { text }); + setHealth.invoke(nms_wither, new Object[] { Integer.valueOf(300) }); + setInvisible.invoke(nms_wither, new Object[] { Boolean.valueOf(true) }); + changeWatcher(nms_wither, text); + Object nms_packet = packetPlayOutSpawnEntityLiving.newInstance(new Object[] { nms_wither }); + Object nms_player = getPlayerHandle.invoke(p, new Object[0]); + Object nms_connection = playerConnection.get(nms_player); + sendPacket.invoke(nms_connection, new Object[] { nms_packet }); + } catch (Exception e) { + e.printStackTrace(); + } + + try + { + Object nms_wither = getWither2(p); + setLocation.invoke(nms_wither, new Object[] { Double.valueOf(getPlayerLoc(p).getX() + xr2), Double.valueOf(p.getLocation().getY() - 10.0D), Double.valueOf(getPlayerLoc(p).getZ() + xr), Float.valueOf(0.0F), Float.valueOf(0.0F) }); + setCustomName.invoke(nms_wither, new Object[] { text }); + setHealth.invoke(nms_wither, new Object[] { Integer.valueOf(300) }); + setInvisible.invoke(nms_wither, new Object[] { Boolean.valueOf(true) }); + changeWatcher(nms_wither, text); + Object nms_packet = packetPlayOutSpawnEntityLiving.newInstance(new Object[] { nms_wither }); + Object nms_player = getPlayerHandle.invoke(p, new Object[0]); + Object nms_connection = playerConnection.get(nms_player); + sendPacket.invoke(nms_connection, new Object[] { 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, new Object[] { Double.valueOf(getPlayerLoc(p).getX() + xr), Double.valueOf(getPlayerLoc(p).getY()), Double.valueOf(getPlayerLoc(p).getZ() + xr2), Float.valueOf(0.0F), Float.valueOf(0.0F) }); + setCustomName.invoke(nms_wither, new Object[] { text }); + setHealth.invoke(nms_wither, new Object[] { Float.valueOf(vie) }); + setInvisible.invoke(nms_wither, new Object[] { Boolean.valueOf(true) }); + changeWatcher(nms_wither, text); + Object nms_packet = packetPlayOutSpawnEntityLiving.newInstance(new Object[] { nms_wither }); + Object nms_player = getPlayerHandle.invoke(p, new Object[0]); + Object nms_connection = playerConnection.get(nms_player); + sendPacket.invoke(nms_connection, new Object[] { nms_packet }); + } catch (Exception e) { + e.printStackTrace(); + } + + try + { + Object nms_wither = getWither2(p); + setLocation.invoke(nms_wither, new Object[] { Double.valueOf(getPlayerLoc(p).getX() + xr2), Double.valueOf(p.getLocation().getY() - 10.0D), Double.valueOf(getPlayerLoc(p).getZ() + xr), Float.valueOf(0.0F), Float.valueOf(0.0F) }); + setCustomName.invoke(nms_wither, new Object[] { text }); + setHealth.invoke(nms_wither, new Object[] { Float.valueOf(vie) }); + setInvisible.invoke(nms_wither, new Object[] { Boolean.valueOf(true) }); + changeWatcher(nms_wither, text); + Object nms_packet = packetPlayOutSpawnEntityLiving.newInstance(new Object[] { nms_wither }); + Object nms_player = getPlayerHandle.invoke(p, new Object[0]); + Object nms_connection = playerConnection.get(nms_player); + sendPacket.invoke(nms_connection, new Object[] { 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, new Object[] { Double.valueOf(p.getLocation().getX()), Integer.valueOf(-5000), Double.valueOf(p.getLocation().getZ()), Float.valueOf(0.0F), Float.valueOf(0.0F) }); + setCustomName.invoke(nms_wither, new Object[] { " " }); + setHealth.invoke(nms_wither, new Object[] { Integer.valueOf(0) }); + setInvisible.invoke(nms_wither, new Object[] { Boolean.valueOf(true) }); + changeWatcher(nms_wither, " "); + Object nms_packet = packetPlayOutSpawnEntityLiving.newInstance(new Object[] { nms_wither }); + Object nms_player = getPlayerHandle.invoke(p, new Object[0]); + Object nms_connection = playerConnection.get(nms_player); + sendPacket.invoke(nms_connection, new Object[] { nms_packet }); + } catch (Exception e) { + e.printStackTrace(); + } + } + + public 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, new Object[0]); + Map map = (Map)d.get(nms_watcher); + map.remove(Integer.valueOf(10)); + a.invoke(nms_watcher, new Object[] { Integer.valueOf(10), text }); + } + + private static Class getMCClass(String name) throws ClassNotFoundException + { + String version = org.bukkit.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 = org.bukkit.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.0F) % 360.0F; + if (rotation < 0.0D) { + rotation += 360.0D; + } + if ((0.0D <= rotation) && (rotation < 22.5D)) + return "N"; + if ((22.5D <= rotation) && (rotation < 67.5D)) + return "NE"; + if ((67.5D <= rotation) && (rotation < 112.5D)) + return "E"; + if ((112.5D <= rotation) && (rotation < 157.5D)) + return "SE"; + if ((157.5D <= rotation) && (rotation < 202.5D)) + return "S"; + if ((202.5D <= rotation) && (rotation < 247.5D)) + return "SW"; + if ((247.5D <= rotation) && (rotation < 292.5D)) + return "W"; + if ((292.5D <= rotation) && (rotation < 337.5D)) + return "NW"; + if ((337.5D <= rotation) && (rotation <= 360.0D)) { + return "N"; + } + return "N"; + } + + public static Location getPlayerLoc(Player p) + { + Location loc = p.getLocation(); + String str; + switch ((str = getCardinalDirection(p)).hashCode()) { case 69: + if (!str.equals("E")) break; + break; + case 78: + case 83: + if ((!str.equals("N")) || (goto 284) || + (!str.equals("S"))) break; + break; + case 87: + case 2487: + if ((!str.equals("W")) || + (goto 284) || + (!str.equals("NE"))) break; + break; + case 2505: + case 2642: + if ((!str.equals("NW")) || + (goto 284) || + (!str.equals("SE"))) break; + break; + case 2660: + if (!str.equals("SW")) + { + loc.add(0.0D, 0.0D, -50.0D); + + loc.add(50.0D, 0.0D, 0.0D); + + loc.add(0.0D, 0.0D, 50.0D); + + loc.add(-50.0D, 0.0D, 0.0D); + + loc.add(50.0D, 0.0D, -50.0D); + + loc.add(50.0D, 0.0D, 50.0D); + + loc.add(-50.0D, 0.0D, -50.0D); + } + else { + loc.add(-50.0D, 0.0D, 50.0D); + } + } + + return loc; + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/utils/GameProfileBuilder.java b/src/de/joethei/core/api/utils/GameProfileBuilder.java new file mode 100644 index 0000000..eca3cc2 --- /dev/null +++ b/src/de/joethei/core/api/utils/GameProfileBuilder.java @@ -0,0 +1,145 @@ +package de.joethei.core.api.utils; + +import com.google.gson.Gson; +import com.google.gson.GsonBuilder; +import com.google.gson.JsonDeserializationContext; +import com.google.gson.JsonDeserializer; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import com.google.gson.JsonParseException; +import com.google.gson.JsonParser; +import com.google.gson.JsonSerializationContext; +import com.google.gson.JsonSerializer; +import com.mojang.authlib.GameProfile; +import com.mojang.authlib.properties.Property; +import com.mojang.authlib.properties.PropertyMap; +import com.mojang.util.UUIDTypeAdapter; + +import java.io.BufferedReader; +import java.io.InputStreamReader; +import java.lang.reflect.Type; +import java.net.HttpURLConnection; +import java.net.URL; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.UUID; +import org.yaml.snakeyaml.external.biz.base64Coder.Base64Coder; + +public class GameProfileBuilder +{ + private HashMap cache = new HashMap(); + private Gson gson; + + public GameProfileBuilder() + { + GsonBuilder builder = new GsonBuilder().disableHtmlEscaping(); + + builder.registerTypeAdapter(UUID.class, new UUIDTypeAdapter()); + builder.registerTypeAdapter(GameProfile.class, new GameProfileSerializer()); + builder.registerTypeAdapter(PropertyMap.class, new PropertyMap.Serializer()); + + this.gson = builder.create(); + } + + public GameProfile fetch(UUID uuid) throws Exception { + return fetch(uuid, false); + } + + public GameProfile fetch(UUID uuid, boolean forceNew) throws Exception { + if ((!forceNew) && (this.cache.containsKey(uuid)) && (this.cache.get(uuid).isValid())) { + return this.cache.get(uuid).profile; + } + HttpURLConnection connection = (HttpURLConnection)new URL(String.format("https://sessionserver.mojang.com/session/minecraft/profile/%s?unsigned=false", new Object[] { UUIDTypeAdapter.fromUUID(uuid) })).openConnection(); + connection.setReadTimeout(5000); + + if (connection.getResponseCode() == 200) { + String json = new BufferedReader(new InputStreamReader(connection.getInputStream())).readLine(); + + GameProfile result = this.gson.fromJson(json, GameProfile.class); + this.cache.put(uuid, new CachedProfile(result)); + return result; + } + if ((!forceNew) && (this.cache.containsKey(uuid))) { + return this.cache.get(uuid).profile; + } + JsonObject error = (JsonObject)new JsonParser().parse(new BufferedReader(new InputStreamReader(connection.getErrorStream())).readLine()); + throw new Exception(error.get("error").getAsString() + ": " + error.get("errorMessage").getAsString()); + } + + public GameProfile getProfile(UUID uuid, String name, String skinUrl) + { + return getProfile(uuid, name, skinUrl, null); + } + + @SuppressWarnings({ "rawtypes" }) +public GameProfile getProfile(UUID uuid, String name, String skinUrl, String capeUrl) { + GameProfile profile = new GameProfile(uuid, name); + boolean cape = (capeUrl != null) && (!capeUrl.isEmpty()); + + List args = new ArrayList(); + args.add(Long.valueOf(System.currentTimeMillis())); + args.add(UUIDTypeAdapter.fromUUID(uuid)); + args.add(name); + args.add(skinUrl); + if (cape) args.add(capeUrl); + + profile.getProperties().put("textures", new Property("textures", Base64Coder.encodeString(String.format(cape ? "{\"timestamp\":%d,\"profileId\":\"%s\",\"profileName\":\"%s\",\"isPublic\":true,\"textures\":{\"SKIN\":{\"url\":\"%s\"},\"CAPE\":{\"url\":\"%s\"}}}" : "{\"timestamp\":%d,\"profileId\":\"%s\",\"profileName\":\"%s\",\"isPublic\":true,\"textures\":{\"SKIN\":{\"url\":\"%s\"}}}", args.toArray(new Object[args.size()]))))); + return profile; + } + + private class CachedProfile + { + private GameProfile profile; + private long timestamp; + + public CachedProfile(GameProfile profile) + { + this.profile = profile; + this.timestamp = System.currentTimeMillis(); + } + + public boolean isValid() { + return System.currentTimeMillis() - this.timestamp < 150000L; + } + } + + private class GameProfileSerializer + implements JsonSerializer, JsonDeserializer + { + private GameProfileSerializer() + { + } + + @SuppressWarnings("rawtypes") + public GameProfile deserialize(JsonElement json, Type type, JsonDeserializationContext context) + throws JsonParseException + { + JsonObject object = (JsonObject)json; + UUID id = object.has("id") ? (UUID)context.deserialize(object.get("id"), UUID.class) : null; + String name = object.has("name") ? object.getAsJsonPrimitive("name").getAsString() : null; + GameProfile profile = new GameProfile(id, name); + + PropertyMap properties = object.has("properties") ? (PropertyMap)context.deserialize(object.get("properties"), PropertyMap.class) : null; + + if (properties != null) { + for (Map.Entry prop : properties.entries()) { + profile.getProperties().put((String)prop.getKey(), (Property)prop.getValue()); + } + } + return profile; + } + + public JsonElement serialize(GameProfile profile, Type type, JsonSerializationContext context) { + JsonObject result = new JsonObject(); + if (profile.getId() != null) + result.add("id", context.serialize(profile.getId())); + if (profile.getName() != null) + result.addProperty("name", profile.getName()); + if (!profile.getProperties().isEmpty()) + result.add("properties", context.serialize(profile.getProperties())); + return result; + } + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/utils/Maths.java b/src/de/joethei/core/api/utils/Maths.java new file mode 100644 index 0000000..06f64c2 --- /dev/null +++ b/src/de/joethei/core/api/utils/Maths.java @@ -0,0 +1,281 @@ +package de.joethei.core.api.utils; + +import java.util.Calendar; +import java.util.GregorianCalendar; +import java.util.Random; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +public final class Maths +{ + public static final float nanoToSec = 1.0E-009F; + public static final float FLOAT_ROUNDING_ERROR = 1.0E-006F; + public static final float PI = 3.141593F; + public static final float PI2 = 6.283186F; + public static final float SQRT_3 = 1.73205F; + public static final float E = 2.718282F; + public static final float radiansToDegrees = 57.295776F; + public static final float radDeg = 57.295776F; + public static final float degreesToRadians = 0.01745329F; + public static final float degRad = 0.01745329F; + static final int ATAN2_DIM = (int)Math.sqrt(16384.0D); + private static final float INV_ATAN2_DIM_MINUS_1 = 1.0F / (ATAN2_DIM - 1); + + public static Random random = new Random(); + + public static final float sin(float radians) { + return Sin.table[((int)(radians * 2607.5945F) & 0x3FFF)]; + } + + public static final float cos(float radians) + { + return Sin.table[((int)((radians + 1.570796F) * 2607.5945F) & 0x3FFF)]; + } + + public static final float sinDeg(float degrees) + { + return Sin.table[((int)(degrees * 45.511112F) & 0x3FFF)]; + } + + public static final float cosDeg(float degrees) + { + return Sin.table[((int)((degrees + 90.0F) * 45.511112F) & 0x3FFF)]; + } + + public static final float atan2(float y, float x) + { + float mul; + float add; + if (x < 0.0F) + { + if (y < 0.0F) { + y = -y; + mul = 1.0F; + } else { + mul = -1.0F; + }x = -x; + add = -3.141593F; + } + else + { + if (y < 0.0F) { + y = -y; + mul = -1.0F; + } else { + mul = 1.0F; + }add = 0.0F; + } + float invDiv = 1.0F / ((x < y ? y : x) * INV_ATAN2_DIM_MINUS_1); + + if (invDiv == 1.0F) return ((float)Math.atan2(y, x) + add) * mul; + + int xi = (int)(x * invDiv); + int yi = (int)(y * invDiv); + return (Atan2.table[(yi * ATAN2_DIM + xi)] + add) * mul; + } + + public static final int random(int range) + { + return random.nextInt(range + 1); + } + + public static final int random(int start, int end) + { + return start + random.nextInt(end - start + 1); + } + + public static final boolean randomBoolean() + { + return random.nextBoolean(); + } + + public static final boolean randomBoolean(float chance) + { + return random() < chance; + } + + public static final float random() + { + return random.nextFloat(); + } + + public static final float random(float range) + { + return random.nextFloat() * range; + } + + public static final float random(float start, float end) + { + return start + random.nextFloat() * (end - start); + } + + public static int nextPowerOfTwo(int value) + { + if (value == 0) return 1; + value--; + value |= value >> 1; + value |= value >> 2; + value |= value >> 4; + value |= value >> 8; + value |= value >> 16; + return value + 1; + } + + public static boolean isPowerOfTwo(int value) { + return (value != 0) && ((value & value - 1) == 0); + } + + public static int clamp(int value, int min, int max) + { + if (value < min) return min; + if (value > max) return max; + return value; + } + + public static short clamp(short value, short min, short max) { + if (value < min) return min; + if (value > max) return max; + return value; + } + + public static float clamp(float value, float min, float max) { + if (value < min) return min; + if (value > max) return max; + return value; + } + + public static int floor(float x) + { + return (int)(x + 16384.0D) - 16384; + } + + public static int floorPositive(float x) + { + return (int)x; + } + + public static int ceil(float x) + { + return (int)(x + 16384.999999999996D) - 16384; + } + + public static int ceilPositive(float x) + { + return (int)(x + 0.9999999000000001D); + } + + public static int round(float x) + { + return (int)(x + 16384.5D) - 16384; + } + + public static int roundPositive(float x) + { + return (int)(x + 0.5F); + } + + public static boolean isZero(float value) + { + return Math.abs(value) <= 1.0E-006F; + } + + public static boolean isZero(float value, float tolerance) + { + return Math.abs(value) <= tolerance; + } + + public static boolean isEqual(float a, float b) + { + return Math.abs(a - b) <= 1.0E-006F; + } + + public static boolean isEqual(float a, float b, float tolerance) + { + return Math.abs(a - b) <= tolerance; + } + + public static long parseDateDiff(String time, boolean future) + throws Exception + { + Pattern timePattern = Pattern.compile("(?:([0-9]+)\\s*y[a-z]*[,\\s]*)?(?:([0-9]+)\\s*mo[a-z]*[,\\s]*)?(?:([0-9]+)\\s*w[a-z]*[,\\s]*)?(?:([0-9]+)\\s*d[a-z]*[,\\s]*)?(?:([0-9]+)\\s*h[a-z]*[,\\s]*)?(?:([0-9]+)\\s*m[a-z]*[,\\s]*)?(?:([0-9]+)\\s*(?:s[a-z]*)?)?", 2); + Matcher m = timePattern.matcher(time); + int years = 0; + int months = 0; + int weeks = 0; + int days = 0; + int hours = 0; + int minutes = 0; + int seconds = 0; + boolean found = false; + while (m.find()) { + if ((m.group() == null) || (m.group().isEmpty())) { + continue; + } + for (int i = 0; i < m.groupCount(); i++) { + if ((m.group(i) != null) && (!m.group(i).isEmpty())) { + found = true; + break; + } + } + if (found) { + if ((m.group(1) != null) && (!m.group(1).isEmpty())) + years = Integer.parseInt(m.group(1)); + if ((m.group(2) != null) && (!m.group(2).isEmpty())) + months = Integer.parseInt(m.group(2)); + if ((m.group(3) != null) && (!m.group(3).isEmpty())) + weeks = Integer.parseInt(m.group(3)); + if ((m.group(4) != null) && (!m.group(4).isEmpty())) + days = Integer.parseInt(m.group(4)); + if ((m.group(5) != null) && (!m.group(5).isEmpty())) + hours = Integer.parseInt(m.group(5)); + if ((m.group(6) != null) && (!m.group(6).isEmpty())) + minutes = Integer.parseInt(m.group(6)); + if ((m.group(7) == null) || (m.group(7).isEmpty())) break; + seconds = Integer.parseInt(m.group(7)); + break; + } + } + if (!found) + throw new Exception("Illegal Date"); + Calendar c = new GregorianCalendar(); + if (years > 0) + c.add(1, years * (future ? 1 : -1)); + if (months > 0) + c.add(2, months * (future ? 1 : -1)); + if (weeks > 0) + c.add(3, weeks * (future ? 1 : -1)); + if (days > 0) + c.add(5, days * (future ? 1 : -1)); + if (hours > 0) + c.add(11, hours * (future ? 1 : -1)); + if (minutes > 0) + c.add(12, minutes * (future ? 1 : -1)); + if (seconds > 0) + c.add(13, seconds * (future ? 1 : -1)); + return c.getTimeInMillis(); + } + + private static class Atan2 + { + static final float[] table = new float[16384]; + + static { for (int i = 0; i < Maths.ATAN2_DIM; i++) + for (int j = 0; j < Maths.ATAN2_DIM; j++) { + float x0 = i / Maths.ATAN2_DIM; + float y0 = j / Maths.ATAN2_DIM; + table[(j * Maths.ATAN2_DIM + i)] = (float)Math.atan2(y0, x0); + } + } + } + + private static class Sin + { + static final float[] table = new float[16384]; + + static { for (int i = 0; i < 16384; i++) + table[i] = (float)Math.sin((i + 0.5F) / 16384.0F * 6.283186F); + for (int i = 0; i < 360; i += 90) + table[((int)(i * 45.511112F) & 0x3FFF)] = (float)Math.sin(i * 0.01745329F); + } + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/utils/NameFetcher.java b/src/de/joethei/core/api/utils/NameFetcher.java new file mode 100644 index 0000000..33ea47d --- /dev/null +++ b/src/de/joethei/core/api/utils/NameFetcher.java @@ -0,0 +1,50 @@ +package de.joethei.core.api.utils; + +import com.google.common.collect.ImmutableList; +import java.io.InputStreamReader; +import java.net.HttpURLConnection; +import java.net.URL; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.UUID; +import java.util.concurrent.Callable; +import org.json.simple.JSONObject; +import org.json.simple.parser.JSONParser; + +public class NameFetcher + implements Callable> +{ + private static final String PROFILE_URL = "https://sessionserver.mojang.com/session/minecraft/profile/"; + private final JSONParser jsonParser = new JSONParser(); + private final List uuids; + + public NameFetcher(List uuids) + { + this.uuids = ImmutableList.copyOf(uuids); + } + + public Map call() throws Exception + { + Map uuidStringMap = new HashMap(); + for (UUID uuid : this.uuids) { + HttpURLConnection connection = (HttpURLConnection)new URL("https://sessionserver.mojang.com/session/minecraft/profile/" + uuid.toString().replace("-", "")).openConnection(); + JSONObject response = (JSONObject)this.jsonParser.parse(new InputStreamReader(connection.getInputStream())); + String name = (String)response.get("name"); + if (name == null) { + continue; + } + String cause = (String)response.get("cause"); + String errorMessage = (String)response.get("errorMessage"); + if ((cause != null) && (cause.length() > 0)) { + throw new IllegalStateException(errorMessage); + } + uuidStringMap.put(uuid, name); + } + return uuidStringMap; + } + +public static String getProfileUrl() { + return PROFILE_URL; +} +} \ No newline at end of file diff --git a/src/de/joethei/core/api/utils/RandomCollection.java b/src/de/joethei/core/api/utils/RandomCollection.java new file mode 100644 index 0000000..b9b72a6 --- /dev/null +++ b/src/de/joethei/core/api/utils/RandomCollection.java @@ -0,0 +1,41 @@ +package de.joethei.core.api.utils; + +import java.util.NavigableMap; +import java.util.Random; +import java.util.TreeMap; + +public class RandomCollection +{ + private final NavigableMap map = new TreeMap(); + private final Random random; + private double total = 0.0D; + + public RandomCollection() { + this(new Random()); + } + + public RandomCollection(Random random) { + this.random = random; + } + + public void add(double weight, E result) { + if (weight <= 0.0D) return; + this.total += weight; + this.map.put(Double.valueOf(this.total), result); + } + + public E next() { + double value = this.random.nextDouble() * this.total; + return this.map.ceilingEntry(Double.valueOf(value)).getValue(); + } + + public E random() { + double value = this.random.nextDouble() * this.total; + + while (this.random.nextBoolean()) { + value = this.random.nextDouble() * this.total; + } + + return this.map.ceilingEntry(Double.valueOf(value)).getValue(); + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/utils/Reflection.java b/src/de/joethei/core/api/utils/Reflection.java new file mode 100644 index 0000000..20cef4a --- /dev/null +++ b/src/de/joethei/core/api/utils/Reflection.java @@ -0,0 +1,140 @@ +package de.joethei.core.api.utils; + +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import org.bukkit.Bukkit; +import org.bukkit.entity.Entity; +import org.bukkit.entity.Player; +import org.bukkit.inventory.ItemStack; + +public class Reflection +{ + public static final Class CLASS_CRAFTITEMSTACK = getCraftBukkitClass("inventory.CraftItemStack"); + public static final Method METHOD_ASNMSCOPY = getMethod(CLASS_CRAFTITEMSTACK, "asNMSCopy"); + + public static void sendPacket(Player p, Object packet) { + try { + Object nmsPlayer = getNMSPlayer(p); + Object connection = nmsPlayer.getClass() + .getField("playerConnection").get(nmsPlayer); + connection.getClass() + .getMethod("sendPacket", new Class[] { getNMSClass("Packet") }) + .invoke(connection, new Object[] { packet }); + } catch (Exception e) { + e.printStackTrace(); + } + } + + public static Field getField(Class clazz, String field) { + Field re = null; + try { + re = clazz.getDeclaredField(field); + } catch (NoSuchFieldException e) { + e.printStackTrace(); + } catch (SecurityException e) { + e.printStackTrace(); + } + return re; + } + + public static void sendPacket(Player p, String packetName, Class[] parameterclass, Object[] parameters) { + try { + Object nmsPlayer = getNMSPlayer(p); + Object connection = nmsPlayer.getClass() + .getField("playerConnection").get(nmsPlayer); + Object packet = + Class.forName( + nmsPlayer.getClass().getPackage().getName() + "." + + packetName) + .getConstructor(parameterclass).newInstance(parameters); + connection.getClass() + .getMethod("sendPacket", new Class[] { getNMSClass("Packet") }) + .invoke(connection, new Object[] { packet }); + } catch (Exception e) { + e.printStackTrace(); + } + } + + public static String getVersion() { + String name = Bukkit.getServer().getClass().getPackage().getName(); + String version = name.substring(name.lastIndexOf('.') + 1) + "."; + return version; + } + + public static Class getNMSClass(String className) { + String fullName = "net.minecraft.server." + getVersion() + className; + Class clazz = null; + try { + clazz = Class.forName(fullName); + } catch (Exception e) { + e.printStackTrace(); + } + return clazz; + } + public static Class getCraftBukkitClass(String className) { + String fullName = "org.bukkit.craftbukkit." + getVersion() + className; + Class clazz = null; + try { + clazz = Class.forName(fullName); + } catch (Exception e) { + e.printStackTrace(); + } + return clazz; + } + + public static Object asNMSCopy(ItemStack i) throws IllegalAccessException, InvocationTargetException { + Object re = null; + try + { + METHOD_ASNMSCOPY.invoke(null, new Object[] { i }); + } + catch (java.lang.IllegalArgumentException e) { + e.printStackTrace(); + } + + return re; + } + + public static Field getField(Field f) { + f.setAccessible(true); + return f; + } + public static Constructor getConstructor(Class clazz, Class[] param) { + Constructor re = null; + try { + re = clazz.getConstructor(param); + } catch (Exception e) { + e.printStackTrace(); + } + return re; + } + public static Object getHandle(Entity entity) { + Object object = null; + try + { + object = getMethod(entity.getClass(), "getHandle").invoke(entity, new Object[0]); + } catch (Exception e) { + e.printStackTrace(); + } + + return object; + } + + public static Object getNMSPlayer(Player player) { + return getHandle(player); + } + + public static Method getMethod(Class c, String methodName) { + Method returnMethod = null; + + for (Method m : c.getDeclaredMethods()) { + if (m.getName().equals(methodName)) { + returnMethod = m; + } + } + + return returnMethod; + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/utils/Vectors.java b/src/de/joethei/core/api/utils/Vectors.java new file mode 100644 index 0000000..466f223 --- /dev/null +++ b/src/de/joethei/core/api/utils/Vectors.java @@ -0,0 +1,45 @@ +package de.joethei.core.api.utils; + +import org.bukkit.util.Vector; + +public final class Vectors +{ + public static final Vector rotateAroundAxisX(Vector v, double angle) + { + double cos = Math.cos(angle); + double sin = Math.sin(angle); + double y = v.getY() * cos - v.getZ() * sin; + double z = v.getY() * sin + v.getZ() * cos; + return v.setY(y).setZ(z); + } + + public static final Vector rotateAroundAxisY(Vector v, double angle) + { + double cos = Math.cos(angle); + double sin = Math.sin(angle); + double x = v.getX() * cos + v.getZ() * sin; + double z = v.getX() * -sin + v.getZ() * cos; + return v.setX(x).setZ(z); + } + + public static final Vector rotateAroundAxisZ(Vector v, double angle) + { + double cos = Math.cos(angle); + double sin = Math.sin(angle); + double x = v.getX() * cos - v.getY() * sin; + double y = v.getX() * sin + v.getY() * cos; + return v.setX(x).setY(y); + } + + public static final Vector rotateVector(Vector v, double angleX, double angleY, double angleZ) + { + rotateAroundAxisX(v, angleX); + rotateAroundAxisY(v, angleY); + rotateAroundAxisZ(v, angleZ); + return v; + } + + public static final double angleToXAxis(Vector vector) { + return Math.atan2(vector.getX(), vector.getY()); + } +} \ No newline at end of file diff --git a/src/de/joethei/core/api/youtube/YTAPI.java b/src/de/joethei/core/api/youtube/YTAPI.java new file mode 100644 index 0000000..0e4c897 --- /dev/null +++ b/src/de/joethei/core/api/youtube/YTAPI.java @@ -0,0 +1,119 @@ +package de.joethei.core.api.youtube; + +import java.io.BufferedReader; +import java.io.InputStreamReader; +import java.net.URL; + +import com.google.gson.Gson; +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; + +public class YTAPI { + + public static Gson gson = new Gson(); + + public static String readJsonFromUrl(String urlString) throws Exception { + BufferedReader reader = null; + try { + URL url = new URL(urlString); + reader = new BufferedReader(new InputStreamReader(url.openStream())); + StringBuffer buffer = new StringBuffer(); + int read; + char[] chars = new char[1024]; + while ((read = reader.read(chars)) != -1) + buffer.append(chars, 0, read); + + return buffer.toString(); + } finally { + if (reader != null) + reader.close(); + } + } + + public static String getGooglePlusId(String uri) throws Exception { + String endid = uri.split("/")[uri.split("/").length - 1]; + String json = YTAPI.readJsonFromUrl("http://gdata.youtube.com/feeds/api/users/" + endid + "?alt=json"); + JsonObject jo = gson.fromJson(json, JsonObject.class); + String gplusid = jo.get("entry").getAsJsonObject().get("yt$googlePlusUserId").getAsJsonObject().get("$t") + .getAsString(); + return gplusid; + } + + public static String getChannelFromGPlusId(String plusid, String uri, String developerkey) throws Exception { + + String endid = uri; + + try { + String json = YTAPI + .readJsonFromUrl("https://www.googleapis.com/plus/v1/people/" + plusid + "?key=" + developerkey); + JsonObject jb = gson.fromJson(json, JsonObject.class); + JsonObject jo = jb; + JsonArray ja = jo.get("urls").getAsJsonArray(); + for (int i = 0; i < ja.size(); i++) { + JsonObject jsob = (JsonObject) ja.get(i); + if (jsob.get("value").getAsString().toLowerCase().contains("youtube")) { + return jsob.get("value").getAsString(); + } + } + return "No Google Plus Data To Find The Channel"; + } catch (NullPointerException e) { + e.printStackTrace(); + return "No Google Plus Data To Find The Channel"; + } + + } + + public static YoutubeChannel getYTChannelFromUri(String uri) { + try { + System.out.println(uri); + YoutubeChannel ch; + String json = YTAPI.readJsonFromUrl(uri + "?alt=json"); + JsonObject jb = gson.fromJson(json, JsonObject.class); + String username = jb.get("entry").getAsJsonObject().get("yt$username").getAsJsonObject().get("$t") + .getAsString(); + String about_us = jb.get("entry").getAsJsonObject().get("content").getAsJsonObject().get("$t") + .getAsString(); + String title = jb.get("entry").getAsJsonObject().get("title").getAsJsonObject().get("$t").getAsString(); + String subscribers = jb.get("entry").getAsJsonObject().get("yt$statistics").getAsJsonObject() + .get("subscriberCount").getAsString(); + String gplusid = jb.get("entry").getAsJsonObject().get("yt$googlePlusUserId").getAsJsonObject().get("$t") + .getAsString(); + String firstname = ""; + String lastname = ""; + if (jb.get("entry").getAsJsonObject().get("yt$firstName") != null) { + firstname = jb.get("entry").getAsJsonObject().get("yt$firstName").getAsJsonObject().get("$t") + .getAsString(); + } + if (jb.get("entry").getAsJsonObject().get("yt$lastName") != null) { + + lastname = jb.get("entry").getAsJsonObject().get("yt$lastName").getAsJsonObject().get("$t") + .getAsString(); + ; + } + String location = jb.get("entry").getAsJsonObject().get("yt$location").getAsJsonObject().get("$t") + .getAsString(); + ; + String lastwebaccess = jb.get("entry").getAsJsonObject().get("yt$statistics").getAsJsonObject() + .get("lastWebAccess").getAsString(); + int videowatchcount = jb.get("entry").getAsJsonObject().get("yt$statistics").getAsJsonObject() + .get("videoWatchCount").getAsInt(); + int viewcount = jb.get("entry").getAsJsonObject().get("yt$statistics").getAsJsonObject().get("viewCount") + .getAsInt(); + String totaluploadviews = jb.get("entry").getAsJsonObject().get("yt$statistics").getAsJsonObject() + .get("totalUploadViews").getAsString(); + String avatar = jb.get("entry").getAsJsonObject().get("media$thumbnail").getAsJsonObject().get("url") + .getAsString(); + ch = new YoutubeChannel(about_us, title, username, subscribers, gplusid, firstname, lastname, location, + lastwebaccess, videowatchcount, viewcount, totaluploadviews, avatar); + return ch; + } catch (Exception err) { + err.printStackTrace(); + return null; + } + } + + public static YoutubeChannel getYTChannelFromName(String channel) { + return getYTChannelFromUri("http://gdata.youtube.com/feeds/api/users/" + channel); + } + +} \ No newline at end of file diff --git a/src/de/joethei/core/api/youtube/YoutubeChannel.java b/src/de/joethei/core/api/youtube/YoutubeChannel.java new file mode 100644 index 0000000..1dd33dc --- /dev/null +++ b/src/de/joethei/core/api/youtube/YoutubeChannel.java @@ -0,0 +1,242 @@ +package de.joethei.core.api.youtube; + +import java.beans.ConstructorProperties; + +public class YoutubeChannel { + String about_us; + String title; + String username; + String subscribers; + String googleplusid; + String firstname = ""; + String lastname = ""; + String location; + String lastwebaccess; + int videoWatchCount; + int viewcount; + String totaluploadViews; + String avatar; + + @ConstructorProperties({ "about_us", "title", "username", "subscribers", "googleplusid", "firstname", "lastname", + "location", "lastwebaccess", "videoWatchCount", "viewcount", "totaluploadViews", "avatar" }) + public YoutubeChannel(String about_us, String title, String username, String subscribers, String googleplusid, + String firstname, String lastname, String location, String lastwebaccess, int videoWatchCount, + int viewcount, String totaluploadViews, String avatar) { + this.about_us = about_us; + this.title = title; + this.username = username; + this.subscribers = subscribers; + this.googleplusid = googleplusid; + this.firstname = firstname; + this.lastname = lastname; + this.location = location; + this.lastwebaccess = lastwebaccess; + this.videoWatchCount = videoWatchCount; + this.viewcount = viewcount; + this.totaluploadViews = totaluploadViews; + this.avatar = avatar; + } + + public String getAbout_us() { + return this.about_us; + } + + public String getTitle() { + return this.title; + } + + public String getUsername() { + return this.username; + } + + public String getSubscribers() { + return this.subscribers; + } + + public String getGoogleplusid() { + return this.googleplusid; + } + + public String getFirstname() { + return this.firstname; + } + + public String getLastname() { + return this.lastname; + } + + public String getLocation() { + return this.location; + } + + public String getLastwebaccess() { + return this.lastwebaccess; + } + + public int getVideoWatchCount() { + return this.videoWatchCount; + } + + public int getViewcount() { + return this.viewcount; + } + + public String getTotaluploadViews() { + return this.totaluploadViews; + } + + public String getAvatar() { + return this.avatar; + } + + public void setAbout_us(String about_us) { + this.about_us = about_us; + } + + public void setTitle(String title) { + this.title = title; + } + + public void setUsername(String username) { + this.username = username; + } + + public void setSubscribers(String subscribers) { + this.subscribers = subscribers; + } + + public void setGoogleplusid(String googleplusid) { + this.googleplusid = googleplusid; + } + + public void setFirstname(String firstname) { + this.firstname = firstname; + } + + public void setLastname(String lastname) { + this.lastname = lastname; + } + + public void setLocation(String location) { + this.location = location; + } + + public void setLastwebaccess(String lastwebaccess) { + this.lastwebaccess = lastwebaccess; + } + + public void setVideoWatchCount(int videoWatchCount) { + this.videoWatchCount = videoWatchCount; + } + + public void setViewcount(int viewcount) { + this.viewcount = viewcount; + } + + public void setTotaluploadViews(String totaluploadViews) { + this.totaluploadViews = totaluploadViews; + } + + public void setAvatar(String avatar) { + this.avatar = avatar; + } + + public boolean equals(Object o) { + if (o == this) + return true; + if (!(o instanceof YoutubeChannel)) + return false; + YoutubeChannel other = (YoutubeChannel) o; + if (!other.canEqual(this)) + return false; + Object this$about_us = getAbout_us(); + Object other$about_us = other.getAbout_us(); + if (this$about_us == null ? other$about_us != null : !this$about_us.equals(other$about_us)) + return false; + Object this$title = getTitle(); + Object other$title = other.getTitle(); + if (this$title == null ? other$title != null : !this$title.equals(other$title)) + return false; + Object this$username = getUsername(); + Object other$username = other.getUsername(); + if (this$username == null ? other$username != null : !this$username.equals(other$username)) + return false; + Object this$subscribers = getSubscribers(); + Object other$subscribers = other.getSubscribers(); + if (this$subscribers == null ? other$subscribers != null : !this$subscribers.equals(other$subscribers)) + return false; + Object this$googleplusid = getGoogleplusid(); + Object other$googleplusid = other.getGoogleplusid(); + if (this$googleplusid == null ? other$googleplusid != null : !this$googleplusid.equals(other$googleplusid)) + return false; + Object this$firstname = getFirstname(); + Object other$firstname = other.getFirstname(); + if (this$firstname == null ? other$firstname != null : !this$firstname.equals(other$firstname)) + return false; + Object this$lastname = getLastname(); + Object other$lastname = other.getLastname(); + if (this$lastname == null ? other$lastname != null : !this$lastname.equals(other$lastname)) + return false; + Object this$location = getLocation(); + Object other$location = other.getLocation(); + if (this$location == null ? other$location != null : !this$location.equals(other$location)) + return false; + Object this$lastwebaccess = getLastwebaccess(); + Object other$lastwebaccess = other.getLastwebaccess(); + if (this$lastwebaccess == null ? other$lastwebaccess != null : !this$lastwebaccess.equals(other$lastwebaccess)) + return false; + if (getVideoWatchCount() != other.getVideoWatchCount()) + return false; + if (getViewcount() != other.getViewcount()) + return false; + Object this$totaluploadViews = getTotaluploadViews(); + Object other$totaluploadViews = other.getTotaluploadViews(); + if (this$totaluploadViews == null ? other$totaluploadViews != null + : !this$totaluploadViews.equals(other$totaluploadViews)) + return false; + Object this$avatar = getAvatar(); + Object other$avatar = other.getAvatar(); + return this$avatar == null ? other$avatar == null : this$avatar.equals(other$avatar); + } + + public boolean canEqual(Object other) { + return other instanceof YoutubeChannel; + } + + public int hashCode() { + int PRIME = 31; + int result = 1; + Object $about_us = getAbout_us(); + result = result * 31 + ($about_us == null ? 0 : $about_us.hashCode()); + Object $title = getTitle(); + result = result * 31 + ($title == null ? 0 : $title.hashCode()); + Object $username = getUsername(); + result = result * 31 + ($username == null ? 0 : $username.hashCode()); + Object $subscribers = getSubscribers(); + result = result * 31 + ($subscribers == null ? 0 : $subscribers.hashCode()); + Object $googleplusid = getGoogleplusid(); + result = result * 31 + ($googleplusid == null ? 0 : $googleplusid.hashCode()); + Object $firstname = getFirstname(); + result = result * 31 + ($firstname == null ? 0 : $firstname.hashCode()); + Object $lastname = getLastname(); + result = result * 31 + ($lastname == null ? 0 : $lastname.hashCode()); + Object $location = getLocation(); + result = result * 31 + ($location == null ? 0 : $location.hashCode()); + Object $lastwebaccess = getLastwebaccess(); + result = result * 31 + ($lastwebaccess == null ? 0 : $lastwebaccess.hashCode()); + result = result * 31 + getVideoWatchCount(); + result = result * 31 + getViewcount(); + Object $totaluploadViews = getTotaluploadViews(); + result = result * 31 + ($totaluploadViews == null ? 0 : $totaluploadViews.hashCode()); + Object $avatar = getAvatar(); + return result * 31 + ($avatar == null ? 0 : $avatar.hashCode()); + } + + public String toString() { + return "YoutubeChannel(about_us=" + getAbout_us() + ", title=" + getTitle() + ", username=" + getUsername() + + ", subscribers=" + getSubscribers() + ", googleplusid=" + getGoogleplusid() + ", firstname=" + + getFirstname() + ", lastname=" + getLastname() + ", location=" + getLocation() + ", lastwebaccess=" + + getLastwebaccess() + ", videoWatchCount=" + getVideoWatchCount() + ", viewcount=" + getViewcount() + + ", totaluploadViews=" + getTotaluploadViews() + ", avatar=" + getAvatar() + ")"; + } +} \ No newline at end of file diff --git a/src/de/joethei/core/commands/Ban.java b/src/de/joethei/core/commands/Ban.java new file mode 100644 index 0000000..be3b2bf --- /dev/null +++ b/src/de/joethei/core/commands/Ban.java @@ -0,0 +1,110 @@ +package de.joethei.core.commands; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +import org.bukkit.Bukkit; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +import de.joethei.core.Core; +import de.joethei.core.api.AutoCommand; +import de.joethei.core.api.CustomPlayer; +import de.joethei.core.api.Messages; +import de.joethei.core.api.Perms.Ranks; + +/** + * command to ban players + * @author joethei + * @version 1.0 + */ +public class Ban extends AutoCommand{ + + /** + * @param plugin main class + * @param command command to execute + * @param description describes the command + * @param aliases aliases of command + */ + public Ban(Core plugin, String command, String description, String[] aliases) { + super(plugin, command, description, aliases); + } + + @Override + public boolean execute(CommandSender sender, String label, String[] args) { + if(sender instanceof Player) { + CustomPlayer p = CustomPlayer.getPlayer(sender.getName()); + if(p.isAllowed(Ranks.Moderator)) { + if(args.length >= 3) { + if(Bukkit.getPlayer(args[0]) != null) { + CustomPlayer t = CustomPlayer.getPlayer(args[0]); + if(getReasons().containsKey(args[1])) { + String string = getReasons().get(args[1]); + int id = Integer.parseInt(string); + + t.ban(getReasons().get(id), p, getBanDurations().get(id)); + }else { + p.sendMessage(Messages.PREFIX + "§cDieser Grund exsistiert nicht"); + } + }else { + p.sendMessage(Messages.PREFIX + "§cDer Spieler " + args[0] + " exsistiert nicht, oder ist nicht online."); + } + }else { + p.sendMessage(Messages.PREFIX + "§cNutze /ban "); + } + }else { + sender.sendMessage(Messages.NO_PERMS); + } + }else { + sender.sendMessage(Messages.NOT_A_PLAYER); + } + return true; + } + + @Override + public List tabComplete(CommandSender sender, String label, String[] args) { + List list = new ArrayList(); + for(int i = 0; i >= getReasons().size(); i++) { + list.add(getReasons().get(i)); + } + return list; + } + + /** + * @return all possible ban reasons + */ + private HashMap getReasons() { + HashMap map = new HashMap(); + + map.put(1, "Hacking"); + map.put(2, "Griefing"); + map.put(3, "Bugusing"); + map.put(4, "Beleidigung"); + map.put(5, "Spam"); + map.put(6, "Banumgehung"); + map.put(7, "Werbung"); + map.put(8, "Trolling"); + + return map; + } + + /** + * @return ban durations to reason + */ + private HashMap getBanDurations() { + HashMap map = new HashMap(); + + map.put(1, 60); + map.put(2, 30); + map.put(3, 20); + map.put(4, 10); + map.put(5, 5); + map.put(6, 50); + map.put(7, 15); + map.put(8, 25); + + return map; + } + +} \ No newline at end of file diff --git a/src/de/joethei/core/commands/Build.java b/src/de/joethei/core/commands/Build.java new file mode 100644 index 0000000..6af9575 --- /dev/null +++ b/src/de/joethei/core/commands/Build.java @@ -0,0 +1,70 @@ +package de.joethei.core.commands; + +import java.util.ArrayList; +import java.util.List; + +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +import de.joethei.core.Core; +import de.joethei.core.api.AutoCommand; +import de.joethei.core.api.Messages; +import de.joethei.core.api.CustomPlayer; +import de.joethei.core.api.Perms.Ranks; + +/** + * lets player build + * @author joethei + * @version 1.0 + */ +public class Build extends AutoCommand{ + + /** + * player who can build + */ + private static ArrayList players = new ArrayList(); + + /** + * @return player that can build + */ + public static ArrayList getPlayers() { + return players; + } + + /** + * @param plugin main class + * @param command command to execute + * @param description describes the command + * @param aliases aliases of command + */ + public Build(Core plugin, String command, String description, String[] aliases) { + super(plugin, command, description, aliases); + } + + @Override + public boolean execute(CommandSender sender, String label, String[] args) { + if(sender instanceof Player) { + CustomPlayer p = CustomPlayer.getPlayer(sender.getName()); + if(p.isAllowed(Ranks.Builder)) { + if(players.contains(p)) { + players.remove(p); + p.sendMessage("§cDu kannst nun nicht mehr bauen"); + }else { + players.add(p); + p.sendMessage("§aDu kannst nun bauen"); + } + }else { + sender.sendMessage(Messages.NO_PERMS); + } + }else { + sender.sendMessage(Messages.NOT_A_PLAYER); + } + return false; + } + + @Override + public List tabComplete(CommandSender sender, String label, String[] args) { + return null; + } + +} \ No newline at end of file diff --git a/src/de/joethei/core/commands/Fix.java b/src/de/joethei/core/commands/Fix.java new file mode 100644 index 0000000..d881503 --- /dev/null +++ b/src/de/joethei/core/commands/Fix.java @@ -0,0 +1,75 @@ +package de.joethei.core.commands; + +import java.util.ArrayList; +import java.util.List; + +import org.bukkit.Bukkit; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +import de.joethei.core.Core; +import de.joethei.core.api.AutoCommand; +import de.joethei.core.api.Messages; +import de.joethei.core.api.CustomPlayer; + +/** + * fixes players + * @author joethei + * @version 1.0 + */ +public class Fix extends AutoCommand{ + + /** + * @param plugin main class + * @param command command to execute + * @param description describes the command + * @param aliases aliases of command + */ + public Fix(Core plugin, String command, String description, String[] aliases) { + super(plugin, command, description, aliases); + } + + @Override + public boolean execute(CommandSender sender, String label, String[] args) { + if(sender instanceof Player) { + CustomPlayer p = CustomPlayer.getPlayer(sender.getName()); + if(args.length == 0) { + for(Player player : Bukkit.getOnlinePlayers()) { + player.hidePlayer(p); + player.showPlayer(p); + } + p.teleport(p.getLocation()); + p.sendMessage("§6Du hast dich gefixt"); + } + if(args.length == 1) { + if(Bukkit.getPlayer(args[0]) != null) { + CustomPlayer t = CustomPlayer.getPlayer(Bukkit.getPlayer(args[0]).getName()); + if(t != p) { + p.hidePlayer(t); + p.showPlayer(t); + p.teleport(p.getLocation()); + p.sendMessage("§6Du hast den Spieler " + t.getDisplayName() + " gefixt"); + t.sendMessage("§6Du wurdest von " + p.getDisplayName() + " gefixt"); + }else { + p.chat("/fix"); + } + }else { + p.sendMessage("§cDieser Spieler ist nicht online"); + } + } + }else { + sender.sendMessage(Messages.NOT_A_PLAYER); + } + return true; + } + + @Override + public List tabComplete(CommandSender sender, String label, String[] args) { + List list = new ArrayList(); + + for(Player players : Bukkit.getOnlinePlayers()) { + list.add(players.getDisplayName()); + } + return list; + } +} \ No newline at end of file diff --git a/src/de/joethei/core/commands/GameMode.java b/src/de/joethei/core/commands/GameMode.java new file mode 100644 index 0000000..ef30461 --- /dev/null +++ b/src/de/joethei/core/commands/GameMode.java @@ -0,0 +1,87 @@ +package de.joethei.core.commands; + +import java.util.ArrayList; +import java.util.List; + +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +import de.joethei.core.Core; +import de.joethei.core.api.AutoCommand; +import de.joethei.core.api.Messages; +import de.joethei.core.api.CustomPlayer; +import de.joethei.core.api.Perms.Ranks; + +/** + * changes game modes + * @author joethei + * @version 1.0 + */ +public class GameMode extends AutoCommand{ + + /** + * @param plugin main class + * @param command command to execute + * @param description describes the command + * @param aliases aliases of command + */ + public GameMode(Core plugin, String command, String description, String[] aliases) { + super(plugin, command, description, aliases); + } + + @Override + public boolean execute(CommandSender sender, String label, String[] args) { + if(sender instanceof Player) { + CustomPlayer p = CustomPlayer.getPlayer(sender.getName()); + if(p.isAllowed(Ranks.Builder)) { + if(args.length == 1) { + String mode = args[0]; + p.setGameMode(getModeFromString(mode)); + p.sendMessage("§aDein Spielmodus wurde geändert"); + }else { + p.sendMessage("§cNutze /gm <0 | 1 | 2 | 3>"); + } + }else { + p.sendMessage(Messages.NO_PERMS); + } + }else { + sender.sendMessage(Messages.NOT_A_PLAYER); + } + return true; + } + + @Override + public List tabComplete(CommandSender sender, String label, String[] args) { + List list = new ArrayList(); + + list.add("0"); + list.add("1"); + list.add("2"); + list.add("3"); + list.add("Survival"); + list.add("Creative"); + list.add("Adventure"); + list.add("Spectator"); + + return list; + } + + /** + * @param string Mode + * @return GameMode + */ + private org.bukkit.GameMode getModeFromString(String string) { + switch(string) { + case "0" : return org.bukkit.GameMode.SURVIVAL; + case "1" : return org.bukkit.GameMode.CREATIVE; + case "2": return org.bukkit.GameMode.ADVENTURE; + case "3" : return org.bukkit.GameMode.SPECTATOR; + case "Survial" : return org.bukkit.GameMode.SURVIVAL; + case "Creative" : return org.bukkit.GameMode.CREATIVE; + case "Adventure" : return org.bukkit.GameMode.ADVENTURE; + case "Spectator" : return org.bukkit.GameMode.SPECTATOR; + default: return org.bukkit.GameMode.SPECTATOR; + } + } + +} \ No newline at end of file diff --git a/src/de/joethei/core/commands/GlobalMute.java b/src/de/joethei/core/commands/GlobalMute.java new file mode 100644 index 0000000..a054834 --- /dev/null +++ b/src/de/joethei/core/commands/GlobalMute.java @@ -0,0 +1,58 @@ +package de.joethei.core.commands; + +import java.util.List; + +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +import de.joethei.core.Core; +import de.joethei.core.api.AutoCommand; +import de.joethei.core.api.Messages; +import de.joethei.core.api.CustomPlayer; +import de.joethei.core.api.Perms.Ranks; +import de.joethei.core.api.Settings; + +/** + * mutes the whole server + * @author joethei + * @version 1.0 + */ +public class GlobalMute extends AutoCommand{ + + /** + * @param plugin main class + * @param command command to execute + * @param description describes the command + * @param aliases aliases of command + */ + public GlobalMute(Core plugin, String command, String description, String[] aliases) { + super(plugin, command, description, aliases); + } + + @Override + public boolean execute(CommandSender sender, String label, String[] args) { + if(sender instanceof Player) { + CustomPlayer p = CustomPlayer.getPlayer(sender.getName()); + if(p.isAllowed(Ranks.Moderator)) { + if(Settings.isMute()) { + Settings.setMute(false); + p.sendMessage("§cGlobal Mute deaktiviert"); + }else { + Settings.setMute(true); + p.sendMessage("§aGlobal Mute aktiviert"); + } + }else { + p.sendMessage(Messages.NO_PERMS); + } + }else { + sender.sendMessage(Messages.NOT_A_PLAYER); + } + return false; + } + + @Override + public List tabComplete(CommandSender sender, String label, String[] args) { + return null; + } + +} \ No newline at end of file diff --git a/src/de/joethei/core/commands/RunAs.java b/src/de/joethei/core/commands/RunAs.java new file mode 100644 index 0000000..a533b6a --- /dev/null +++ b/src/de/joethei/core/commands/RunAs.java @@ -0,0 +1,77 @@ +package de.joethei.core.commands; + +import java.util.ArrayList; +import java.util.List; + +import org.bukkit.Bukkit; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +import de.joethei.core.Core; +import de.joethei.core.api.AutoCommand; +import de.joethei.core.api.Messages; +import de.joethei.core.api.CustomPlayer; +import de.joethei.core.api.Perms.Ranks; + +/** + * lets other player run commands + * @author joethei + * @version 1.0 + */ +public class RunAs extends AutoCommand{ + + /** + * @param plugin main class + * @param command command to execute + * @param description describes the command + * @param aliases aliases of command + */ + public RunAs(Core plugin, String command, String description, String[] aliases) { + super(plugin, command, description, aliases); + } + + + @Override + public boolean execute(CommandSender sender, String label, String[] args) { + if(sender instanceof Player) { + CustomPlayer p = CustomPlayer.getPlayer(sender.getName()); + if(p.isAllowed(Ranks.Admin)) { + if(args.length >= 2) { + CustomPlayer t = CustomPlayer.getPlayer(Bukkit.getPlayer(args[0]).getName()); + if(t != null) { + String msg = ""; + for(int i = 1; i < args.length; i++) { + msg = msg + args[i] + " "; + } + t.chat(msg); + p.sendMessage("§2Erfolgreich ausgeführt"); + return true; + }else { + String msg = Messages.readString("Messages.Player.NotOnline"); + msg = msg.replace("$player", args[0]); + p.sendMessage(msg); + } + }else { + p.sendMessage("§cDu musst §6/RunAs §causführen"); + } + }else { + p.sendMessage(Messages.NO_PERMS); + } + }else { + sender.sendMessage(Messages.NOT_A_PLAYER); + } + return false; + } + + @Override + public List tabComplete(CommandSender sender, String label, String[] args) { + List list = new ArrayList(); + + for(Player players : Bukkit.getOnlinePlayers()) { + list.add(players.getDisplayName()); + } + return list; + } + + +} diff --git a/src/de/joethei/core/commands/SetRank.java b/src/de/joethei/core/commands/SetRank.java new file mode 100644 index 0000000..4a6b7ef --- /dev/null +++ b/src/de/joethei/core/commands/SetRank.java @@ -0,0 +1,95 @@ +package de.joethei.core.commands; + +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.List; + +import org.bukkit.Bukkit; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +import de.joethei.core.Core; +import de.joethei.core.api.AutoCommand; +import de.joethei.core.api.Messages; +import de.joethei.core.api.CustomPlayer; +import de.joethei.core.api.Perms; +import de.joethei.core.api.Perms.Ranks; + +/** + * sets ranks for players + * @author joethei + * @version 1.0 + */ +public class SetRank extends AutoCommand{ + + /** + * @param plugin main class + * @param command command to execute + * @param description describes the command + * @param aliases aliases of command + */ + public SetRank(Core plugin, String command, String description, String[] aliases) { + super(plugin, command, description, aliases); + } + + @Override + public boolean execute(CommandSender sender, String label, String[] args) { + if(sender instanceof Player) { + CustomPlayer p = CustomPlayer.getPlayer(sender.getName()); + if(p.isAllowed(Ranks.Admin)) { + if(args.length == 2) { + Ranks rank = Ranks.valueOf(args[1]); + if(Bukkit.getPlayer(args[0]) != null) { + CustomPlayer player = CustomPlayer.getPlayer(Bukkit.getPlayer(args[0]).getName()); + if(rank != null) { + try { + Perms.setRank(player, rank); + p.sendMessage("§aDer Rang wurde erfolgreich gesetzt"); + } catch (ClassNotFoundException | SQLException e) { + e.printStackTrace(); + p.sendMessage(Messages.readString("Messages.UnknownError")); + } + }else { + p.sendMessage("§cDen Rang gibt es nicht"); + } + }else { + String msg = Messages.readString("Messages.Player.NotOnline"); + msg = msg.replace("$player", args[0]); + p.sendMessage(msg); + } + }else { + p.sendMessage("§cNutze §6/setRank "); + } + }else { + p.sendMessage(Messages.NO_PERMS); + } + }else { + sender.sendMessage(Messages.NOT_A_PLAYER); + } + return true; + } + + @Override + public List tabComplete(CommandSender sender, String label, String[] args) { + List list = new ArrayList(); + + for(Player players : Bukkit.getOnlinePlayers()) { + list.add(players.getDisplayName()); + } + + list.add("Admin"); + list.add("Developer"); + list.add("HeadBuild"); + list.add("Builder"); + list.add("Moderator"); + list.add("Supporter"); + list.add("Youtuber"); + list.add("Premium"); + list.add("Spieler"); + + return list; + } + + + +} \ No newline at end of file diff --git a/src/de/joethei/core/commands/SystemInfo.java b/src/de/joethei/core/commands/SystemInfo.java new file mode 100644 index 0000000..4085e09 --- /dev/null +++ b/src/de/joethei/core/commands/SystemInfo.java @@ -0,0 +1,61 @@ +package de.joethei.core.commands; + +import java.util.List; + +import org.bukkit.Bukkit; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +import de.joethei.core.Core; +import de.joethei.core.api.AutoCommand; +import de.joethei.core.api.Messages; +import de.joethei.core.api.CustomPlayer; +import de.joethei.core.api.Perms.Ranks; + +/** + * prints infos about the server + * @author joethei + * @version 1.0 + */ +public class SystemInfo extends AutoCommand{ + + /** + * @param plugin main class + * @param command command to execute + * @param description describes the command + * @param aliases aliases of command + */ + public SystemInfo(Core plugin, String command, String description, String[] aliases) { + super(plugin, command, description, aliases); + } + + @Override + public boolean execute(CommandSender sender, String label, String[] args) { + if(sender instanceof Player) { + CustomPlayer p = CustomPlayer.getPlayer(sender.getName()); + if(p.isAllowed(Ranks.Admin)) { + Runtime run = Runtime.getRuntime(); + p.sendMessage("§6§l===SystemInfo ==="); + p.sendMessage("§6Spigot Version: " + Bukkit.getVersion()); + p.sendMessage("§6Genutzter Arbeitsspeicher: " + (run.totalMemory() - run.freeMemory() / 1048576L) + " MB"); + p.sendMessage("§6Freier Arbeitsspeicher: " + run.freeMemory() / 1048576L + " MB"); + p.sendMessage("§6Gesamter Arbeitsspeicher: " + run.maxMemory() / 1048576L + " MB"); + p.sendMessage("§6Verfügbare Prozessoren: " + run.availableProcessors()); + p.sendMessage("§6Betriebssystem: " + System.getProperty("os.name")); + p.sendMessage("§6Betriebsystem Version: " + System.getProperty("os.version")); + p.sendMessage("§6Betriebssystem Architektur: " + System.getProperty("os.arch")); + }else { + p.sendMessage(Messages.NO_PERMS); + } + }else { + sender.sendMessage(Messages.NOT_A_PLAYER); + } + return false; + } + + @Override + public List tabComplete(CommandSender sender, String label, String[] args) { + return null; + } + +} \ No newline at end of file diff --git a/src/de/joethei/core/commands/Twitch.java b/src/de/joethei/core/commands/Twitch.java new file mode 100644 index 0000000..73cb947 --- /dev/null +++ b/src/de/joethei/core/commands/Twitch.java @@ -0,0 +1,65 @@ +package de.joethei.core.commands; + +import java.util.List; + +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +import de.joethei.core.Core; +import de.joethei.core.api.AutoCommand; +import de.joethei.core.api.CustomPlayer; +import de.joethei.core.api.Messages; +import de.joethei.core.api.twitch.Twitch_API; +import de.joethei.core.api.twitch.Twitch_Stream; + +/** + * send info about twitch streams + * @author joethei + * @version 1.0 + */ +public class Twitch extends AutoCommand{ + + /** + * @param plugin main class + * @param command command to execute + * @param description describes the command + * @param aliases aliases of command + */ + public Twitch(Core plugin, String command, String description, String[] aliases) { + super(plugin, command, description, aliases); + } + + @Override + public boolean execute(CommandSender sender, String label, String[] args) { + if(sender instanceof Player) { + CustomPlayer p = CustomPlayer.getPlayer(sender.getName()); + if(args.length == 1) { + Twitch_Stream stream = Twitch_API.getStream(args[0]); + if(stream != null) { + p.sendMessage("§a" + stream.getBroadcaster()); + p.sendMessage("§aBenutzername: " + stream.getUsername()); + p.sendMessage("§aSpiel: " + stream.getMeta_game()); + p.sendMessage("§aKategorie: " + stream.getCategory()); + p.sendMessage("§aTitel: " + stream.getTitle()); + p.sendMessage("§aStatus: " + stream.getStatus()); + p.sendMessage("§aZuschauer:" + stream.getChannel_view_count()); + p.sendMessage("§aSprachen: " + stream.getGeo()); + p.sendMessage("§aOnline seit: " + stream.getUp_time()); + }else { + p.sendMessage(Messages.PREFIX + "§aDen Benutzer gibt es nicht"); + } + }else { + p.sendMessage(Messages.PREFIX + "§cNutze /twitch "); + } + }else { + sender.sendMessage(Messages.NOT_A_PLAYER); + } + return true; + } + + @Override + public List tabComplete(CommandSender sender, String label, String[] args) { + return null; + } + +} \ No newline at end of file diff --git a/src/de/joethei/core/commands/Vanish.java b/src/de/joethei/core/commands/Vanish.java new file mode 100644 index 0000000..817fa1a --- /dev/null +++ b/src/de/joethei/core/commands/Vanish.java @@ -0,0 +1,77 @@ +package de.joethei.core.commands; + +import java.util.ArrayList; +import java.util.List; + +import org.bukkit.Bukkit; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +import de.joethei.core.Core; +import de.joethei.core.api.AutoCommand; +import de.joethei.core.api.Messages; +import de.joethei.core.api.CustomPlayer; +import de.joethei.core.api.Perms.Ranks; + +/** + * vanish players + * @author joethei + * @version 1.0 + */ +public class Vanish extends AutoCommand{ + + /** + * contains vanished players + */ + private static ArrayList players = new ArrayList(); + /** + * @return vanished players + */ + public static ArrayList getPlayers() { + return players; + } + + /** + * @param plugin main class + * @param command command to execute + * @param description describes the command + * @param aliases aliases of command + */ + public Vanish(Core plugin, String command, String description, String[] aliases) { + super(plugin, command, description, aliases); + } + + @Override + public boolean execute(CommandSender sender, String label, String[] args) { + if(sender instanceof Player) { + CustomPlayer p = CustomPlayer.getPlayer(sender.getName()); + if(p.isAllowed(Ranks.Moderator)) { + if(players.contains(p)) { + for(Player players : Bukkit.getOnlinePlayers()) { + players.showPlayer(p); + } + players.remove(p); + p.sendMessage("§cDu bist nun wieder sichtbar"); + }else { + for(Player players : Bukkit.getOnlinePlayers()) { + players.hidePlayer(p); + } + players.add(p); + p.sendMessage("Du bist nun unsichtbar"); + } + }else { + p.sendMessage(Messages.NO_PERMS); + } + }else { + sender.sendMessage(Messages.NOT_A_PLAYER); + } + return false; + } + + @Override + public List tabComplete(CommandSender sender, String label, String[] args) { + return null; + } + + +} \ No newline at end of file diff --git a/src/de/joethei/core/commands/Youtuber.java b/src/de/joethei/core/commands/Youtuber.java new file mode 100644 index 0000000..c003175 --- /dev/null +++ b/src/de/joethei/core/commands/Youtuber.java @@ -0,0 +1,63 @@ +package de.joethei.core.commands; + +import java.util.List; + +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +import de.joethei.core.Core; +import de.joethei.core.api.AutoCommand; +import de.joethei.core.api.CustomPlayer; +import de.joethei.core.api.Messages; +import de.joethei.core.api.youtube.YTAPI; +import de.joethei.core.api.youtube.YoutubeChannel; + +/** + * sets player to youtube rank + * @author joethei + * @version 1.0 + */ +public class Youtuber extends AutoCommand{ + + /** + * @param plugin main class + * @param command command to execute + * @param description describes the command + * @param aliases aliases of command + */ + public Youtuber(Core plugin, String command, String description, String[] aliases) { + super(plugin, command, description, aliases); + } + + @Override + public boolean execute(CommandSender sender, String label, String[] args) { + if(sender instanceof Player) { + CustomPlayer p = CustomPlayer.getPlayer(sender.getName()); + if(args.length == 1) { + YoutubeChannel yt = YTAPI.getYTChannelFromName(args[0]); + if(yt != null) { + p.sendMessage("§aBenutzername: " + yt.getUsername()); + p.sendMessage("§aGooglePlus ID: " + yt.getGoogleplusid()); + p.sendMessage("§aZuletzt online: " + yt.getLastwebaccess()); + p.sendMessage("§aVon: " + yt.getLocation()); + p.sendMessage("§aAbos: " + yt.getSubscribers()); + p.sendMessage("§aVideo Watch Count: " + yt.getVideoWatchCount()); + p.sendMessage("§aViewcount: " + yt.getViewcount()); + }else { + p.sendMessage(Messages.PREFIX + "§cDer Youtube Kanal exsistiert nicht"); + } + }else { + p.sendMessage(Messages.PREFIX + "§cBenutze doch /youtuber "); + } + }else { + sender.sendMessage(Messages.NOT_A_PLAYER); + } + return true; + } + + @Override + public List tabComplete(CommandSender sender, String label, String[] args) { + return null; + } + +} \ No newline at end of file diff --git a/src/de/joethei/core/listeners/Blocks.java b/src/de/joethei/core/listeners/Blocks.java new file mode 100644 index 0000000..336303b --- /dev/null +++ b/src/de/joethei/core/listeners/Blocks.java @@ -0,0 +1,46 @@ +package de.joethei.core.listeners; + +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.block.BlockBreakEvent; +import org.bukkit.event.block.BlockPlaceEvent; + +import de.joethei.core.api.CustomPlayer; +import de.joethei.core.api.Settings; +import de.joethei.core.commands.Build; + +/** + * cancels building + * @author joethei + * @version 1.0 + */ +public class Blocks implements Listener{ + + /** + * @param e BlockPlaceEvent + */ + @EventHandler + public void onBlockPlace(BlockPlaceEvent e) { + CustomPlayer p = CustomPlayer.getPlayer(e.getPlayer().getName()); + if(Settings.isBuild()) { + if(!Build.getPlayers().contains(p)) { + e.setCancelled(true); + } + } + } + + /** + * @param e BlockBreakEvent + */ + @EventHandler + public void onBlockBreak(BlockBreakEvent e) { + CustomPlayer p = CustomPlayer.getPlayer(e.getPlayer().getName()); + if(Settings.isBuild()) { + if(!Build.getPlayers().contains(p)) { + e.setCancelled(true); + } + } + + } + +} \ No newline at end of file diff --git a/src/de/joethei/core/listeners/Chat.java b/src/de/joethei/core/listeners/Chat.java new file mode 100644 index 0000000..5087b03 --- /dev/null +++ b/src/de/joethei/core/listeners/Chat.java @@ -0,0 +1,38 @@ +package de.joethei.core.listeners; + +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.AsyncPlayerChatEvent; + +import de.joethei.core.api.CustomPlayer; +import de.joethei.core.api.Settings; +import de.joethei.core.api.Perms.Ranks; + +/** + * manages chat + * @author joethei + * @version 1.0 + */ +public class Chat implements Listener{ + + /** + * @param e AsyncPlayerChatEvent + */ + @EventHandler + public void onChat(AsyncPlayerChatEvent e) { + CustomPlayer p = CustomPlayer.getPlayer(e.getPlayer().getName()); + if(Settings.isMute()) { + if(!p.isAllowed(Ranks.Supporter)) { + e.setCancelled(true); + p.sendMessage("§cMomentan ist dieser Server gemutet"); + } + } + if(!p.isMuted()) { + String msg = p.getPrefix() + p.getDisplayName() + p.getSuffix() + e.getMessage(); + e.setFormat(msg); + }else { + p.sendMessage("§cDu wurdest leider vom Chat ausgeschlossen"); + } + } + +} \ No newline at end of file diff --git a/src/de/joethei/core/listeners/Commands.java b/src/de/joethei/core/listeners/Commands.java new file mode 100644 index 0000000..0c91510 --- /dev/null +++ b/src/de/joethei/core/listeners/Commands.java @@ -0,0 +1,72 @@ +package de.joethei.core.listeners; + +import org.bukkit.Bukkit; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.EventPriority; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerCommandPreprocessEvent; +import org.bukkit.help.HelpTopic; + +import de.joethei.core.Core; +import de.joethei.core.api.Messages; +import de.joethei.core.api.CustomPlayer; +import de.joethei.core.api.Perms.Ranks; + +/** + * commands + * @author joethei + * @version 1.0 + */ +public class Commands implements Listener{ + + + /** + * prints unknown command message + * @param e PlayerCommandPreprocessEvent + */ + @EventHandler(priority = EventPriority.NORMAL) + public void onPlayerPreprocess(PlayerCommandPreprocessEvent e) { + if(!(e.isCancelled())) { + CustomPlayer p = CustomPlayer.getPlayer(e.getPlayer().getName()); + String cmd = e.getMessage().split(" ")[0]; + HelpTopic topic = Bukkit.getServer().getHelpMap().getHelpTopic(cmd); + if(topic == null) { + String msg = Messages.readString("Commands.Unknown"); + msg = msg.replace("$cmd", cmd); + p.sendMessage(msg); + e.setCancelled(true); + } + } + } + + /** + * custom reload + * @param e PlayerPreprocessEvent + */ + @EventHandler + public void onReload(PlayerCommandPreprocessEvent e) { + CustomPlayer p = CustomPlayer.getPlayer(e.getPlayer().getName()); + String cmd = e.getMessage(); + if(cmd.equalsIgnoreCase("/rl") || cmd.equalsIgnoreCase("/reload")) { + if(p.isAllowed(Ranks.Admin)) { + e.setCancelled(true); + Bukkit.broadcastMessage("§cAchtung der Server wird gleich neu geladen"); + Bukkit.getScheduler().scheduleSyncDelayedTask(Core.getInstance(), new Runnable() { + + @Override + public void run() { + for(Player players : Bukkit.getOnlinePlayers()) { + players.kickPlayer("§cServer wurde neu geladen \n §6Bitte joine doch neu unter \n §bplay§5.§6univento§5.§aeu"); + } + Bukkit.reload(); + } + + }, 100L); + }else { + p.sendMessage(Messages.NO_PERMS); + } + } + } + +} \ No newline at end of file diff --git a/src/de/joethei/core/listeners/JoinQuit.java b/src/de/joethei/core/listeners/JoinQuit.java new file mode 100644 index 0000000..1acefa8 --- /dev/null +++ b/src/de/joethei/core/listeners/JoinQuit.java @@ -0,0 +1,124 @@ +package de.joethei.core.listeners; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Timestamp; +import java.util.Date; + +import org.bukkit.Bukkit; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.EventPriority; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerJoinEvent; +import org.bukkit.event.player.PlayerKickEvent; +import org.bukkit.event.player.PlayerQuitEvent; + +import de.joethei.core.Core; +import de.joethei.core.api.CustomPlayer; +import de.joethei.core.api.MySQL; +import de.joethei.core.api.NickName; +import de.joethei.core.api.Perms; +import de.joethei.core.api.Perms.Ranks; +import de.joethei.core.commands.Vanish; + +/** + * @author joethei + * @version 1.0 + */ +public class JoinQuit implements Listener{ + + /** + * Handles JoinMessage and vanished players + * @param e event + */ + @EventHandler + public void onJoin(PlayerJoinEvent e) { + CustomPlayer p = CustomPlayer.getPlayer(e.getPlayer().getName()); + e.setJoinMessage(null); + createPlayer(p); + Perms.getRanks().put(p, p.getRankFresh()); + try { + setup(p, p.getRank()); + } catch (SQLException e1) { + e1.printStackTrace(); + } + for(Player players : Bukkit.getOnlinePlayers()) { + if(Vanish.getPlayers().contains(players)) { + p.hidePlayer(players); + } + } + if(p.isNicked()) { + p.setDisplayName(p.getNick()); + } + + } + + /** + * Handles QuitMessage and other needed stuff + * @param e event + */ + @EventHandler + public void onQuit(PlayerQuitEvent e) { + CustomPlayer p = CustomPlayer.getPlayer(e.getPlayer().getName()); + NickName.remove(p); + Perms.getRanks().remove(p); + p.onLeave(); + e.setQuitMessage(null); + } + + /** + * creates player in database + * @param p CustomPlayer + */ + private static void createPlayer(CustomPlayer p) { + Date date = new Date(); + Timestamp time = new Timestamp(date.getTime()); + String uuid = p.getUniqueId().toString(); + try { + MySQL sql = Core.returnSQL(); + sql.openConnection(); + ResultSet res = Core.returnSQL().getConnection().createStatement().executeQuery("SELECT player_uuid FROM PlayerData WHERE player_uuid ='" + uuid + "';"); + if (!res.next()) + Core.returnSQL().getConnection().createStatement().execute("INSERT INTO PlayerData (player_uuid, FirstJoin, Coins, mute, Rank, nick, FastMenu, teleport) VALUES ('" + uuid + "','" + time + "', '0', '0', '" + Perms.Ranks.Spieler.toString() + "', '0', '0', '1');"); + sql.closeConnection(); + } + catch (SQLException | ClassNotFoundException e) { + e.printStackTrace(); + } + } + + /** + * sets up the player + * @param p CustomPlayer + * @param r Ranks + * @throws SQLException Database not available + */ + private void setup(CustomPlayer p, Ranks r) throws SQLException { + if (p.isNicked()) { + Core.nicks.put(p, NickName.getNicks()); + setName(p, Core.nicks.get(p)); + } else { + setName(p, p.getName()); + } + } + + /** + * sets DisplayName of Player + * @param p CustomPlayer + * @param name name to set + */ + private void setName(CustomPlayer p, String name) { + p.setDisplayName(name); + p.setPlayerListName(p.getColor() + name); + } + /** + * Handles KickMessage + * @param e event + */ + @EventHandler(priority=EventPriority.HIGHEST) + public void onKick(PlayerKickEvent e) { + e.setLeaveMessage(null); + NickName.remove(e.getPlayer()); + } +} \ No newline at end of file diff --git a/src/plugin.yml b/src/plugin.yml new file mode 100644 index 0000000..0d59c8f --- /dev/null +++ b/src/plugin.yml @@ -0,0 +1,6 @@ +main: de.joethei.core.Core +name: Core +description: univento Core +author: joethei +version: 0.1 +website: http://univento.eu \ No newline at end of file