773 lines
24 KiB
Java
773 lines
24 KiB
Java
package eu.univento.core.api.player;
|
|
|
|
import com.mongodb.BasicDBObject;
|
|
import com.mongodb.CursorType;
|
|
import com.mongodb.client.FindIterable;
|
|
import com.mongodb.client.MongoCollection;
|
|
import eu.univento.core.Core;
|
|
import eu.univento.core.api.Actionbar;
|
|
import eu.univento.core.api.Utils;
|
|
import eu.univento.core.api.database.MongoDB;
|
|
import eu.univento.core.api.effects.Effects;
|
|
import eu.univento.core.api.languages.Messages;
|
|
import eu.univento.core.api.server.Game;
|
|
import eu.univento.core.api.server.Servers;
|
|
import io.netty.buffer.ByteBuf;
|
|
import io.netty.buffer.Unpooled;
|
|
import net.minecraft.server.v1_9_R1.EnumParticle;
|
|
import net.minecraft.server.v1_9_R1.PacketDataSerializer;
|
|
import net.minecraft.server.v1_9_R1.PacketPlayOutCustomPayload;
|
|
import org.bson.Document;
|
|
import org.bukkit.Bukkit;
|
|
import org.bukkit.Color;
|
|
import org.bukkit.Location;
|
|
import org.bukkit.Sound;
|
|
import org.bukkit.attribute.Attribute;
|
|
import org.bukkit.attribute.AttributeInstance;
|
|
import org.bukkit.attribute.AttributeModifier;
|
|
import org.bukkit.craftbukkit.v1_9_R1.CraftServer;
|
|
import org.bukkit.craftbukkit.v1_9_R1.entity.CraftPlayer;
|
|
import org.bukkit.entity.Player;
|
|
import org.bukkit.scoreboard.Scoreboard;
|
|
import org.bukkit.scoreboard.Team;
|
|
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.IOException;
|
|
import java.io.ObjectOutputStream;
|
|
import java.util.*;
|
|
|
|
public class CustomPlayer extends CraftPlayer {
|
|
|
|
|
|
private static final HashMap<String, CustomPlayer> PLAYERS = new HashMap<>();
|
|
private final Player PLAYER;
|
|
private String customPrefix;
|
|
private String customSuffix;
|
|
private String customColor;
|
|
|
|
|
|
private boolean openInventory;
|
|
|
|
private MongoDB mongoDB = Core.getMongoDB();
|
|
private MongoCollection userCollection;
|
|
private MongoCollection friendCollection;
|
|
|
|
private CustomPlayer(Player player) {
|
|
super((CraftServer) Bukkit.getServer(), ((CraftPlayer) player).getHandle());
|
|
PLAYERS.put(player.getName().toLowerCase(), this);
|
|
PLAYER = player;
|
|
userCollection = mongoDB.getDatabase().getCollection("users");
|
|
friendCollection = mongoDB.getDatabase().getCollection("friends");
|
|
}
|
|
|
|
public void onLeave() {
|
|
Date date = new Date();
|
|
setInDatabase("lastOnline", date);
|
|
|
|
HashMap<String, Object> location = new HashMap<>();
|
|
location.put("X", getLocation().getX());
|
|
location.put("Y", getLocation().getY());
|
|
location.put("Z", getLocation().getZ());
|
|
location.put("Yaw", getLocation().getYaw());
|
|
location.put("Pitch", getLocation().getPitch());
|
|
|
|
if(Bukkit.getServerName().contains("Lobby")) setInDatabase("Pos", new BasicDBObject(location));
|
|
|
|
if (PLAYERS.containsKey(getName().toLowerCase())) PLAYERS.remove(getName().toLowerCase());
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
|
|
public static CustomPlayer getPlayer(Player player) {
|
|
return getPlayer(player.getName());
|
|
}
|
|
|
|
|
|
public Player getPLAYER() {
|
|
return PLAYER;
|
|
}
|
|
|
|
public void insertToDatabase() {
|
|
Document doc = new Document("uuid", getUniqueId());
|
|
Date date = new Date();
|
|
|
|
doc.put("rank", "Player");
|
|
doc.put("firstLogin", date);
|
|
doc.put("lastLogin", date);
|
|
doc.put("lastOnline", date);
|
|
doc.put("lastIP", getAddress().getHostName());
|
|
doc.put("tsid", 0);
|
|
doc.put("timesJoined", 1);
|
|
doc.put("coins", 0);
|
|
doc.put("experience", 0);
|
|
doc.put("foundSecrets", new ArrayList<String>());
|
|
doc.put("foundEggs", new ArrayList<String>());
|
|
|
|
HashMap<String, Object> settings = new HashMap<>();
|
|
settings.put("playerVisibility", "all");
|
|
settings.put("inventoryAnimation", true);
|
|
settings.put("teleportAnimation", true);
|
|
settings.put("partyRequests", true);
|
|
settings.put("friendRequests", true);
|
|
settings.put("friendJump", true);
|
|
settings.put("chatSounds", true);
|
|
settings.put("effects", true);
|
|
settings.put("storyMode", true);
|
|
settings.put("language", "EN");
|
|
|
|
doc.put("Settings", new BasicDBObject(settings));
|
|
|
|
HashMap<String, Object> location = new HashMap<>();
|
|
location.put("X", getLocation().getX());
|
|
location.put("Y", getLocation().getY());
|
|
location.put("Z", getLocation().getZ());
|
|
location.put("Yaw", getLocation().getYaw());
|
|
location.put("Pitch", getLocation().getPitch());
|
|
|
|
doc.put("Pos", new BasicDBObject(location));
|
|
userCollection.insertOne(doc);
|
|
}
|
|
|
|
@Override
|
|
public boolean hasPlayedBefore() {
|
|
FindIterable cursor = userCollection.find(new Document("uuid", getUniqueId()));
|
|
cursor.cursorType(CursorType.NonTailable);
|
|
|
|
Object obj = cursor.first();
|
|
if (obj == null)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
public void updateDatabaseEntry() {
|
|
setInDatabase("lastLogin", new Date());
|
|
setInDatabase("lastIP", getAddress().getHostName());
|
|
setInDatabase("timesJoined", getTimesJoined() + 1);
|
|
}
|
|
|
|
public void setRank(Ranks rank) {
|
|
setInDatabase("rank", rank.toString());
|
|
}
|
|
|
|
public void setTSID(int id) {
|
|
setInDatabase("tsid", id);
|
|
}
|
|
|
|
public void setCoins(int coins) {
|
|
setInDatabase("coins", coins);
|
|
}
|
|
|
|
public void setExperience(int experience) {
|
|
setInDatabase("experience", experience);
|
|
}
|
|
|
|
private void setFoundSecrets(ArrayList<String> secrets) {
|
|
setInDatabase("foundSecrets", secrets);
|
|
}
|
|
|
|
public void addSecret(String name) {
|
|
ArrayList<String> list = getFoundSecrets();
|
|
list.add(name);
|
|
setFoundSecrets(list);
|
|
}
|
|
|
|
private void setFoundEggs(ArrayList<String> eggs) {
|
|
setInDatabase("foundEggs", eggs);
|
|
}
|
|
|
|
public void addEgg(String name) {
|
|
ArrayList<String> list = getFoundEggs();
|
|
list.add(name);
|
|
setFoundEggs(list);
|
|
}
|
|
|
|
private void setSettings(Map<String, Object> settings) {
|
|
setInDatabase("Settings", settings);
|
|
}
|
|
|
|
private void setSetting(String name, Object setting) {
|
|
Map<String, Object> list = getSettings();
|
|
list.put(name, setting);
|
|
setSettings(list);
|
|
}
|
|
|
|
public Ranks getRank() {
|
|
return Ranks.valueOf(getStringFromDatabase("rank"));
|
|
}
|
|
|
|
public Date getFirstLogin() {
|
|
return getDateFromDatabase("firstLogin");
|
|
}
|
|
|
|
public Date getLastLogin() {
|
|
return getDateFromDatabase("lastLogin");
|
|
}
|
|
|
|
public Date getLastOnline() {
|
|
return getDateFromDatabase("lastOnline");
|
|
}
|
|
|
|
public String getLastIP() {
|
|
return getStringFromDatabase("lastIP");
|
|
}
|
|
|
|
public int getTSID() {
|
|
return getIntegerFromDatabase("tsid");
|
|
}
|
|
|
|
private int getTimesJoined() {
|
|
return getIntegerFromDatabase("timesJoined");
|
|
}
|
|
|
|
public int getCoins() {
|
|
return getIntegerFromDatabase("coins");
|
|
}
|
|
|
|
public int getExperience() {
|
|
return getIntegerFromDatabase("experience");
|
|
}
|
|
|
|
public int getSecrets() { return getFoundSecrets().size();}
|
|
|
|
public ArrayList<String> getFoundSecrets() {
|
|
return getArrayListFromDatabase("foundSecrets");
|
|
}
|
|
|
|
public int getEggs() { return getFoundEggs().size();}
|
|
|
|
private ArrayList<String> getFoundEggs() {
|
|
return getArrayListFromDatabase("foundEggs");
|
|
}
|
|
|
|
private Map<String, Object> getSettings() {
|
|
return getMapFromDatabase("Settings");
|
|
}
|
|
|
|
public Location getLastLocation() {
|
|
Map<String, Object> map = getMapFromDatabase("Pos");
|
|
return new Location(Bukkit.getWorld("world"), (double)map.get("X"), (double)map.get("Y"), (double)map.get("Z"), (float)map.get("Yaw"), (float)map.get("Pitch"));
|
|
}
|
|
|
|
public String getPlayerVisibility() {
|
|
return (String) getSettings().get("playerVisibility");
|
|
}
|
|
|
|
public boolean hasInventoryAnimation() {
|
|
return (boolean) getSettings().get("inventoryAnimation");
|
|
}
|
|
|
|
public boolean hasTeleportAnimation() {
|
|
return (boolean) getSettings().get("teleportAnimation");
|
|
}
|
|
|
|
public boolean hasPartyRequests() {
|
|
return (boolean) getSettings().get("partyRequests");
|
|
}
|
|
|
|
public boolean hasFriendRequests() {
|
|
return (boolean) getSettings().get("friendRequests");
|
|
}
|
|
|
|
public boolean hasFriendJump() {
|
|
return (boolean) getSettings().get("friendJump");
|
|
}
|
|
|
|
public boolean hasChatSounds() {
|
|
return (boolean) getSettings().get("chatSounds");
|
|
}
|
|
|
|
public boolean hasEffects() {
|
|
return (boolean) getSettings().get("effects");
|
|
}
|
|
|
|
public boolean hasStoryMode() {
|
|
return (boolean) getSettings().get("storyMode");
|
|
}
|
|
|
|
public String getLanguage() {
|
|
return (String) getSettings().get("language");
|
|
}
|
|
|
|
public void setPlayerVisibility(String visibility) {
|
|
setSetting("playerVisibility", visibility);
|
|
}
|
|
|
|
public void setInventoryAnimation(boolean animation) {
|
|
setSetting("inventoryAnimation", animation);
|
|
}
|
|
|
|
public void setTeleportAnimation(boolean animation) {
|
|
setSetting("teleportAnimation", animation);
|
|
}
|
|
|
|
public void setPartyRequests(boolean requests) {
|
|
setSetting("partyRequests", requests);
|
|
}
|
|
|
|
public void setFriendRequests(boolean requests) {
|
|
setSetting("friendRequests", requests);
|
|
}
|
|
|
|
public void setFriendJump(boolean jump) {
|
|
setSetting("friendJump", jump);
|
|
}
|
|
|
|
public void setChatSounds(boolean sounds) {
|
|
setSetting("chatSounds", sounds);
|
|
}
|
|
|
|
public void setEffects(boolean effects) {
|
|
setSetting("effects", effects);
|
|
}
|
|
|
|
public void setStoryMode(boolean storyMode) {
|
|
setSetting("storyMode", storyMode);
|
|
}
|
|
|
|
public void setLanguage(String language) {
|
|
setSetting("language", language);
|
|
}
|
|
|
|
public boolean isJoined() {
|
|
return true;
|
|
}
|
|
|
|
public void connectToServer(String server) {
|
|
Servers.connectServer(PLAYER, server);
|
|
}
|
|
|
|
public boolean isAllowed(Ranks rank) {
|
|
return getRank().value >= rank.value;
|
|
}
|
|
|
|
public ArrayList<UUID> getFriends() {
|
|
FindIterable<Document> cursor = friendCollection.find(new Document("uuid", getUniqueId()));
|
|
cursor.cursorType(CursorType.NonTailable);
|
|
|
|
Document doc = cursor.first();
|
|
if (doc == null) return null;
|
|
|
|
return (ArrayList<UUID>) doc.get("friends");
|
|
}
|
|
|
|
private void setFriends(ArrayList<UUID> friends) {
|
|
friendCollection.updateOne(new Document("uuid", getUniqueId()), new Document("$set", new Document("friends", friends)));
|
|
}
|
|
|
|
public boolean isFriend(UUID uuid) {
|
|
return getFriends().contains(uuid);
|
|
}
|
|
|
|
public void addFriend(UUID uuid) {
|
|
ArrayList<UUID> list = getFriends();
|
|
list.add(uuid);
|
|
setFriends(list);
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
public boolean isAllowed(Ranks.Ranks rank) {
|
|
try {
|
|
return Ranks.isAllowed(this, rank);
|
|
} catch (ClassNotFoundException | SQLException e) {
|
|
e.printStackTrace();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
|
|
public Ranks.Ranks getRank() {
|
|
try {
|
|
return Ranks.getRank(this);
|
|
} catch (ClassNotFoundException | SQLException e) {
|
|
e.printStackTrace();
|
|
return Ranks.Ranks.Player;
|
|
}
|
|
}
|
|
|
|
public Ranks.Ranks getFreshRank() {
|
|
try{
|
|
return Ranks.getRankFresh(this);
|
|
}catch (ClassNotFoundException | SQLException e) {
|
|
e.printStackTrace();
|
|
return Ranks.Ranks.Player;
|
|
}
|
|
}
|
|
|
|
public void setRank(Ranks.Ranks r) {
|
|
try {
|
|
Ranks.setRank(this, r);
|
|
} catch (ClassNotFoundException e) {
|
|
e.printStackTrace();
|
|
} catch (SQLException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
*/
|
|
public String getPrefix() {
|
|
if(customPrefix != null) return customPrefix;
|
|
if(isNicked()) return getPrefix(Ranks.Premium);
|
|
return getPrefix(getRank());
|
|
}
|
|
|
|
public String getSuffix() {
|
|
if(customSuffix != null) return customSuffix;
|
|
if(isNicked()) return getSuffix(Ranks.Premium);
|
|
return getSuffix(getRank());
|
|
}
|
|
|
|
public String getColor() {
|
|
if(customColor != null) return customColor;
|
|
if(isNicked()) return getColor(Ranks.Premium);
|
|
return getColor(getRank());
|
|
}
|
|
|
|
public Team getTeam() {
|
|
if(isNicked()) return getTeam(Ranks.Premium);
|
|
return getTeam(getRank());
|
|
}
|
|
|
|
//TODO: add function
|
|
public boolean isNicked() {
|
|
return false;
|
|
}
|
|
|
|
public boolean isNickedReal() {
|
|
return false;
|
|
}
|
|
|
|
public void setNicked(boolean nick) {
|
|
|
|
}
|
|
|
|
public Color getArmorColor() {
|
|
return getArmorColor(getRank());
|
|
}
|
|
|
|
public void setCustomPrefix(String prefix) {
|
|
customPrefix = prefix;
|
|
}
|
|
|
|
public void setCustomSuffix(String suffix) {
|
|
customSuffix = suffix;
|
|
}
|
|
|
|
public void setCustomColor(String color) {
|
|
customColor = color;
|
|
}
|
|
|
|
public boolean hasEmptyInventory() {
|
|
return Utils.hasEmptyInventory(PLAYER);
|
|
}
|
|
|
|
public void clearPotionEffects() {
|
|
Utils.clearPotionEffects(PLAYER);
|
|
}
|
|
|
|
public boolean hasOpenInventory() {
|
|
return openInventory;
|
|
}
|
|
|
|
|
|
public void setOpenInventory(boolean openInventory) {
|
|
this.openInventory = openInventory;
|
|
}
|
|
|
|
public void addCoins(int coins) {
|
|
setCoins(getCoins() + coins);
|
|
}
|
|
|
|
public void substractCoins(int coins) {
|
|
setCoins(getCoins() - coins);
|
|
}
|
|
|
|
|
|
public void sendActionBar(String text) {
|
|
Actionbar.send(PLAYER, text);
|
|
}
|
|
|
|
public void addExperience(int experience) {
|
|
setExperience(getExperience() + experience);
|
|
setExp(0F);
|
|
giveExp(getExperience());
|
|
playSound(getLocation(), Sound.ENTITY_PLAYER_LEVELUP, 1.0F, 1.0F);
|
|
}
|
|
|
|
public void substractExperience(int experience) {
|
|
setExperience(getExperience() - experience);
|
|
setExp(0F);
|
|
giveExp(getExperience());
|
|
}
|
|
|
|
public void refreshExperience() {
|
|
setLevel(0);
|
|
setExp(0F);
|
|
giveExp(getExperience());
|
|
}
|
|
|
|
public void playParticle(Location loc, EnumParticle ep, float f, int count) {
|
|
if(hasEffects()) Effects.playEffectToPlayer(PLAYER, loc, ep, f, count);
|
|
}
|
|
|
|
public void setAttackSpeed(double speed) {
|
|
AttributeModifier modifier = new AttributeModifier("Core", speed, AttributeModifier.Operation.ADD_NUMBER);
|
|
getAttribute(Attribute.GENERIC_ATTACK_SPEED).addModifier(modifier);
|
|
}
|
|
|
|
public double getAttackSpeed() {
|
|
return getAttribute(Attribute.GENERIC_ATTACK_SPEED).getValue();
|
|
}
|
|
|
|
public void resetAttackSpeed() {
|
|
AttributeModifier modifier = new AttributeModifier("Core", getAttackSpeed(), AttributeModifier.Operation.ADD_NUMBER);
|
|
getAttribute(Attribute.GENERIC_ATTACK_SPEED).removeModifier(modifier);
|
|
AttributeInstance instance = getAttribute(Attribute.GENERIC_ATTACK_SPEED);
|
|
instance.setBaseValue(16.0D);
|
|
}
|
|
|
|
public Messages getMessages() {
|
|
return new Messages(this);
|
|
}
|
|
|
|
public Statistics getStatistics(Game game) {
|
|
return new Statistics(this, game);
|
|
}
|
|
|
|
private void setInDatabase(String name, Object obj) {
|
|
userCollection.updateOne(new Document("uuid", getUniqueId()), new Document("$set", new Document(name, obj)));
|
|
}
|
|
|
|
private Object getObjectFromDatbase(String name) {
|
|
FindIterable<Document> cursor = userCollection.find(new Document("uuid", getUniqueId()));
|
|
cursor.cursorType(CursorType.NonTailable);
|
|
|
|
Document doc = cursor.first();
|
|
if (doc == null) return null;
|
|
|
|
return doc.get(name);
|
|
}
|
|
|
|
private int getIntegerFromDatabase(String name) {
|
|
FindIterable<Document> cursor = userCollection.find(new Document("uuid", getUniqueId()));
|
|
cursor.cursorType(CursorType.NonTailable);
|
|
|
|
Document doc = cursor.first();
|
|
if (doc == null) return 0;
|
|
|
|
return doc.getInteger(name);
|
|
}
|
|
|
|
private String getStringFromDatabase(String name) {
|
|
FindIterable<Document> cursor = userCollection.find(new Document("uuid", getUniqueId()));
|
|
cursor.cursorType(CursorType.NonTailable);
|
|
|
|
Document doc = cursor.first();
|
|
if (doc == null) return null;
|
|
|
|
return doc.getString(name);
|
|
}
|
|
|
|
private Date getDateFromDatabase(String name) {
|
|
FindIterable<Document> cursor = userCollection.find(new Document("uuid", getUniqueId()));
|
|
cursor.cursorType(CursorType.NonTailable);
|
|
|
|
Document doc = cursor.first();
|
|
if (doc == null) return null;
|
|
|
|
return doc.getDate(name);
|
|
}
|
|
|
|
private ArrayList<String> getArrayListFromDatabase(String name) {
|
|
return (ArrayList<String>) getObjectFromDatbase(name);
|
|
}
|
|
|
|
private Map<String, Object> getMapFromDatabase(String name) {
|
|
return (Map<String, Object>) getObjectFromDatbase(name);
|
|
}
|
|
|
|
public String getPrefix(Ranks r) {
|
|
switch(r) {
|
|
case Admin: return "§8[§4Admin§8]§4 ";
|
|
case SrDeveloper: return "§8[§3Dev+§8]§3 ";
|
|
case Developer: return "§8[§3Dev§8]§3 ";
|
|
case SrModerator: return "§8[§cSrMod§8]§c ";
|
|
case HeadBuilder: return "§8[§aHead-Builder§8]§a ";
|
|
case Moderator: return "§8[§cMod§8]§c ";
|
|
case Builder: return "§8[§2Builder§8]§2 ";
|
|
case Supporter: return "§8[§9Supporter§8]§9 ";
|
|
case Youtuber: return "§5";
|
|
case Premium: return "§6";
|
|
case Player: return "§e";
|
|
default: return "§cFehler ";
|
|
}
|
|
}
|
|
|
|
public String getSuffix(Ranks r) {
|
|
switch(r) {
|
|
case Admin: return "§8 »§7 ";
|
|
case SrDeveloper: return "§8 »§7";
|
|
case Developer: return "§8 »§7 ";
|
|
case SrModerator: return "§8 »§7 ";
|
|
case HeadBuilder: return "§8 »§7 ";
|
|
case Moderator: return "§8 »§7 ";
|
|
case Builder: return "§8 »§7 ";
|
|
case Supporter: return "§8 »§7 ";
|
|
case Youtuber: return "§8 »§7 ";
|
|
case Premium: return "§8 »§7 ";
|
|
case Player: return "§8 »§7 ";
|
|
default: return "§cFehler";
|
|
}
|
|
}
|
|
|
|
public String getColor(Ranks r) {
|
|
switch(r) {
|
|
case Admin: return "§4";
|
|
case SrDeveloper: return "§3";
|
|
case Developer: return "§3";
|
|
case SrModerator: return "§c";
|
|
case HeadBuilder: return "§a";
|
|
case Moderator: return "§c";
|
|
case Builder: return "§2";
|
|
case Supporter: return "§9";
|
|
case Youtuber: return "§5";
|
|
case Premium: return "§6";
|
|
case Player: return "§e";
|
|
default: return "§cFehler";
|
|
}
|
|
}
|
|
|
|
private Color getArmorColor(Ranks r) {
|
|
switch (r) {
|
|
case Admin: return Color.MAROON;
|
|
case SrDeveloper: return Color.TEAL;
|
|
case Developer: return Color.TEAL;
|
|
case SrModerator: return Color.RED;
|
|
case HeadBuilder: return Color.LIME;
|
|
case Moderator: return Color.RED;
|
|
case Builder: return Color.GREEN;
|
|
case Supporter: return Color.PURPLE;
|
|
default: return null;
|
|
}
|
|
}
|
|
|
|
public Team getTeam(Ranks r) {
|
|
switch (r) {
|
|
case Admin: return Admin;
|
|
case SrDeveloper: return SrDeveloper;
|
|
case Developer: return Developer;
|
|
case SrModerator: return SrModerator;
|
|
case HeadBuilder: return HeadBuilder;
|
|
case Moderator: return Moderator;
|
|
case Builder: return Builder;
|
|
case Supporter: return Supporter;
|
|
case Youtuber: return Youtuber;
|
|
case Premium: return Premium;
|
|
case Player: return Player;
|
|
default: return Player;
|
|
}
|
|
}
|
|
private Scoreboard board = getScoreboard();
|
|
private Team Admin = board.getTeam("a");
|
|
private Team SrDeveloper = board.getTeam("b");
|
|
private Team Developer = board.getTeam("c");
|
|
private Team SrModerator = board.getTeam("d");
|
|
private Team HeadBuilder = board.getTeam("e");
|
|
private Team Moderator = board.getTeam("f");
|
|
private Team Builder = board.getTeam("g");
|
|
private Team Supporter = board.getTeam("h");
|
|
private Team Youtuber = board.getTeam("i");
|
|
private Team Premium = board.getTeam("j");
|
|
private Team Player = board.getTeam("k");
|
|
|
|
public void initScoreboard() {
|
|
Scoreboard board = getScoreboard();
|
|
board.getTeams().forEach(Team::unregister);
|
|
|
|
Team Admin = board.registerNewTeam("a");
|
|
Team SrDeveloper = board.registerNewTeam("b");
|
|
Team Developer = board.registerNewTeam("c");
|
|
Team SrModerator = board.registerNewTeam("d");
|
|
Team HeadBuilder = board.registerNewTeam("e");
|
|
Team Moderator = board.registerNewTeam("f");
|
|
Team Builder = board.registerNewTeam("g");
|
|
Team Supporter = board.registerNewTeam("h");
|
|
Team Youtuber = board.registerNewTeam("i");
|
|
Team Premium = board.registerNewTeam("j");
|
|
Team Player = board.registerNewTeam("k");
|
|
|
|
Admin.setPrefix(getColor(Ranks.Admin));
|
|
SrDeveloper.setPrefix(getColor(Ranks.SrDeveloper));
|
|
Developer.setPrefix(getColor(Ranks.Developer));
|
|
SrModerator.setPrefix(getColor(Ranks.SrModerator));
|
|
HeadBuilder.setPrefix(getColor(Ranks.HeadBuilder));
|
|
Moderator.setPrefix(getColor(Ranks.Moderator));
|
|
Builder.setPrefix(getColor(Ranks.Builder));
|
|
Supporter.setPrefix(getColor(Ranks.Supporter));
|
|
Youtuber.setPrefix(getColor(Ranks.Youtuber));
|
|
Premium.setPrefix(getColor(Ranks.Premium));
|
|
Player.setPrefix(getColor(Ranks.Player));
|
|
|
|
Admin.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
|
|
SrDeveloper.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
|
|
Developer.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
|
|
SrModerator.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
|
|
HeadBuilder.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
|
|
Moderator.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
|
|
Builder.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
|
|
Supporter.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
|
|
Youtuber.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
|
|
Premium.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
|
|
Player.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
|
|
|
|
|
|
}
|
|
|
|
public void setLabyModFeatures(HashMap<LabyModFeature, Boolean> list) {
|
|
HashMap<String, Boolean> temp = new HashMap<>();
|
|
for(LabyModFeature feature : list.keySet()) {
|
|
temp.put(feature.name(), list.get(feature));
|
|
}
|
|
ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
|
|
try {
|
|
ObjectOutputStream out = new ObjectOutputStream(byteOut);
|
|
out.writeObject(temp);
|
|
ByteBuf byteBuf = Unpooled.copiedBuffer(byteOut.toByteArray());
|
|
PacketDataSerializer packetDataSerializer = new PacketDataSerializer(byteBuf);
|
|
PacketPlayOutCustomPayload packet = new PacketPlayOutCustomPayload("LABYMOD", packetDataSerializer);
|
|
getHandle().playerConnection.sendPacket(packet);
|
|
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
}
|
|
|
|
public enum LabyModFeature{
|
|
FOOD("FOOD", 0),
|
|
GUI("GUI", 1),
|
|
NICK("NICK", 2),
|
|
BLOCKBUILD("BLOCKBUILD", 3),
|
|
CHAT("CHAT", 4),
|
|
EXTRAS("EXTRAS", 5),
|
|
ANIMATIONS("ANIMATIONS", 6),
|
|
POTIONS("POTIONS", 7),
|
|
ARMOR("ARMOR", 8),
|
|
DAMAGEINDICATOR("DAMAGEINDICATOR", 9),
|
|
MINIMAP_RADAR("MINIMAP_RADAR", 10);
|
|
|
|
private LabyModFeature(String s, int n) {
|
|
|
|
}
|
|
}
|
|
} |