Elixium/Raxen
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

gq to me

Browse source 
change of domain name
This commit is contained in:
unurled 2022-06-09 23:27:04 +02:00
parent 1717733fab
commit b24ddfba27
117 changed files with 1255 additions and 1255 deletions
Download patch file Download diff file Expand all files Collapse all files

103
src/main/java/me/unurled/raxen/utils/DungeonUtils.java Normal file
View file

@ -0,0 +1,103 @@
package me.unurled.raxen.utils;
import me.unurled.raxen.Raxen;
import me.unurled.raxen.components.dungeons.Gate;
import me.unurled.raxen.components.dungeons.Rank;
import me.unurled.raxen.components.dungeons.Types;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.jetbrains.annotations.NotNull;
import java.util.HashMap;
import java.util.Random;
public class DungeonUtils {
/**
* get the radius from the rank of a dungeon
*/
public static Integer getRadiusFromRank(@NotNull Rank rank) {
Integer radius = 1;
switch (rank) {
case F:
radius = 4;
case E:
radius = 5;
case D:
radius = 8;
case C:
radius = 10;
case B:
radius = 15;
case A:
radius = 20;
case S:
radius = 30;
case SS:
radius = 40;
case SSS:
radius = 50;
case WORLD:
radius = 100;
case UNBEATABLE:
radius = 200;
case NOT_DEFINED:
radius = 1000;
}
return radius;
}
/**
* used to spawn monster based on random
*/
public static void fromTypeToMonster(Types types, Rank rank) {
Random r = new Random();
r.nextInt();
}
/**
* if a gate is in range of the player
* @return boolean
*/
public static Boolean isInRange(Location loc) {
Raxen main = (Raxen) Bukkit.getServer().getPluginManager().getPlugin("Raxen");
HashMap<Gate, Location> gats = main.getManager().getDungeonsManager().getGates();
for (Gate g : gats.keySet()) {
Double x = g.getLoc().getX();
Double y = g.getLoc().getY();
Double z = g.getLoc().getZ();
Double radius = Double.valueOf(g.getPortalRadius());
if (loc.getX() < x+radius && loc.getX() > x-radius) {
if (loc.getY() < y+radius && loc.getY() > y-radius) {
if (loc.getZ() < z+radius && loc.getZ() > z-radius) {
return true;
}
}
}
}
return false;
}
/**
* if a gate is in range of the player
* @return the gates which is in range
*/
public static Gate whichIsInRange(Location loc) {
Raxen main = (Raxen) Bukkit.getServer().getPluginManager().getPlugin("Raxen");
HashMap<Gate, Location> gats = main.getManager().getDungeonsManager().getGates();
for (Gate g : gats.keySet()) {
Double x = g.getLoc().getX();
Double y = g.getLoc().getY();
Double z = g.getLoc().getZ();
Double radius = Double.valueOf(g.getPortalRadius());
if (loc.getX() < x+radius && loc.getX() > x-radius) {
if (loc.getY() < y+radius && loc.getY() > y-radius) {
if (loc.getZ() < z+radius && loc.getZ() > z-radius) {
return g;
}
}
}
}
return null;
}
}

65
src/main/java/me/unurled/raxen/utils/EntityAttributes.java Normal file
View file

@ -0,0 +1,65 @@
package me.unurled.raxen.utils;
import me.unurled.raxen.Raxen;
import me.unurled.raxen.components.entity.player.attributes.Attribute;
import me.unurled.raxen.manager.entity.PlayerManager;
import org.bukkit.Bukkit;
import org.bukkit.entity.Entity;
import java.util.Objects;
import static me.unurled.raxen.utils.Utils.debug;
public class EntityAttributes {
/**
* get every attribute of an entity
* @param e an entity
* @return an instance of attribute
*/
public static Attribute getAttribute(Entity e) {
int maxHealth, health, itemHealth, defense, itemDefense, speed, itemSpeed, strength, itemStrength, maxMana, mana, itemMana, luck, itemLuck;
PlayerManager pm = ((Raxen) Objects.requireNonNull(Bukkit.getPluginManager().getPlugin("Raxen"))).getManager().getPlayerManager();
defense= pm.getDefense().get(e);
maxMana = pm.getMaxMana().get(e);
itemDefense= pm.getItemDefense().get(e);
health = pm.getHealth().get(e);
itemHealth = pm.getItemHealth().get(e);
mana = pm.getMana().get(e);
speed = pm.getSpeed().get(e);
itemLuck = pm.getItemLuck().get(e);
strength = pm.getStrength().get(e);
luck = pm.getLuck().get(e);
maxHealth = pm.getMaxHealth().get(e);
itemStrength = pm.getItemStrength().get(e);
itemSpeed = pm.getItemSpeed().get(e);
itemMana = pm.getItemMana().get(e);
return new Attribute(maxHealth, health, itemHealth, defense, itemDefense, speed, itemSpeed, strength, itemStrength, maxMana, mana, itemMana, luck, itemLuck);
}
/**
* set each attribute
*/
public static void setAttributes(Entity e, int maxHealth, int health, int itemHealth, int defense, int itemDefense, int speed, int itemSpeed, int strength, int itemStrength, int maxMana, int mana, int itemMana, int luck, int itemLuck) {
PlayerManager pm = ((Raxen) Objects.requireNonNull(Bukkit.getPluginManager().getPlugin("Raxen"))).getManager().getPlayerManager();
pm.getDefense().set(e, defense);
pm.getMaxMana().set(e, maxMana);
pm.getItemDefense().set(e, itemDefense);
pm.getHealth().set(e, health);
pm.getItemHealth().set(e, itemHealth);
pm.getMana().set(e, mana);
pm.getSpeed().set(e, speed);
pm.getItemLuck().set(e, itemLuck);
pm.getStrength().set(e, strength);
pm.getLuck().set(e, luck);
pm.getMaxHealth().set(e, maxHealth);
pm.getItemStrength().set(e, itemStrength);
pm.getItemSpeed().set(e, itemSpeed);
pm.getItemMana().set(e, itemMana);
debug("Speedometer " + speed);
for (String s : pm.getAttribute().keySet()) {
debug(s + " " + pm.getAttribute().get(s).get(e).toString());
}
}
}

557
src/main/java/me/unurled/raxen/utils/Items.java Normal file
View file

@ -0,0 +1,557 @@
package me.unurled.raxen.utils;
import com.google.gson.Gson;
import de.tr7zw.nbtapi.NBTItem;
import me.unurled.raxen.Raxen;
import me.unurled.raxen.components.items.NBT;
import net.kyori.adventure.text.Component;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemFlag;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.PlayerInventory;
import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.util.io.BukkitObjectInputStream;
import org.bukkit.util.io.BukkitObjectOutputStream;
import org.jetbrains.annotations.NotNull;
import org.yaml.snakeyaml.external.biz.base64Coder.Base64Coder;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.*;
import static me.unurled.raxen.utils.Utils.*;
public class Items {
/**
* create an item with @param
* @param material the item material
* @param amount the amount of the itemstack
* @param glow if the item glows or not
* @param unb if the item is unbreakable
* @param name the name of the item
* @param lore the lore of the item
* @return the created itemstack
*/
public static @NotNull ItemStack createItem(Material material, int amount, boolean glow, boolean unb, String name, String... lore) {
ItemStack item = new ItemStack(material, amount);
ItemMeta itemMeta = item.getItemMeta();
if(name != null) {
itemMeta.displayName(colorComp(name));
}
if(lore != null) {
List<Component> list = new ArrayList<>();
for(String string : lore) {
list.add(colorComp(string));
}
itemMeta.lore(list);
}
if(glow) {
itemMeta.addItemFlags(ItemFlag.HIDE_ENCHANTS);
itemMeta.addEnchant(Enchantment.DURABILITY, 1, true);
}
if(unb) {
itemMeta.setUnbreakable(true);
}
item.setItemMeta(itemMeta);
return item;
}
/**
* edit an item with provided @param
* @param item the item to modify
* @param name the new name of the item
* @param amount the new amount
* @param lore the new lore
* @return the modified itemstack
*/
public static @NotNull ItemStack editItem(ItemStack item, String name, int amount, List<Component> lore) {
if(amount == 0) {
amount = 1;
}
item.setAmount(amount);
ItemMeta itemMeta = item.getItemMeta();
if (name != null) {
itemMeta.displayName(Component.text(name));
}
itemMeta.lore(lore);
item.setItemMeta(itemMeta);
return item;
}
/**
* the basic close gui button
* @return a barrier block itemstack named close
*/
public static @NotNull ItemStack closeItem () {
ItemStack close = createItem(Material.BARRIER, 1, false, false, colorString("<red>CLOSE</red>"));
ItemMeta clo = close.getItemMeta();
clo.setCustomModelData(1);
close.setItemMeta(clo);
return close;
}
/**
* fill item in chest and guis
* @return a grey glass pane named nothing
*/
public static @NotNull ItemStack greyPane() {
return createItem(Material.GRAY_STAINED_GLASS_PANE, 1, false, true, "");
}
/**
* serialize item
* @param it an itemstack
* @param slot the slot it was in the inventory
* @return the serialized string
*/
public static @NotNull String itemStackSerialize(ItemStack it, @NotNull Integer slot) {
String str = "";
str = itemTo64(it);
str = str + "@#SLOT#" + (slot-1);
return str;
}
/**
* Serelize the PlayerInventory
* @param inv a player inventory
* @return return a serelized string
*/
public static @NotNull String itemStackSer(PlayerInventory inv) {
List<String> list = new ArrayList<>();
Integer i = 0;
for (ItemStack it : inv.getContents()) {
String str = "";
str = itemTo64(it);
if (it != null) {
if (isContained(it, inv.getArmorContents())) {
str = str + "@#SLOT#" + getWhichArmor(it.getType());
} else {
i++;
str = str + "@#SLOT#" + (i - 1);
}
}
list.add(str);
}
return listItemStackSerialize(list);
}
/**
* if item is in its
* @param item an Itemstack
* @param its an Itemstack[]
* @return return if item is in its
*/
public static boolean isContained(ItemStack item, ItemStack[] its) {
for (ItemStack it : its) {
if (it == item) {
return true;
}
}
return false;
}
/**
* Get which armor the type is
* @param type a material type
* @return the armor type or null
*/
public static String getWhichArmor(Material type) {
String name = type.name();
if (name.contains("HELMET") || name.contains("helmet")) {
return "HELMET";
} else if (name.contains("CHESTPLATE") || name.contains("chestplate")) {
return "CHESTPLATE";
} else if (name.contains("LEGGINGS") || name.contains("leggins")) {
return "LEGGINGS";
} else if (name.contains("BOOTS") || name.contains("boots")) {
return "BOOTS";
}
return null;
}
/**
* a class that represent the itemstack deserialized.
*/
public static class itemStackDeserializeResult {
int slot;
ItemStack it;
String armor;
/**
* custructor
* @param slot an int of the slot of the item
* @param it the item which is deserialized.
*/
public itemStackDeserializeResult(Integer slot, ItemStack it) {
this.slot = slot;
this.it = it;
}
public itemStackDeserializeResult(Integer slot, ItemStack it, String armor) {
this.slot = slot;
this.it = it;
this.armor = armor;
}
}
/**
* a class that represent a list of itemstack deserialized.
*/
public static class itemStackListDeserilize {
HashMap<Integer, ItemStack> inv;
/**
* constructor
* @param inv a list of itemstack with their slot.
*/
public itemStackListDeserilize(HashMap<Integer, ItemStack> inv) {
this.inv = inv;
}
}
/**
* deserilize items
* @param str the serilized item
* @return a deserialized item instance
*/
public static @NotNull Items.itemStackDeserializeResult itemStackDeserilize(@NotNull String str) {
List<String> mapp = Arrays.asList(str.split("@#SLOT#"));
Gson gson = new Gson();
ItemStack it = new ItemStack(Material.AIR);
Integer slot = 0;
String armor = null;
debug("full item " + str);
for (String s : mapp) {
if(s != null) {
try {
it = itemFrom64(s);
} catch (Exception e) {
if (!s.equals("")) {
debug("slot " + s);
try {
slot = Integer.parseInt(s);
} catch (NumberFormatException nfe) {
armor = s;
}
}
}
}
}
itemStackDeserializeResult itt;
if (armor != null) {
itt = new itemStackDeserializeResult(slot, it, armor);
} else {
itt = new itemStackDeserializeResult(slot, it);
}
return itt;
}
/**
* a list of serialized item in one string
* @param list the list of all serialized item
* @return a string
*/
public static String listItemStackSerialize(@NotNull List<String> list) {
Gson gson = new Gson();
String str = "";
for(String a : list) {
str = str + "@#NEW_ITEM#" + a;
}
return str;
}
/**
* deserialize item
* @param str a list of all serialized item
* @return a list of itemstack with their slot
*/
public static @NotNull HashMap<Integer, ItemStack> mapItemStackDeserialize(@NotNull String str) {
Gson gson = new Gson();
List<String> map = Arrays.asList(str.split("@#NEW_ITEM#"));
HashMap<Integer, ItemStack> inv = new HashMap<>();
ArrayList<ItemStack> items = new ArrayList<ItemStack>();
for(String s : map) {
ItemStack itt;
Integer slot;
if(s != null) {
itemStackDeserializeResult itm = itemStackDeserilize(s);
itt = itm.it;
if (itt != null && itt.getType() != Material.AIR) {
items.add(itt);
}
slot = itm.slot;
inv.put(slot, itt);
}
}
ItemStack[] it = items.toArray(new ItemStack[0]);
return inv;
}
/**
* deserialize item
* @param str a list of all serialized item
* @return a list of itemstack with their slot
*/
public static @NotNull List<itemStackDeserializeResult> listItemStackDeserialize(@NotNull String str) {
Gson gson = new Gson();
List<String> map = Arrays.asList(str.split("@#NEW_ITEM#"));
List<itemStackDeserializeResult> inv = new ArrayList<>();
ArrayList<ItemStack> items = new ArrayList<ItemStack>();
for(String s : map) {
ItemStack itt;
Integer slot;
if(s != null) {
itemStackDeserializeResult itm = itemStackDeserilize(s);
itt = itm.it;
if (itt != null && itt.getType() != Material.AIR) {
items.add(itt);
}
}
}
return inv;
}
/**
* set all item in the list to their slot in inv
* @param list a list of item with their slot
* @param inv the destined inventory
* @return the inv
*/
public static Inventory setItemsToInventory(@NotNull HashMap<Integer, ItemStack> list, Inventory inv) {
for (Map.Entry<Integer, ItemStack> entry : list.entrySet()) {
inv.setItem(entry.getKey(), entry.getValue());
}
return inv;
}
/**
* set all item in the list to their slot in inv
* @param list a list of item with their slot
* @param inv the destined inventory
* @return the inv
*/
public static PlayerInventory setItemsToInventory(@NotNull List<itemStackDeserializeResult> list, PlayerInventory inv) {
Inventory invv = Bukkit.createInventory(null, 54);
for (itemStackDeserializeResult itm : list) {
if (itm.armor != null) {
setArmorItem(inv, itm.it);
} else {
inv.setItem(itm.slot, itm.it);
}
}
return inv;
}
public static void setArmorItem(PlayerInventory inv, ItemStack item) {
String name = item.getType().name();
if (name.contains("HELMET")) {
inv.setHelmet(item);
} else if (name.contains("CHESTPLATE")) {
inv.setChestplate(item);
} else if (name.contains("LEGGINGS")) {
inv.setLeggings(item);
} else if (name.contains("BOOTS")) {
inv.setBoots(item);
}
}
/**
* set all item in the list to their slot in inv
* @param list a list of item with their slot
* @param inv the player inventory
* @return the inv
*/
public static PlayerInventory setItemsToInventory(@NotNull HashMap<Integer, ItemStack> list, PlayerInventory inv) {
for (Map.Entry<Integer, ItemStack> entry : list.entrySet()) {
if (entry.getKey() == 40) {
inv.setHelmet(entry.getValue());
} else if (entry.getKey() == 39) {
inv.setChestplate(entry.getValue());
} else if (entry.getKey() == 38) {
inv.setLeggings(entry.getValue());
} else if (entry.getKey() == 37) {
inv.setBoots(entry.getValue());
} else if (entry.getKey() == 41) {
inv.setItemInOffHand(entry.getValue());
}
else {
inv.setItem(entry.getKey(), entry.getValue());
}
}
return inv;
}
/**
* serialize an item
* @param stack the item
* @return a string
* @throws IllegalStateException stream errors
*/
private static @NotNull String itemTo64(ItemStack stack) throws IllegalStateException {
try {
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
BukkitObjectOutputStream dataOutput = new BukkitObjectOutputStream(outputStream);
dataOutput.writeObject(stack);
// Serialize that array
dataOutput.close();
return Base64Coder.encodeLines(outputStream.toByteArray());
}
catch (Exception e) {
throw new IllegalStateException("Unable to save item stack.", e);
}
}
/**
* deserialize item for string to itemstack
* @param data string
* @return itemstack
* @throws IOException stream error
*/
private static ItemStack itemFrom64(String data) throws IOException {
try {
ByteArrayInputStream inputStream = new ByteArrayInputStream(Base64Coder.decodeLines(data));
BukkitObjectInputStream dataInput = new BukkitObjectInputStream(inputStream);
try {
return (ItemStack) dataInput.readObject();
} finally {
dataInput.close();
}
}
catch (ClassNotFoundException e) {
throw new IOException("Unable to decode class types.", e);
}
}
/**
* return in correct naming each attributes,
* @param str the nbt attribute
* @return the good name
*/
@Deprecated
public static @NotNull String attributes(@NotNull String str) {
String stt = "";
if(str.contains("SPEED")) {
stt = "<white>Speed";
return stt;
}
if(str.contains("STRENGTH")) {
stt = "<dark_red>Strength";
return stt;
}
if(str.contains("HEALTH")) {
stt = "<red>Health";
return stt;
}
if(str.contains("DEFENSE")) {
stt = "<dark_blue>Defense";
return stt;
}
else {
stt = "None";
return stt;
}
}
/**
* set the attribute of an item
* @param main a main instance
* @param str the attribute
* @param nb how many of the attribute
* @param nbti the item
* @return an item
*/
@Deprecated
public static NBTItem setAttributes(Raxen main, @NotNull String str, Integer nb, NBTItem nbti) {
switch (str) {
case "SPEED":
nbti.setInteger(NBT.SPEED, nb);
case "STRENGTH":
nbti.setInteger(NBT.STRENGTH, nb);
case "HEALTH":
nbti.setInteger(NBT.HEALTH, nb);
case "DEFENSE":
nbti.setInteger(NBT.DEFENSE, nb);
case "LUCK":
nbti.setInteger(NBT.LUCK, nb);
case "MANA":
nbti.setInteger(NBT.MANA, nb);
default:
error((Raxen) Bukkit.getPluginManager().getPlugin("Raxen"), "Cant set Attributes with an unknown attribute.");
}
return nbti;
}
/**
* set the lore from the nbt
* @param it an itemstack
* @return the modified item
*/
@Deprecated
public static @NotNull ItemStack setLoreFromNBT(@NotNull ItemStack it) {
ItemMeta itm = it.getItemMeta();
List<Component> lore = new ArrayList<>();
for (Component cp : itm.lore()) {
lore.add(cp);
}
NBTItem nbti = new NBTItem(it);
if(nbti.hasKey(NBT.SPEED)) {
if(lore.size() > 2) {
lore.add(2, colorComp(attributes("SPEED")).append(Component.text(nbti.getInteger(NBT.SPEED))));
} else {
lore.add(colorComp(attributes("SPEED")).append(Component.text(nbti.getInteger(NBT.SPEED))));
}
}
if(nbti.hasKey(NBT.HEALTH)) {
if(lore.size() > 1) {
lore.add(1, colorComp(attributes("HEALTH")).append(Component.text(nbti.getInteger(NBT.HEALTH))));
} else {
lore.add(colorComp(attributes("HEALTH")).append(Component.text(nbti.getInteger(NBT.HEALTH))));
}
}
if(nbti.hasKey(NBT.DEFENSE)) {
if(lore.size() > 3) {
lore.add(3, colorComp(attributes("DEFENSE")).append(Component.text(nbti.getInteger(NBT.DEFENSE))));
} else {
lore.add(colorComp(attributes("DEFENSE")).append(Component.text(nbti.getInteger(NBT.DEFENSE))));
}
}
if(nbti.hasKey(NBT.STRENGTH)) {
if(lore.size() > 3) {
lore.add(3, colorComp(attributes("STRENGTH")).append(Component.text(nbti.getInteger(NBT.STRENGTH))));
} else {
lore.add(colorComp(attributes("STRENGTH")).append(Component.text(nbti.getInteger(NBT.STRENGTH))));
}
}
if(nbti.hasKey(NBT.MANA)) {
if(lore.size() > 3) {
lore.add(3, colorComp(attributes("MANA")).append(Component.text(nbti.getInteger(NBT.MANA))));
} else {
lore.add(colorComp(attributes("MANA")).append(Component.text(nbti.getInteger(NBT.MANA))));
}
}
if(nbti.hasKey(NBT.LUCK)) {
if(lore.size() > 3) {
lore.add(3, colorComp(attributes("LUCK")).append(Component.text(nbti.getInteger(NBT.LUCK))));
} else {
lore.add(colorComp(attributes("LUCK")).append(Component.text(nbti.getInteger(NBT.LUCK))));
}
}
itm.lore(lore);
it.setItemMeta(itm);
return it;
}
public static ItemStack customModelData(ItemStack it, Integer in) {
ItemMeta itm = it.getItemMeta();
itm.setCustomModelData(in);
it.setItemMeta(itm);
return it;
}
}

71
src/main/java/me/unurled/raxen/utils/Reload.java Normal file
View file

@ -0,0 +1,71 @@
package me.unurled.raxen.utils;
import me.unurled.raxen.Raxen;
import net.kyori.adventure.text.Component;
import org.bukkit.Bukkit;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.server.ServerListPingEvent;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
import static me.unurled.raxen.utils.Utils.colorTextComp;
public class Reload implements Listener {
private static FileConfiguration config = Raxen.getPlugin().getConfig();
private static boolean serverReloading = true;
/**
* kick all online players
*/
public static void kickAll() {
for(Player player : Bukkit.getOnlinePlayers()) {
player.kick(colorTextComp(Raxen.getPrefix() + "\n<red>Server is Restarting</red>\n <red>Please Wait a few Minutes to reconnect.</red>"));
}
}
/**
* change the server ping list
* @param e the server ping list event
*/
@EventHandler
public static void pingList(ServerListPingEvent e) {
try {
setPingList(e);
} catch (IOException ex) {
throw new RuntimeException(ex);
}
}
/**
* update ping list
* @param e the ping event
* @throws IOException file writing
*/
public static void setPingList(ServerListPingEvent e) throws IOException {
if(serverReloading) {
List<String> newLines = new ArrayList<>();
for(String line : Files.readAllLines(Paths.get("server.properties"), StandardCharsets.UTF_8)) {
if(line.contains("motd=")) {
newLines.add("motd=" + config.get("motd-reload"));
} else {
newLines.add(line);
}
}
Files.write(Paths.get("server.properties"), newLines, StandardCharsets.UTF_8);
e.motd(Component.text((String) config.get("motd-reload")));
} else {
e.motd(Component.text((String) config.get("motd")));
}
}
}

33
src/main/java/me/unurled/raxen/utils/TabApi.java Normal file
View file

@ -0,0 +1,33 @@
package me.unurled.raxen.utils;
import com.comphenix.protocol.PacketType;
import com.comphenix.protocol.ProtocolManager;
import com.comphenix.protocol.events.ListenerPriority;
import com.comphenix.protocol.events.PacketAdapter;
import me.unurled.raxen.Raxen;
public class TabApi {
private ProtocolManager protocolManager;
private Raxen main;
/**
* instance of tabapi
* @param main running instance of main
*/
public TabApi(Raxen main) {
this.main = main;
this.protocolManager = main.getProtocolManager();
}
/**
* stuff for protocolmanager, used to add player and infos to the ping list
*/
public void packetListener() {
protocolManager.addPacketListener(
new PacketAdapter(main, ListenerPriority.NORMAL, PacketType.Play.Server.PLAYER_INFO) {
}
);
}
}

369
src/main/java/me/unurled/raxen/utils/Utils.java Normal file
View file

@ -0,0 +1,369 @@
package me.unurled.raxen.utils;
import me.unurled.raxen.Raxen;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.TextComponent;
import net.kyori.adventure.text.minimessage.MiniMessage;
import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
import net.kyori.adventure.text.minimessage.tag.standard.StandardTags;
import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.command.CommandSender;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.entity.Player;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;
import org.jetbrains.annotations.NotNull;
import java.io.IOException;
import java.nio.file.*;
public class Utils {
/**
* convert a string with mini-message formatting to a colored Component
* @param stringToComponent a string
* @return a component
*/
public static @NotNull Component colorComp(String stringToComponent) {
MiniMessage minimessage = MiniMessage.builder()
.tags(TagResolver.builder()
.resolver(StandardTags.color())
.resolver(StandardTags.decorations())
.resolver(StandardTags.reset())
.build()
)
.build();
return minimessage.deserialize(stringToComponent);
}
/**
* convert a string with mini-message formatting to a colored TextComponent
* @param stringToComponent a string
* @return a component
*/
public static @NotNull TextComponent colorTextComp(String stringToComponent) {
MiniMessage minimessage = MiniMessage.builder()
.tags(TagResolver.builder()
.resolver(StandardTags.color())
.resolver(StandardTags.decorations())
.resolver(StandardTags.reset())
.build()
)
.build();
return (TextComponent) minimessage.deserialize(stringToComponent);
}
/**
* change the mini-message colorized format to the legacy format, with §
* @param string a string
* @return a colored string
*/
public static @NotNull String colorString(String string) {
MiniMessage minimessage = MiniMessage.builder()
.tags(TagResolver.builder()
.resolver(StandardTags.color())
.resolver(StandardTags.decorations())
.resolver(StandardTags.reset())
.build()
)
.build();
return LegacyComponentSerializer.legacyAmpersand().serialize(minimessage.deserialize(string));
}
/**
* change the mini-message colorized format to the legacy format, with §
* @param string a string
* @return a String
*/
public static String coloredString(String string) {
MiniMessage minimessage = MiniMessage.builder()
.tags(TagResolver.builder()
.resolver(StandardTags.color())
.resolver(StandardTags.decorations())
.resolver(StandardTags.reset())
.build()
)
.build();
return ChatColor.translateAlternateColorCodes('&', LegacyComponentSerializer.legacyAmpersand()
.serialize(minimessage.deserialize(string)));
}
/**
* transform a text-component to a string
* @param comp a string
* @return a String
*/
public static String textCompToString(TextComponent comp) {
MiniMessage minimessage = MiniMessage.builder()
.tags(TagResolver.builder()
.resolver(StandardTags.color())
.resolver(StandardTags.decorations())
.resolver(StandardTags.reset())
.build()
)
.build();
return ChatColor.translateAlternateColorCodes('&', LegacyComponentSerializer.legacyAmpersand()
.serialize(comp));
}
/**
* Strips all color from a string.
* @param string the string that want's to be decolored.
* @return a decolored string
*/
public static String decolor(String string) {
return MiniMessage.miniMessage().stripTags(string);
}
/**
* debug output to console if debug is set to true in config
* @param main Raxen instance
* @param strings output to console
*/
public static void debug(Raxen main, String... strings) {
FileConfiguration config = main.getConfig();
if(config.getBoolean("debug")) {
for(String string : strings) {
main.getLogger().info(string);
}
}
}
/**
* debug output to console if debug is set to true in config
* @param strings output to console
*/
public static void debug(String... strings) {
Raxen main = (Raxen) Bukkit.getPluginManager().getPlugin("Raxen");
assert main != null;
FileConfiguration config = main.getConfig();
if(config.getBoolean("debug")) {
for(String string : strings) {
main.getLogger().info(string);
}
}
}
/**
* debug output to console if debug is set to true in config
* @param config main file config
* @param strings ouput to console
*/
public static void debug(FileConfiguration config, String... strings) {
Raxen main = (Raxen) Bukkit.getPluginManager().getPlugin("Raxen");
assert main != null;
if(config.getBoolean("debug")) {
for(String string : strings) {
main.getLogger().info(string);
}
}
}
/**
* Log the strings to the console
* @param main a main instance running
* @param strings string that want to be outputted.
*/
public static void log(Raxen main, String... strings) {
for(String string : strings) {
main.getLogger().info(string);
}
}
/**
* Log the strings to the console
* @param strings string that want to be outputted.
*/
public static void log(String... strings) {
Raxen main = (Raxen) Bukkit.getPluginManager().getPlugin("Raxen");
assert main != null;
for(String string : strings) {
main.getLogger().info(string);
}
}
/**
* Log the TextComponent to the console
* @param comp TextComponent that want to be outputted.
*/
public static void log(TextComponent... comp) {
Raxen main = (Raxen) Bukkit.getPluginManager().getPlugin("Raxen");
assert main != null;
for(TextComponent string : comp) {
main.getServer().sendMessage(string);
}
}
/**
* Warns strings to the console using the logger
* @param strings to warn message
*/
public static void warn(String... strings) {
Raxen main = (Raxen) Bukkit.getPluginManager().getPlugin("Raxen");
assert main != null;
for(String string : strings) {
main.getLogger().warning(string);
}
}
/**
* Warns strings to the console using the logger
* @param strings to warn message
* @param main a running instance
*/
public static void warn(Raxen main, String... strings) {
for(String string : strings) {
main.getLogger().warning(string);
}
}
/**
* Error strings to the console using the logger
* @param strings to error message
*/
public static void error(String... strings) {
Raxen main = (Raxen) Bukkit.getPluginManager().getPlugin("Raxen");
assert main != null;
for(String string : strings) {
main.getLogger().severe(string);
}
}
/**
* Error strings to the console using the logger
* @param strings to error message
* @param main a main instance running
*/
public static void error(Raxen main, String... strings) {
for(String string : strings) {
main.getLogger().severe(string);
}
}
/**
* message strings to player.
* @param player an online player
* @param strings strings that will be sent.
*/
public static void msgPlayer(Player player, String... strings) {
for(String string : strings) {
player.sendMessage(colorComp(string));
}
}
/**
* message textComponent to player.
* @param player an online player
* @param comp textComponent that will be sent.
*/
public static void msgPlayer(Player player, TextComponent comp) {
player.sendMessage(colorComp(PlainTextComponentSerializer.plainText().serialize(comp)));
}
/**
* message the command sender with textComponent.
* @param player the command sender
* @param textComponent message
*/
public static void msgSender(CommandSender player, TextComponent textComponent) {
player.sendMessage(colorComp(PlainTextComponentSerializer.plainText().serialize(textComponent)));
}
/**
* message the command sender with strings.
* @param player the command sender
* @param strings message
*/
public static void msgSender(CommandSender player, String... strings) {
for(String string : strings) {
player.sendMessage(colorComp(string));
}
}
/**
* fill an inventory with grey glass pane.
* @param inv an inventory
* @return the inventory filled
*/
public static Inventory fillGreyPane(Inventory inv) {
int in = -1;
for (ItemStack it : inv) {
in++;
if (it == null || it.getType() == Material.AIR) {
inv.setItem(in, Items.greyPane());
}
}
return inv;
}
/**
* output message when player have no perms
* @return a component
*/
public static Component noPerms() {
return colorComp("<red>You don't have the permission to use this feature.");
}
/**
* error message output to player
* @return a component
*/
public static Component error() {
return colorComp("<red>An Error has occurred. Please retry or contact an Admin.");
}
public static void errorConsoleSender(CommandSender sender) {
sender.sendMessage(colorComp("<red>Can't use this command as the console.</red>"));
}
/**
* Copy folder from sourceDirectoryLocation to destinationDirectoryLocation
* @param sourceDirectoryLocation the source directory
* @param destinationDirectoryLocation the copy location
* @throws IOException exception with coping data
*/
public static void copyDirectory(String sourceDirectoryLocation, String destinationDirectoryLocation) throws IOException {
Files.walk(Paths.get(sourceDirectoryLocation))
.forEach(source -> {
Path destination = Paths.get(destinationDirectoryLocation, source.toString()
.substring(sourceDirectoryLocation.length()));
try {
Files.copy(source, destination);
} catch (IOException e) {
e.printStackTrace();
}
});
}
/**
* remove path directory
* @param path removed folder
* @throws IOException error with handling data
*/
public static void removeDirectory(Path path) throws IOException {
if (Files.isDirectory(path, LinkOption.NOFOLLOW_LINKS)) {
try (DirectoryStream<Path> entries = Files.newDirectoryStream(path)) {
for (Path entry : entries) {
removeDirectory(entry);
}
}
}
Files.delete(path);
}
public static boolean isInt(String strNum) {
if (strNum == null) {
return false;
}
try {
double d = Integer.parseInt(strNum);
} catch (NumberFormatException nfe) {
return false;
}
return true;
}
}

23
src/main/java/me/unurled/raxen/utils/libs/Citizens.java Normal file
View file

@ -0,0 +1,23 @@
package me.unurled.raxen.utils.libs;
import me.unurled.raxen.Raxen;
import org.bukkit.entity.Entity;
public class Citizens {
private Raxen main;
public Citizens(Raxen main) {
this.main = main;
}
public boolean isNPC(Entity e) {
return e.hasMetadata("NPC");
}
/*
public void createNPC(EntityType type) {
NPC npc = CitizensAPI.getNPCRegistry().createNPC(type);
}
*/
}

24
src/main/java/me/unurled/raxen/utils/libs/LuckPerm.java Normal file
View file

@ -0,0 +1,24 @@
package me.unurled.raxen.utils.libs;
import lombok.Getter;
import me.unurled.raxen.Raxen;
import net.luckperms.api.LuckPerms;
import org.bukkit.Bukkit;
import org.bukkit.plugin.RegisteredServiceProvider;
public class LuckPerm {
private static RegisteredServiceProvider<LuckPerms> provider;
@Getter
private static LuckPerms api;
public LuckPerm(Raxen main) {
provider = Bukkit.getServicesManager().getRegistration(LuckPerms.class);
}
public static void register() {
if (provider != null) {
api = provider.getProvider();
}
}
}

47
src/main/java/me/unurled/raxen/utils/libs/MongoDB.java Normal file
View file

@ -0,0 +1,47 @@
package me.unurled.raxen.utils.libs;
import com.mongodb.ConnectionString;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import lombok.Getter;
import org.bson.Document;
import org.bukkit.Bukkit;
import org.bukkit.configuration.file.FileConfiguration;
import java.util.Objects;
import static me.unurled.raxen.utils.Utils.colorComp;
import static me.unurled.raxen.utils.Utils.log;
public class MongoDB {
@Getter
private MongoClient mongoClient;
@Getter
private MongoDatabase mongoDatabase;
@Getter
private MongoCollection<Document> mongoCollection;
@Getter
private MongoCollection<Document> mongoConfigs;
public void connect() {
FileConfiguration config = Objects.requireNonNull(Bukkit.getPluginManager().getPlugin("Raxen")).getConfig();
String uri = (String) config.get("url");
assert uri != null;
log("URI" + uri);
ConnectionString connectionString = new ConnectionString(uri);
mongoClient = MongoClients.create(connectionString);
mongoDatabase = mongoClient.getDatabase("Raxen");
mongoCollection = mongoDatabase.getCollection("player");
mongoConfigs = mongoDatabase.getCollection("config");
Bukkit.getConsoleSender().sendMessage(colorComp("<green>MongoDB connected!"));
}
public void close() {
mongoClient.close();
Bukkit.getConsoleSender().sendMessage(colorComp("<red>MongoDB disconnected!"));
}
}

24
src/main/java/me/unurled/raxen/utils/libs/Multiverse.java Normal file
View file

@ -0,0 +1,24 @@
package me.unurled.raxen.utils.libs;
import com.onarandombox.MultiverseCore.MultiverseCore;
import com.onarandombox.MultiverseCore.api.MVWorldManager;
import org.bukkit.Bukkit;
public class Multiverse {
private MultiverseCore core;
private MVWorldManager worldManager;
public Multiverse() {
this.core = (MultiverseCore) Bukkit.getServer().getPluginManager().getPlugin("Multiverse-Core");
this.worldManager = core.getMVWorldManager();
}
public MVWorldManager getWorldManager() {
return worldManager;
}
public MultiverseCore getMultiverseCore() {
return core;
}
}

46
src/main/java/me/unurled/raxen/utils/libs/Mysql.java Normal file
View file

@ -0,0 +1,46 @@
package me.unurled.raxen.utils.libs;
import me.unurled.raxen.Raxen;
import me.unurled.raxen.config.Config;
import me.unurled.raxen.manager.entity.StorageManager;
import org.bukkit.entity.Player;
import java.sql.SQLException;
public class Mysql {
private static String username;
private static String password;
private static String url;
private Raxen main;
private StorageManager sto;
private Config config;
public Mysql(Raxen main) {
this.main = main;
this.sto = main.getManager().getStorageManager();
this.config = main.getConf();
this.username = (String) config.getConfig().get("username");
this.url = (String) config.getConfig().get("url");
this.password = (String) config.getConfig().get("password");
}
public static void init() {
}
public static String get(Player player, String str) throws SQLException {
return "False";
}
public static void connect() {
}
public static void disconnect() {
}
}

18
src/main/java/me/unurled/raxen/utils/libs/PlaceHolderAPI.java Normal file
View file

@ -0,0 +1,18 @@
package me.unurled.raxen.utils.libs;
import me.unurled.raxen.Raxen;
public class PlaceHolderAPI {
private Raxen main;
public PlaceHolderAPI(Raxen main) {
this.main = main;
}
/*
public static setPlaceholders() {
}
*/
}

48
src/main/java/me/unurled/raxen/utils/libs/Vault.java Normal file
View file

@ -0,0 +1,48 @@
package me.unurled.raxen.utils.libs;
import lombok.Getter;
import me.unurled.raxen.Raxen;
import net.milkbowl.vault.economy.Economy;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.plugin.RegisteredServiceProvider;
import java.text.DecimalFormat;
import static me.unurled.raxen.utils.Utils.error;
public class Vault {
@Getter
private Economy econ = null;
//econ.depositPlayer(player,amount)
//econ.withdrawPlayer(player,amount)
//econ.getBalance(player);
private static Raxen main;
public Vault(Raxen main) {
this.main = main;
setupEconomy();
}
private void setupEconomy() {
if (main.getServer().getPluginManager().getPlugin("Vault") == null) {
error((Raxen) Bukkit.getPluginManager().getPlugin("Raxen"),"Need to install plugin Vault. (https://github.com/milkbowl/Vault)");
return;
}
RegisteredServiceProvider<Economy> rsp = main.getServer().getServicesManager().getRegistration(Economy.class);
if (rsp == null) {
error((Raxen) Bukkit.getPluginManager().getPlugin("Raxen"),"Some bug happend in the initialisation of Vault and Raxen.");
return;
}
econ = rsp.getProvider();
return;
}
public String getBalanceString(Player player) {
double bal = econ.getBalance(player);
DecimalFormat format = new DecimalFormat("#,###.00");
return format.format(bal);
}
}

5
src/main/java/me/unurled/raxen/utils/libs/WorldEdit.java Normal file
View file

@ -0,0 +1,5 @@
package me.unurled.raxen.utils.libs;
public class WorldEdit {
}